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

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

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

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

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

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_content_provider_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_ref_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_ref_storable_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_content_changed</NAME>
<RETURNS>void</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_write_mime_type_async</NAME>
<RETURNS>void</RETURNS>
GdkContentProvider     *provider, const char             *mime_type, GOutputStream          *stream, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_write_mime_type_finish</NAME>
<RETURNS>gboolean</RETURNS>
GdkContentProvider     *provider, GAsyncResult           *result, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_get_value</NAME>
<RETURNS>gboolean</RETURNS>
GdkContentProvider     *provider, GValue                 *value, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_for_value</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
const GValue           *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_typed</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GType                   type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_union</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GdkContentProvider    **providers, gsize                   n_providers
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_for_bytes</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
const char             *mime_type, GBytes                 *bytes
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_CONTENT_SERIALIZER</NAME>
#define GDK_TYPE_CONTENT_SERIALIZER         (gdk_content_serializer_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_SERIALIZER</NAME>
#define GDK_CONTENT_SERIALIZER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_CONTENT_SERIALIZER, GdkContentSerializer))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_SERIALIZER</NAME>
#define GDK_IS_CONTENT_SERIALIZER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_CONTENT_SERIALIZER))
</MACRO>
<USER_FUNCTION>
<NAME>GdkContentSerializeFunc</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer *serializer
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_mime_type</NAME>
<RETURNS>const char *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_gtype</NAME>
<RETURNS>GType</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_value</NAME>
<RETURNS>const GValue *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_output_stream</NAME>
<RETURNS>GOutputStream *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_priority</NAME>
<RETURNS>int</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_cancellable</NAME>
<RETURNS>GCancellable *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_user_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_set_task_data</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_task_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_success</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_error</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer, GError                 *error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_gtypes</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_mime_types</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_register_serializer</NAME>
<RETURNS>void</RETURNS>
GType                   type, const char             *mime_type, GdkContentSerializeFunc serialize, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_async</NAME>
<RETURNS>void</RETURNS>
GOutputStream          *stream, const char             *mime_type, const GValue           *value, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_finish</NAME>
<RETURNS>gboolean</RETURNS>
GAsyncResult           *result, GError                **error
</FUNCTION>
<STRUCT>
<NAME>GdkContentSerializer</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CURSOR</NAME>
#define GDK_TYPE_CURSOR              (gdk_cursor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CURSOR</NAME>
#define GDK_CURSOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_CURSOR, GdkCursor))
</MACRO>
<MACRO>
<NAME>GDK_IS_CURSOR</NAME>
#define GDK_IS_CURSOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_CURSOR))
</MACRO>
<FUNCTION>
<NAME>gdk_cursor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_texture</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkTexture      *texture, int              hotspot_x, int              hotspot_y, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_name</NAME>
<RETURNS>GdkCursor *</RETURNS>
const gchar     *name, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_fallback</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkCursor	  *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_name</NAME>
<RETURNS>const char *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_texture</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_x</NAME>
<RETURNS>int</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_y</NAME>
<RETURNS>int</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE</NAME>
#define GDK_TYPE_DEVICE         (gdk_device_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE</NAME>
#define GDK_DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE, GdkDevice))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE</NAME>
#define GDK_IS_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE))
</MACRO>
<ENUM>
<NAME>GdkInputSource</NAME>
typedef enum
{
  GDK_SOURCE_MOUSE,
  GDK_SOURCE_PEN,
  GDK_SOURCE_ERASER,
  GDK_SOURCE_CURSOR,
  GDK_SOURCE_KEYBOARD,
  GDK_SOURCE_TOUCHSCREEN,
  GDK_SOURCE_TOUCHPAD,
  GDK_SOURCE_TRACKPOINT,
  GDK_SOURCE_TABLET_PAD
} GdkInputSource;
</ENUM>
<ENUM>
<NAME>GdkDeviceType</NAME>
typedef enum {
  GDK_DEVICE_TYPE_MASTER,
  GDK_DEVICE_TYPE_SLAVE,
  GDK_DEVICE_TYPE_FLOATING
} GdkDeviceType;
</ENUM>
<MACRO>
<NAME>GDK_MAX_TIMECOORD_AXES</NAME>
#define GDK_MAX_TIMECOORD_AXES 128
</MACRO>
<STRUCT>
<NAME>GdkTimeCoord</NAME>
struct _GdkTimeCoord
{
  guint32 time;
  gdouble axes[GDK_MAX_TIMECOORD_AXES];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_device_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_has_cursor</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_source</NAME>
<RETURNS>GdkInputSource</RETURNS>
GdkDevice    *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_n_keys</NAME>
<RETURNS>gint</RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_key</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice       *device, guint            index_, guint           *keyval, GdkModifierType *modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_set_key</NAME>
<RETURNS>void</RETURNS>
GdkDevice      *device, guint           index_, guint           keyval, GdkModifierType modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_use</NAME>
<RETURNS>GdkAxisUse</RETURNS>
GdkDevice         *device, guint              index_
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_set_axis_use</NAME>
<RETURNS>void</RETURNS>
GdkDevice         *device, guint              index_, GdkAxisUse         use
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_state</NAME>
<RETURNS>void</RETURNS>
GdkDevice         *device, GdkSurface         *surface, gdouble           *axes, GdkModifierType   *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_surface_at_position</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDevice *device, double    *win_x, double    *win_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_history</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice         *device, GdkSurface         *surface, guint32            start, guint32            stop, GdkTimeCoord    ***events, gint              *n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_free_history</NAME>
<RETURNS>void</RETURNS>
GdkTimeCoord     **events, gint               n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_n_axes</NAME>
<RETURNS>gint</RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_names</NAME>
<RETURNS>char **</RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_value</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice       *device, gdouble         *axes, const char      *axis_label, gdouble         *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice         *device, gdouble           *axes, GdkAxisUse         use, gdouble           *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDevice      *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_associated_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_list_slave_devices</NAME>
<RETURNS>GList *</RETURNS>
GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_device_type</NAME>
<RETURNS>GdkDeviceType</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_last_event_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_vendor_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_product_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axes</NAME>
<RETURNS>GdkAxisFlags</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_num_touches</NAME>
<RETURNS>guint</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GdkDevice *device
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD</NAME>
#define GDK_TYPE_DEVICE_PAD         (gdk_device_pad_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_PAD</NAME>
#define GDK_DEVICE_PAD(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_PAD, GdkDevicePad))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_PAD</NAME>
#define GDK_IS_DEVICE_PAD(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_PAD))
</MACRO>
<ENUM>
<NAME>GdkDevicePadFeature</NAME>
typedef enum {
  GDK_DEVICE_PAD_FEATURE_BUTTON,
  GDK_DEVICE_PAD_FEATURE_RING,
  GDK_DEVICE_PAD_FEATURE_STRIP
} GdkDevicePadFeature;
</ENUM>
<FUNCTION>
<NAME>gdk_device_pad_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_groups</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad *pad
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_group_n_modes</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad *pad, gint          group_idx
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_features</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_feature_group</NAME>
<RETURNS>gint</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature, gint                 feature_idx
</FUNCTION>
<STRUCT>
<NAME>GdkDevicePad</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevicePadInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL</NAME>
#define GDK_TYPE_DEVICE_TOOL    (gdk_device_tool_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_TOOL</NAME>
#define GDK_DEVICE_TOOL(o)      (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_TOOL, GdkDeviceTool))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_TOOL</NAME>
#define GDK_IS_DEVICE_TOOL(o)   (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_TOOL))
</MACRO>
<ENUM>
<NAME>GdkDeviceToolType</NAME>
typedef enum {
  GDK_DEVICE_TOOL_TYPE_UNKNOWN,
  GDK_DEVICE_TOOL_TYPE_PEN,
  GDK_DEVICE_TOOL_TYPE_ERASER,
  GDK_DEVICE_TOOL_TYPE_BRUSH,
  GDK_DEVICE_TOOL_TYPE_PENCIL,
  GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
  GDK_DEVICE_TOOL_TYPE_MOUSE,
  GDK_DEVICE_TOOL_TYPE_LENS,
} GdkDeviceToolType;
</ENUM>
<FUNCTION>
<NAME>gdk_device_tool_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_serial</NAME>
<RETURNS>guint64</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_hardware_id</NAME>
<RETURNS>guint64</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_tool_type</NAME>
<RETURNS>GdkDeviceToolType</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<STRUCT>
<NAME>GdkDeviceTool</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DISPLAY</NAME>
#define GDK_TYPE_DISPLAY              (gdk_display_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY</NAME>
#define GDK_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY, GdkDisplay))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY</NAME>
#define GDK_IS_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY))
</MACRO>
<FUNCTION>
<NAME>gdk_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_open</NAME>
<RETURNS>GdkDisplay *</RETURNS>
const gchar *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_device_is_grabbed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display, GdkDevice   *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_beep</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_sync</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_flush</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_close</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_closed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_composited</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_rgba</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_event</NAME>
<RETURNS>GdkEvent *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_peek_event</NAME>
<RETURNS>GdkEvent *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_put_event</NAME>
<RETURNS>void</RETURNS>
GdkDisplay     *display, GdkEvent       *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_has_pending</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default</NAME>
<RETURNS>GdkDisplay *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_group</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_primary_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_shapes</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_input_shapes</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_notify_startup_complete</NAME>
<RETURNS>void</RETURNS>
GdkDisplay    *display, const gchar   *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_startup_notification_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_app_launch_context</NAME>
<RETURNS>GdkAppLaunchContext *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_list_seats</NAME>
<RETURNS>GList *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_n_monitors</NAME>
<RETURNS>int</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display, int         monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor_at_surface</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display, GdkSurface  *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_keymap</NAME>
<RETURNS>GdkKeymap *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_setting</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display, const char *name, GValue     *value
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DISPLAY_MANAGER</NAME>
#define GDK_TYPE_DISPLAY_MANAGER              (gdk_display_manager_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_MANAGER</NAME>
#define GDK_DISPLAY_MANAGER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MANAGER, GdkDisplayManager))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY_MANAGER</NAME>
#define GDK_IS_DISPLAY_MANAGER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_MANAGER))
</MACRO>
<FUNCTION>
<NAME>gdk_display_manager_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get</NAME>
<RETURNS>GdkDisplayManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get_default_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_set_default_display</NAME>
<RETURNS>void</RETURNS>
GdkDisplayManager *manager, GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_list_displays</NAME>
<RETURNS>GSList *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_open_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager, const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gdk_set_allowed_backends</NAME>
<RETURNS>void</RETURNS>
const gchar       *backends
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG</NAME>
#define GDK_TYPE_DRAG              (gdk_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAG</NAME>
#define GDK_DRAG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG, GdkDrag))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAG</NAME>
#define GDK_IS_DRAG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG))
</MACRO>
<ENUM>
<NAME>GdkDragCancelReason</NAME>
typedef enum {
  GDK_DRAG_CANCEL_NO_TARGET,
  GDK_DRAG_CANCEL_USER_CANCELLED,
  GDK_DRAG_CANCEL_ERROR
} GdkDragCancelReason;
</ENUM>
<FUNCTION>
<NAME>gdk_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_selected_action</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_action_is_unique</NAME>
<RETURNS>gboolean</RETURNS>
GdkDragAction   action
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_begin</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkSurface         *surface, GdkDevice          *device, GdkContentProvider *content, GdkDragAction       actions, gint                dx, gint                dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_drop_done</NAME>
<RETURNS>void</RETURNS>
GdkDrag  *drag, gboolean  success
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_drag_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_set_hotspot</NAME>
<RETURNS>void</RETURNS>
GdkDrag *drag, gint     hot_x, gint     hot_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_content</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrag *drag
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG_SURFACE</NAME>
#define GDK_TYPE_DRAG_SURFACE (gdk_drag_surface_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_drag_surface_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkDragSurface *drag_icon, 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_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>
<ENUM>
<NAME>GdkEventType</NAME>
typedef enum
{
  GDK_DELETE,
  GDK_MOTION_NOTIFY,
  GDK_BUTTON_PRESS,
  GDK_BUTTON_RELEASE,
  GDK_KEY_PRESS,
  GDK_KEY_RELEASE,
  GDK_ENTER_NOTIFY,
  GDK_LEAVE_NOTIFY,
  GDK_FOCUS_CHANGE,
  GDK_CONFIGURE,
  GDK_PROXIMITY_IN,
  GDK_PROXIMITY_OUT,
  GDK_DRAG_ENTER,
  GDK_DRAG_LEAVE,
  GDK_DRAG_MOTION,
  GDK_DROP_START,
  GDK_SCROLL,
  GDK_GRAB_BROKEN,
  GDK_TOUCH_BEGIN,
  GDK_TOUCH_UPDATE,
  GDK_TOUCH_END,
  GDK_TOUCH_CANCEL,
  GDK_TOUCHPAD_SWIPE,
  GDK_TOUCHPAD_PINCH,
  GDK_PAD_BUTTON_PRESS,
  GDK_PAD_BUTTON_RELEASE,
  GDK_PAD_RING,
  GDK_PAD_STRIP,
  GDK_PAD_GROUP_MODE,
  GDK_EVENT_LAST        /* helper variable for decls */
} GdkEventType;
</ENUM>
<ENUM>
<NAME>GdkTouchpadGesturePhase</NAME>
typedef enum
{
  GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
  GDK_TOUCHPAD_GESTURE_PHASE_UPDATE,
  GDK_TOUCHPAD_GESTURE_PHASE_END,
  GDK_TOUCHPAD_GESTURE_PHASE_CANCEL
} GdkTouchpadGesturePhase;
</ENUM>
<ENUM>
<NAME>GdkScrollDirection</NAME>
typedef enum
{
  GDK_SCROLL_UP,
  GDK_SCROLL_DOWN,
  GDK_SCROLL_LEFT,
  GDK_SCROLL_RIGHT,
  GDK_SCROLL_SMOOTH
} GdkScrollDirection;
</ENUM>
<ENUM>
<NAME>GdkNotifyType</NAME>
typedef enum
{
  GDK_NOTIFY_ANCESTOR		= 0,
  GDK_NOTIFY_VIRTUAL		= 1,
  GDK_NOTIFY_INFERIOR		= 2,
  GDK_NOTIFY_NONLINEAR		= 3,
  GDK_NOTIFY_NONLINEAR_VIRTUAL	= 4,
  GDK_NOTIFY_UNKNOWN		= 5
} GdkNotifyType;
</ENUM>
<ENUM>
<NAME>GdkCrossingMode</NAME>
typedef enum
{
  GDK_CROSSING_NORMAL,
  GDK_CROSSING_GRAB,
  GDK_CROSSING_UNGRAB,
  GDK_CROSSING_GTK_GRAB,
  GDK_CROSSING_GTK_UNGRAB,
  GDK_CROSSING_STATE_CHANGED,
  GDK_CROSSING_TOUCH_BEGIN,
  GDK_CROSSING_TOUCH_END,
  GDK_CROSSING_DEVICE_SWITCH
} GdkCrossingMode;
</ENUM>
<FUNCTION>
<NAME>gdk_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_sequence_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_ref</NAME>
<RETURNS>GdkEvent *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_unref</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_type</NAME>
<RETURNS>GdkEventType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_source_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_time</NAME>
<RETURNS>guint32</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_sequence</NAME>
<RETURNS>GdkEventSequence *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_modifier_state</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_position</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent  *event, double	   *x, double	   *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axes</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent  *event, double   **axes, guint     *n_axes
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axis</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent   *event, GdkAxisUse  axis_use, double     *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_pointer_emulated</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_button_event_get_button</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</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_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_scancode</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_group</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_in</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touch_event_get_emulating_pointer</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</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_configure_event_get_size</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, int      *width, int      *height
</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_pinch_event_get_angle_delta</NAME>
<RETURNS>double</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_pinch_event_get_scale</NAME>
<RETURNS>double</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_button_event_get_button</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_axis_event_get_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_drag_event_get_drop</NAME>
<RETURNS>GdkDrop *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_grab_broken_event_get_grab_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_motion_history</NAME>
<RETURNS>GList *</RETURNS>
GdkEvent *event
</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>
<UNION>
<NAME>GdkEvent</NAME>
</UNION>
<STRUCT>
<NAME>GdkEventSequence</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK</NAME>
#define GDK_TYPE_FRAME_CLOCK            (gdk_frame_clock_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK</NAME>
#define GDK_FRAME_CLOCK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClock))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_CLASS</NAME>
#define GDK_FRAME_CLOCK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK</NAME>
#define GDK_IS_FRAME_CLOCK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK_CLASS</NAME>
#define GDK_IS_FRAME_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_GET_CLASS</NAME>
#define GDK_FRAME_CLOCK_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<ENUM>
<NAME>GdkFrameClockPhase</NAME>
typedef enum {
  GDK_FRAME_CLOCK_PHASE_NONE          = 0,
  GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS  = 1 << 0,
  GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT  = 1 << 1,
  GDK_FRAME_CLOCK_PHASE_UPDATE        = 1 << 2,
  GDK_FRAME_CLOCK_PHASE_LAYOUT        = 1 << 3,
  GDK_FRAME_CLOCK_PHASE_PAINT         = 1 << 4,
  GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS = 1 << 5,
  GDK_FRAME_CLOCK_PHASE_AFTER_PAINT   = 1 << 6
} GdkFrameClockPhase;
</ENUM>
<FUNCTION>
<NAME>gdk_frame_clock_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_request_phase</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock, GdkFrameClockPhase  phase
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_begin_updating</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_end_updating</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_counter</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_history_start</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_timings</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameClock *frame_clock, gint64         frame_counter
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_current_timings</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_refresh_info</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock *frame_clock, gint64         base_time, gint64        *refresh_interval_return, gint64        *presentation_time_return
</FUNCTION>
<STRUCT>
<NAME>GdkFrameClock</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_frame_timings_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_ref</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_unref</NAME>
<RETURNS>void</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_frame_counter</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_complete</NAME>
<RETURNS>gboolean</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_frame_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_presentation_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_refresh_interval</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_predicted_presentation_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<STRUCT>
<NAME>GdkFrameTimings</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_GL_CONTEXT</NAME>
#define GDK_TYPE_GL_CONTEXT             (gdk_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_GL_CONTEXT</NAME>
#define GDK_GL_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_CONTEXT, GdkGLContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_GL_CONTEXT</NAME>
#define GDK_IS_GL_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_GL_ERROR</NAME>
#define GDK_GL_ERROR       (gdk_gl_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_gl_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_shared_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int           *major, int           *minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_is_legacy</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_required_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int            major, int            minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_required_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int           *major, int           *minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_debug_enabled</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, gboolean       enabled
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_debug_enabled</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_forward_compatible</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, gboolean       compatible
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_forward_compatible</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_use_es</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int            use_es
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_use_es</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_realize</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_make_current</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_current</NAME>
<RETURNS>GdkGLContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_clear_current</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_GL_TEXTURE</NAME>
#define GDK_TYPE_GL_TEXTURE (gdk_gl_texture_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_GL_TEXTURE</NAME>
#define GDK_GL_TEXTURE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_TEXTURE, GdkGLTexture))
</MACRO>
<MACRO>
<NAME>GDK_IS_GL_TEXTURE</NAME>
#define GDK_IS_GL_TEXTURE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_TEXTURE))
</MACRO>
<FUNCTION>
<NAME>gdk_gl_texture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_texture_new</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkGLContext    *context, guint            id, int              width, int              height, GDestroyNotify   destroy, gpointer         data
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_texture_release</NAME>
<RETURNS>void</RETURNS>
GdkGLTexture    *self
</FUNCTION>
<STRUCT>
<NAME>GdkGLTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLTextureClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkKeymapKey</NAME>
struct _GdkKeymapKey
{
  guint keycode;
  gint  group;
  gint  level;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_KEYMAP</NAME>
#define GDK_TYPE_KEYMAP              (gdk_keymap_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_KEYMAP</NAME>
#define GDK_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_KEYMAP, GdkKeymap))
</MACRO>
<MACRO>
<NAME>GDK_IS_KEYMAP</NAME>
#define GDK_IS_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_KEYMAP))
</MACRO>
<FUNCTION>
<NAME>gdk_keymap_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_lookup_key</NAME>
<RETURNS>guint</RETURNS>
GdkKeymap           *keymap, const GdkKeymapKey  *key
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_translate_keyboard_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap, guint                hardware_keycode, GdkModifierType      state, gint                 group, guint               *keyval, gint                *effective_group, gint                *level, GdkModifierType     *consumed_modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_entries_for_keyval</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap, guint                keyval, GdkKeymapKey       **keys, gint                *n_keys
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_entries_for_keycode</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap, guint                hardware_keycode, GdkKeymapKey       **keys, guint              **keyvals, gint                *n_entries
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_direction</NAME>
<RETURNS>PangoDirection</RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_have_bidi_layouts</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_caps_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_num_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_scroll_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_modifier_state</NAME>
<RETURNS>guint</RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_add_virtual_modifiers</NAME>
<RETURNS>void</RETURNS>
GdkKeymap           *keymap, GdkModifierType     *state
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_map_virtual_modifiers</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap           *keymap, GdkModifierType     *state
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_modifier_mask</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkKeymap           *keymap, GdkModifierIntent    intent
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_name</NAME>
<RETURNS>const char *</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_from_name</NAME>
<RETURNS>guint</RETURNS>
const gchar *keyval_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_convert_case</NAME>
<RETURNS>void</RETURNS>
guint        symbol, guint       *lower, guint       *upper
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_upper</NAME>
<RETURNS>guint</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_lower</NAME>
<RETURNS>guint</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_upper</NAME>
<RETURNS>gboolean</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_lower</NAME>
<RETURNS>gboolean</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_unicode</NAME>
<RETURNS>guint32</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_unicode_to_keyval</NAME>
<RETURNS>guint</RETURNS>
guint32      wc
</FUNCTION>
<ENUM>
<NAME>GdkMemoryFormat</NAME>
typedef enum {
  GDK_MEMORY_B8G8R8A8_PREMULTIPLIED,
  GDK_MEMORY_A8R8G8B8_PREMULTIPLIED,
  GDK_MEMORY_B8G8R8A8,
  GDK_MEMORY_A8R8G8B8,
  GDK_MEMORY_R8G8B8A8,
  GDK_MEMORY_A8B8G8R8,
  GDK_MEMORY_R8G8B8,
  GDK_MEMORY_B8G8R8,

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

  /*< public >*/
  /* draw to 0,0 with the given width and height */
  void                  (* snapshot)                    (GdkPaintable           *paintable,
                                                         GdkSnapshot            *snapshot,
                                                         double                  width,
                                                         double                  height);
  /* get the current contents in an immutable form (optional) */
  GdkPaintable *        (* get_current_image)           (GdkPaintable           *paintable);
   
  /* get flags for potential optimizations (optional) */
  GdkPaintableFlags     (* get_flags)                   (GdkPaintable           *paintable);
  /* preferred width of paintable or 0 if it has no width (optional) */
  int                   (* get_intrinsic_width)         (GdkPaintable           *paintable);
  /* preferred height of paintable or 0 if it has no height (optional) */
  int                   (* get_intrinsic_height)        (GdkPaintable           *paintable);
  /* aspect ratio (width / height) of paintable or 0 if it has no aspect ratio (optional) */
  double                (* get_intrinsic_aspect_ratio)  (GdkPaintable           *paintable);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_paintable_snapshot</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable, GdkSnapshot            *snapshot, double                  width, double                  height
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_current_image</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_flags</NAME>
<RETURNS>GdkPaintableFlags</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_intrinsic_width</NAME>
<RETURNS>int</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_intrinsic_height</NAME>
<RETURNS>int</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_get_intrinsic_aspect_ratio</NAME>
<RETURNS>double</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_compute_concrete_size</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable, double                  specified_width, double                  specified_height, double                  default_width, double                  default_height, double                 *concrete_width, double                 *concrete_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_invalidate_contents</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_invalidate_size</NAME>
<RETURNS>void</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gdk_paintable_new_empty</NAME>
<RETURNS>GdkPaintable *</RETURNS>
int                     intrinsic_width, int                     intrinsic_height
</FUNCTION>
<STRUCT>
<NAME>GdkPaintable</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_pango_layout_line_get_clip_region</NAME>
<RETURNS>cairo_region_t *</RETURNS>
PangoLayoutLine *line, gint             x_origin, gint             y_origin, const gint      *index_ranges, gint             n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pango_layout_get_clip_region</NAME>
<RETURNS>cairo_region_t *</RETURNS>
PangoLayout     *layout, gint             x_origin, gint             y_origin, const gint      *index_ranges, gint             n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_from_surface</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
cairo_surface_t *surface, gint             src_x, gint             src_y, gint             width, gint             height
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_from_texture</NAME>
<RETURNS>GdkPixbuf *</RETURNS>
GdkTexture      *texture
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_POPUP</NAME>
#define GDK_TYPE_POPUP (gdk_popup_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_popup_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopup       *popup, int             width, int             height, GdkPopupLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_surface_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_rect_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_parent</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_position_x</NAME>
<RETURNS>int</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_position_y</NAME>
<RETURNS>int</RETURNS>
GdkPopup       *popup
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_get_autohide</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopup       *popup
</FUNCTION>
<STRUCT>
<NAME>GdkPopup</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPopupInterface</NAME>
</STRUCT>
<ENUM>
<NAME>GdkAnchorHints</NAME>
typedef enum
{
  GDK_ANCHOR_FLIP_X   = 1 << 0,
  GDK_ANCHOR_FLIP_Y   = 1 << 1,
  GDK_ANCHOR_SLIDE_X  = 1 << 2,
  GDK_ANCHOR_SLIDE_Y  = 1 << 3,
  GDK_ANCHOR_RESIZE_X = 1 << 4,
  GDK_ANCHOR_RESIZE_Y = 1 << 5,
  GDK_ANCHOR_FLIP     = GDK_ANCHOR_FLIP_X | GDK_ANCHOR_FLIP_Y,
  GDK_ANCHOR_SLIDE    = GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_SLIDE_Y,
  GDK_ANCHOR_RESIZE   = GDK_ANCHOR_RESIZE_X | GDK_ANCHOR_RESIZE_Y,
} GdkAnchorHints;
</ENUM>
<MACRO>
<NAME>GDK_TYPE_POPUP_LAYOUT</NAME>
#define GDK_TYPE_POPUP_LAYOUT (gdk_popup_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_popup_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_new</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
const GdkRectangle     *anchor_rect, GdkGravity              rect_anchor, GdkGravity              surface_anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_ref</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_unref</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_copy</NAME>
<RETURNS>GdkPopupLayout *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_equal</NAME>
<RETURNS>gboolean</RETURNS>
GdkPopupLayout         *layout, GdkPopupLayout         *other
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_anchor_rect</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, const GdkRectangle     *anchor_rect
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_anchor_rect</NAME>
<RETURNS>const GdkRectangle *</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_rect_anchor</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkGravity              anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_rect_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_surface_anchor</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkGravity              anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_surface_anchor</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_anchor_hints</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, GdkAnchorHints          anchor_hints
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_anchor_hints</NAME>
<RETURNS>GdkAnchorHints</RETURNS>
GdkPopupLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_set_offset</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, int                     dx, int                     dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_popup_layout_get_offset</NAME>
<RETURNS>void</RETURNS>
GdkPopupLayout         *layout, int                    *dx, int                    *dy
</FUNCTION>
<STRUCT>
<NAME>GdkPopupLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPopupInterface</NAME>
struct _GdkPopupInterface
{
  GTypeInterface g_iface;

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

  GdkGravity    (* get_surface_anchor)  (GdkPopup       *popup);
  GdkGravity    (* get_rect_anchor)     (GdkPopup       *popup);
  int           (* get_position_x)      (GdkPopup       *popup);
  int           (* get_position_y)      (GdkPopup       *popup);
};
</STRUCT>
<ENUM>
<NAME>GdkPopupProperties</NAME>
typedef enum
{
  GDK_POPUP_PROP_PARENT,
  GDK_POPUP_PROP_AUTOHIDE,
  GDK_POPUP_NUM_PROPERTIES
} GdkPopupProperties;
</ENUM>
<FUNCTION>
<NAME>gdk_popup_install_properties</NAME>
<RETURNS>guint</RETURNS>
GObjectClass *object_class, guint         first_prop
</FUNCTION>
<MACRO>
<NAME>GDK_PROFILER_IS_RUNNING</NAME>
#define GDK_PROFILER_IS_RUNNING G_UNLIKELY (gdk_profiler_is_running ())
</MACRO>
<FUNCTION>
<NAME>gdk_profiler_start</NAME>
<RETURNS>void</RETURNS>
int fd
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_stop</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_is_running</NAME>
<RETURNS>gboolean</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_add_mark</NAME>
<RETURNS>void</RETURNS>
gint64           start, guint64          duration, const char      *name, const char      *message
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_add_markf</NAME>
<RETURNS>void</RETURNS>
gint64           start, guint64          duration, const char      *name, const char      *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_end_mark</NAME>
<RETURNS>void</RETURNS>
gint64           start, const char      *name, const char      *message
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_end_markf</NAME>
<RETURNS>void</RETURNS>
gint64           start, const char      *name, const char      *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_define_counter</NAME>
<RETURNS>guint</RETURNS>
const char *name, const char *description
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_set_counter</NAME>
<RETURNS>void</RETURNS>
guint  id, gint64 time, double value
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_define_int_counter</NAME>
<RETURNS>guint</RETURNS>
const char *name, const char *description
</FUNCTION>
<FUNCTION>
<NAME>gdk_profiler_set_int_counter</NAME>
<RETURNS>void</RETURNS>
guint  id, gint64 time, gint64 value
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_intersect</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_union</NAME>
<RETURNS>void</RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_equal</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *rect1, const GdkRectangle *rect2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_contains_point</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRectangle *rect, int                 x, int                 y
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_RECTANGLE</NAME>
#define GDK_TYPE_RECTANGLE (gdk_rectangle_get_type ())
</MACRO>
<STRUCT>
<NAME>GdkRGBA</NAME>
struct _GdkRGBA
{
  float red;
  float green;
  float blue;
  float alpha;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_RGBA</NAME>
#define GDK_TYPE_RGBA (gdk_rgba_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_rgba_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_copy</NAME>
<RETURNS>GdkRGBA *</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_free</NAME>
<RETURNS>void</RETURNS>
GdkRGBA       *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_clear</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_opaque</NAME>
<RETURNS>gboolean</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_hash</NAME>
<RETURNS>guint</RETURNS>
gconstpointer  p
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_equal</NAME>
<RETURNS>gboolean</RETURNS>
gconstpointer  p1, gconstpointer  p2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_parse</NAME>
<RETURNS>gboolean</RETURNS>
GdkRGBA       *rgba, const gchar   *spec
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_to_string</NAME>
<RETURNS>gchar *</RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<MACRO>
<NAME>GDK_RGBA</NAME>
#define GDK_RGBA(str) ((GdkRGBA) {\
    ((_GDK_RGBA_SELECT_COLOR(str, 0, 0) << 4) | _GDK_RGBA_SELECT_COLOR(str, 0, 1)) / 255., \
    ((_GDK_RGBA_SELECT_COLOR(str, 1, 2) << 4) | _GDK_RGBA_SELECT_COLOR(str, 1, 3)) / 255., \
    ((_GDK_RGBA_SELECT_COLOR(str, 2, 4) << 4) | _GDK_RGBA_SELECT_COLOR(str, 2, 5)) / 255., \
    ((sizeof(str) % 4 == 1) ? ((_GDK_RGBA_SELECT_COLOR(str, 3, 6) << 4) | _GDK_RGBA_SELECT_COLOR(str, 3, 7)) : 0xFF) / 255 })
</MACRO>
<FUNCTION>
<NAME>gdk_rgba_parser_parse</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser           *parser, GdkRGBA                *rgba
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_SEAT</NAME>
#define GDK_TYPE_SEAT  (gdk_seat_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_SEAT</NAME>
#define GDK_SEAT(o)    (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_SEAT, GdkSeat))
</MACRO>
<MACRO>
<NAME>GDK_IS_SEAT</NAME>
#define GDK_IS_SEAT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_SEAT))
</MACRO>
<ENUM>
<NAME>GdkSeatCapabilities</NAME>
typedef enum {
  GDK_SEAT_CAPABILITY_NONE          = 0,
  GDK_SEAT_CAPABILITY_POINTER       = 1 << 0,
  GDK_SEAT_CAPABILITY_TOUCH         = 1 << 1,
  GDK_SEAT_CAPABILITY_TABLET_STYLUS = 1 << 2,
  GDK_SEAT_CAPABILITY_KEYBOARD      = 1 << 3,
  GDK_SEAT_CAPABILITY_TABLET_PAD    = 1 << 4,
  GDK_SEAT_CAPABILITY_ALL_POINTING  = (GDK_SEAT_CAPABILITY_POINTER | GDK_SEAT_CAPABILITY_TOUCH | GDK_SEAT_CAPABILITY_TABLET_STYLUS),
  GDK_SEAT_CAPABILITY_ALL           = (GDK_SEAT_CAPABILITY_ALL_POINTING | GDK_SEAT_CAPABILITY_KEYBOARD)
} GdkSeatCapabilities;
</ENUM>
<STRUCT>
<NAME>GdkSeat</NAME>
struct _GdkSeat
{
  GObject parent_instance;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_seat_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_capabilities</NAME>
<RETURNS>GdkSeatCapabilities</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_slaves</NAME>
<RETURNS>GList *</RETURNS>
GdkSeat             *seat, GdkSeatCapabilities  capabilities
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_pointer</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_keyboard</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_master_pointers</NAME>
<RETURNS>GList *</RETURNS>
GdkSeat             *seat, GdkSeatCapabilities  capabilities
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_SNAPSHOT</NAME>
#define GDK_TYPE_SNAPSHOT               (gdk_snapshot_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_SNAPSHOT</NAME>
#define GDK_SNAPSHOT(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_SNAPSHOT, GdkSnapshot))
</MACRO>
<MACRO>
<NAME>GDK_IS_SNAPSHOT</NAME>
#define GDK_IS_SNAPSHOT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_SNAPSHOT))
</MACRO>
<FUNCTION>
<NAME>gdk_snapshot_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkSnapshotClass</NAME>
</STRUCT>
<ENUM>
<NAME>GdkSurfaceHints</NAME>
typedef enum
{
  GDK_HINT_POS	       = 1 << 0,
  GDK_HINT_MIN_SIZE    = 1 << 1,
  GDK_HINT_MAX_SIZE    = 1 << 2,
  GDK_HINT_BASE_SIZE   = 1 << 3,
  GDK_HINT_ASPECT      = 1 << 4,
  GDK_HINT_RESIZE_INC  = 1 << 5,
  GDK_HINT_WIN_GRAVITY = 1 << 6,
  GDK_HINT_USER_POS    = 1 << 7,
  GDK_HINT_USER_SIZE   = 1 << 8
} GdkSurfaceHints;
</ENUM>
<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>
<STRUCT>
<NAME>GdkGeometry</NAME>
struct _GdkGeometry
{
  gint min_width;
  gint min_height;
  gint max_width;
  gint max_height;
  gint base_width;
  gint base_height;
  gint width_inc;
  gint height_inc;
  gdouble min_aspect;
  gdouble max_aspect;
  GdkGravity win_gravity;
};
</STRUCT>
<ENUM>
<NAME>GdkSurfaceState</NAME>
typedef enum
{
  GDK_SURFACE_STATE_WITHDRAWN        = 1 << 0,
  GDK_SURFACE_STATE_MINIMIZED        = 1 << 1,
  GDK_SURFACE_STATE_MAXIMIZED        = 1 << 2,
  GDK_SURFACE_STATE_STICKY           = 1 << 3,
  GDK_SURFACE_STATE_FULLSCREEN       = 1 << 4,
  GDK_SURFACE_STATE_ABOVE            = 1 << 5,
  GDK_SURFACE_STATE_BELOW            = 1 << 6,
  GDK_SURFACE_STATE_FOCUSED          = 1 << 7,
  GDK_SURFACE_STATE_TILED            = 1 << 8,
  GDK_SURFACE_STATE_TOP_TILED        = 1 << 9,
  GDK_SURFACE_STATE_TOP_RESIZABLE    = 1 << 10,
  GDK_SURFACE_STATE_RIGHT_TILED      = 1 << 11,
  GDK_SURFACE_STATE_RIGHT_RESIZABLE  = 1 << 12,
  GDK_SURFACE_STATE_BOTTOM_TILED     = 1 << 13,
  GDK_SURFACE_STATE_BOTTOM_RESIZABLE = 1 << 14,
  GDK_SURFACE_STATE_LEFT_TILED       = 1 << 15,
  GDK_SURFACE_STATE_LEFT_RESIZABLE   = 1 << 16
} GdkSurfaceState;
</ENUM>
<MACRO>
<NAME>GDK_TYPE_SURFACE</NAME>
#define GDK_TYPE_SURFACE              (gdk_surface_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_SURFACE</NAME>
#define GDK_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SURFACE, GdkSurface))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_CLASS</NAME>
#define GDK_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SURFACE, GdkSurfaceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_SURFACE</NAME>
#define GDK_IS_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_IS_SURFACE_CLASS</NAME>
#define GDK_IS_SURFACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_GET_CLASS</NAME>
#define GDK_SURFACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SURFACE, GdkSurfaceClass))
</MACRO>
<FUNCTION>
<NAME>gdk_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_new_toplevel</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay    *display, int            width, int            height
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_new_popup</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkSurface    *parent, gboolean       autohide
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_destroy</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_is_destroyed</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_hide</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_input_region</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_is_viewable</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_mapped</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_device_cursor</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, GdkDevice     *device, GdkCursor     *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_device_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkSurface     *surface, GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_width</NAME>
<RETURNS>int</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_height</NAME>
<RETURNS>int</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_translate_coordinates</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *from, GdkSurface *to, double     *x, double     *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_scale_factor</NAME>
<RETURNS>gint</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_device_position</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, GdkDevice       *device, double          *x, double          *y, GdkModifierType *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_similar_surface</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GdkSurface *surface, cairo_content_t  content, int              width, int              height
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_beep</NAME>
<RETURNS>void</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_begin_resize_drag</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, GdkSurfaceEdge  edge, GdkDevice      *device, gint            button, gint            x, gint            y, guint32         timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_begin_move_drag</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, GdkDevice      *device, gint            button, gint            x, gint            y, guint32         timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_queue_expose</NAME>
<RETURNS>void</RETURNS>
GdkSurface          *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_freeze_updates</NAME>
<RETURNS>void</RETURNS>
GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_thaw_updates</NAME>
<RETURNS>void</RETURNS>
GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_constrain_size</NAME>
<RETURNS>void</RETURNS>
GdkGeometry    *geometry, GdkSurfaceHints  flags, gint            width, gint            height, gint           *new_width, gint           *new_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_support_multidevice</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean   support_multidevice
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_support_multidevice</NAME>
<RETURNS>gboolean</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_get_frame_clock</NAME>
<RETURNS>GdkFrameClock *</RETURNS>
GdkSurface     *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_opaque_region</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_set_shadow_width</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, gint            left, gint            right, gint            top, gint            bottom
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_cairo_context</NAME>
<RETURNS>GdkCairoContext *</RETURNS>
GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_gl_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkSurface     *surface, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_create_vulkan_context</NAME>
<RETURNS>GdkVulkanContext *</RETURNS>
GdkSurface     *surface, GError        **error
</FUNCTION>
<STRUCT>
<NAME>GdkSurfaceClass</NAME>
</STRUCT>
<ENUM>
<NAME>GdkSurfaceType</NAME>
typedef enum
{
  GDK_SURFACE_TOPLEVEL,
  GDK_SURFACE_TEMP,
  GDK_SURFACE_POPUP
} GdkSurfaceType;
</ENUM>
<STRUCT>
<NAME>GdkSurface</NAME>
struct _GdkSurface
{
  GObject parent_instance;

  GdkDisplay *display;

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

  gpointer widget;

  gint x;
  gint y;

  guint8 resize_count;

  GdkGLContext *gl_paint_context;

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

  GdkSurfaceState old_state;
  GdkSurfaceState state;

  guint8 alpha;
  guint8 fullscreen_mode;

  guint modal_hint : 1;

  guint destroyed : 2;

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

  struct {
    GdkGravity surface_anchor;
    GdkGravity rect_anchor;
  } popup;

  guint update_and_descendants_freeze_count;

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

  GdkCursor *cursor;
  GHashTable *device_cursor;

  cairo_region_t *input_region;

  GList *devices_inside;

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

  GSList *draw_contexts;
  GdkDrawContext *paint_context;

  cairo_region_t *opaque_region;
};
</STRUCT>
<STRUCT>
<NAME>GdkSurfaceClass</NAME>
struct _GdkSurfaceClass
{
  GObjectClass parent_class;

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

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

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

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


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

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

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

  void         (* set_opaque_region)      (GdkSurface      *surface,
                                           cairo_region_t *region);
  void         (* set_shadow_width)       (GdkSurface      *surface,
                                           gint            left,
                                           gint            right,
                                           gint            top,
                                           gint            bottom);
  GdkGLContext *(*create_gl_context)      (GdkSurface      *surface,
                                           gboolean        attached,
                                           GdkGLContext   *share,
                                           GError        **error);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_surface_set_state</NAME>
<RETURNS>void</RETURNS>
GdkSurface      *surface, GdkSurfaceState  new_state
</FUNCTION>
<FUNCTION>
<NAME>gdk_surface_layout_popup_helper</NAME>
<RETURNS>void</RETURNS>
GdkSurface     *surface, int             width, int             height, GdkPopupLayout *layout, GdkRectangle   *out_final_rect
</FUNCTION>
<FUNCTION>
<NAME>gdk_gravity_flip_horizontally</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkGravity anchor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gravity_flip_vertically</NAME>
<RETURNS>GdkGravity</RETURNS>
GdkGravity anchor
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_TEXTURE</NAME>
#define GDK_TYPE_TEXTURE (gdk_texture_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TEXTURE</NAME>
#define GDK_TEXTURE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_TEXTURE, GdkTexture))
</MACRO>
<MACRO>
<NAME>GDK_IS_TEXTURE</NAME>
#define GDK_IS_TEXTURE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_TEXTURE))
</MACRO>
<FUNCTION>
<NAME>gdk_texture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_for_pixbuf</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkPixbuf       *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_from_resource</NAME>
<RETURNS>GdkTexture *</RETURNS>
const char      *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_new_from_file</NAME>
<RETURNS>GdkTexture *</RETURNS>
GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_get_width</NAME>
<RETURNS>int</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_get_height</NAME>
<RETURNS>int</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_download</NAME>
<RETURNS>void</RETURNS>
GdkTexture      *texture, guchar          *data, gsize            stride
</FUNCTION>
<FUNCTION>
<NAME>gdk_texture_save_to_png</NAME>
<RETURNS>gboolean</RETURNS>
GdkTexture      *texture, const char      *filename
</FUNCTION>
<STRUCT>
<NAME>GdkTextureClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TOPLEVEL</NAME>
#define GDK_TYPE_TOPLEVEL (gdk_toplevel_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_toplevel_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel, int                width, int                height, GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_minimize</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_lower</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_focus</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, guint32            timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_get_state</NAME>
<RETURNS>GdkSurfaceState</RETURNS>
GdkToplevel       *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_title</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, const char        *title
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_startup_id</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, const char        *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_transient_for</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, GdkSurface        *parent
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_modal</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, gboolean           modal
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_icon_list</NAME>
<RETURNS>void</RETURNS>
GdkToplevel       *toplevel, GList             *surfaces
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_show_window_menu</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel       *toplevel, GdkEvent          *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_decorated</NAME>
<RETURNS>void</RETURNS>
GdkToplevel      *toplevel, gboolean          decorated
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_set_deletable</NAME>
<RETURNS>void</RETURNS>
GdkToplevel      *toplevel, gboolean          deletable
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_supports_edge_constraints</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<STRUCT>
<NAME>GdkToplevel</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkToplevelInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_TOPLEVEL_LAYOUT</NAME>
#define GDK_TYPE_TOPLEVEL_LAYOUT (gdk_toplevel_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_new</NAME>
<RETURNS>GdkToplevelLayout *</RETURNS>
int min_width, int min_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_ref</NAME>
<RETURNS>GdkToplevelLayout *</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_unref</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_copy</NAME>
<RETURNS>GdkToplevelLayout *</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_equal</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout, GdkToplevelLayout *other
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_set_maximized</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout, gboolean           maximized
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_set_fullscreen</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout, gboolean           fullscreen, GdkMonitor        *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_min_width</NAME>
<RETURNS>int</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_min_height</NAME>
<RETURNS>int</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_maximized</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_fullscreen</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_fullscreen_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_set_resizable</NAME>
<RETURNS>void</RETURNS>
GdkToplevelLayout *layout, gboolean           resizable
</FUNCTION>
<FUNCTION>
<NAME>gdk_toplevel_layout_get_resizable</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevelLayout *layout
</FUNCTION>
<STRUCT>
<NAME>GdkToplevelLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkToplevelInterface</NAME>
struct _GdkToplevelInterface
{
  GTypeInterface g_iface;

  gboolean      (* present)             (GdkToplevel       *toplevel,
                                         int                width,
                                         int                height,
                                         GdkToplevelLayout *layout);
  gboolean      (* minimize)            (GdkToplevel       *toplevel);
  gboolean      (* lower)               (GdkToplevel       *toplevel);
  void          (* focus)               (GdkToplevel       *toplevel,
                                         guint32            timestamp);
  gboolean      (* show_window_menu)    (GdkToplevel       *toplevel,
                                         GdkEvent          *event);
  gboolean      (* supports_edge_constraints) (GdkToplevel *toplevel);
};
</STRUCT>
<ENUM>
<NAME>GdkToplevelProperties</NAME>
typedef enum
{
  GDK_TOPLEVEL_PROP_STATE,
  GDK_TOPLEVEL_PROP_TITLE,
  GDK_TOPLEVEL_PROP_STARTUP_ID,
  GDK_TOPLEVEL_PROP_TRANSIENT_FOR,
  GDK_TOPLEVEL_PROP_MODAL,
  GDK_TOPLEVEL_PROP_ICON_LIST,
  GDK_TOPLEVEL_PROP_DECORATED,
  GDK_TOPLEVEL_PROP_DELETABLE,
  GDK_TOPLEVEL_PROP_FULLSCREEN_MODE,
  GDK_TOPLEVEL_NUM_PROPERTIES
} GdkToplevelProperties;
</ENUM>
<FUNCTION>
<NAME>gdk_toplevel_install_properties</NAME>
<RETURNS>guint</RETURNS>
GObjectClass *object_class, guint         first_prop
</FUNCTION>
<MACRO>
<NAME>GDK_CURRENT_TIME</NAME>
#define GDK_CURRENT_TIME     0L
</MACRO>
<MACRO>
<NAME>GDK_PARENT_RELATIVE</NAME>
#define GDK_PARENT_RELATIVE  1L
</MACRO>
<STRUCT>
<NAME>GdkPoint</NAME>
struct _GdkPoint
{
  gint x;
  gint y;
};
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
struct _GdkRectangle
{
    int x, y;
    int width, height;
};
</STRUCT>
<ENUM>
<NAME>GdkGravity</NAME>
typedef enum
{
  GDK_GRAVITY_NORTH_WEST = 1,
  GDK_GRAVITY_NORTH,
  GDK_GRAVITY_NORTH_EAST,
  GDK_GRAVITY_WEST,
  GDK_GRAVITY_CENTER,
  GDK_GRAVITY_EAST,
  GDK_GRAVITY_SOUTH_WEST,
  GDK_GRAVITY_SOUTH,
  GDK_GRAVITY_SOUTH_EAST,
  GDK_GRAVITY_STATIC
} GdkGravity;
</ENUM>
<ENUM>
<NAME>GdkByteOrder</NAME>
typedef enum
{
  GDK_LSB_FIRST,
  GDK_MSB_FIRST
} GdkByteOrder;
</ENUM>
<ENUM>
<NAME>GdkModifierType</NAME>
typedef enum
{
  GDK_SHIFT_MASK    = 1 << 0,
  GDK_LOCK_MASK     = 1 << 1,
  GDK_CONTROL_MASK  = 1 << 2,
  GDK_MOD1_MASK     = 1 << 3,
  GDK_MOD2_MASK     = 1 << 4,
  GDK_MOD3_MASK     = 1 << 5,
  GDK_MOD4_MASK     = 1 << 6,
  GDK_MOD5_MASK     = 1 << 7,
  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_MODIFIER_RESERVED_13_MASK  = 1 << 13,
  GDK_MODIFIER_RESERVED_14_MASK  = 1 << 14,
  GDK_MODIFIER_RESERVED_15_MASK  = 1 << 15,
  GDK_MODIFIER_RESERVED_16_MASK  = 1 << 16,
  GDK_MODIFIER_RESERVED_17_MASK  = 1 << 17,
  GDK_MODIFIER_RESERVED_18_MASK  = 1 << 18,
  GDK_MODIFIER_RESERVED_19_MASK  = 1 << 19,
  GDK_MODIFIER_RESERVED_20_MASK  = 1 << 20,
  GDK_MODIFIER_RESERVED_21_MASK  = 1 << 21,
  GDK_MODIFIER_RESERVED_22_MASK  = 1 << 22,
  GDK_MODIFIER_RESERVED_23_MASK  = 1 << 23,
  GDK_MODIFIER_RESERVED_24_MASK  = 1 << 24,
  GDK_MODIFIER_RESERVED_25_MASK  = 1 << 25,

  /* The next few modifiers are used by XKB, so we skip to the end.
   * Bits 15 - 25 are currently unused. Bit 29 is used internally.
   */
  
  GDK_SUPER_MASK    = 1 << 26,
  GDK_HYPER_MASK    = 1 << 27,
  GDK_META_MASK     = 1 << 28,
  
  GDK_MODIFIER_RESERVED_29_MASK  = 1 << 29,

  GDK_RELEASE_MASK  = 1 << 30,

  /* Combination of GDK_SHIFT_MASK..GDK_BUTTON5_MASK + GDK_SUPER_MASK
     + GDK_HYPER_MASK + GDK_META_MASK + GDK_RELEASE_MASK */
  GDK_MODIFIER_MASK = 0x5c001fff
} GdkModifierType;
</ENUM>
<ENUM>
<NAME>GdkModifierIntent</NAME>
typedef enum
{
  GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR,
  GDK_MODIFIER_INTENT_CONTEXT_MENU,
  GDK_MODIFIER_INTENT_EXTEND_SELECTION,
  GDK_MODIFIER_INTENT_MODIFY_SELECTION,
  GDK_MODIFIER_INTENT_NO_TEXT_INPUT,
  GDK_MODIFIER_INTENT_SHIFT_GROUP,
  GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK,
} GdkModifierIntent;
</ENUM>
<ENUM>
<NAME>GdkGrabStatus</NAME>
typedef enum
{
  GDK_GRAB_SUCCESS         = 0,
  GDK_GRAB_ALREADY_GRABBED = 1,
  GDK_GRAB_INVALID_TIME    = 2,
  GDK_GRAB_NOT_VIEWABLE    = 3,
  GDK_GRAB_FROZEN          = 4,
  GDK_GRAB_FAILED          = 5
} GdkGrabStatus;
</ENUM>
<ENUM>
<NAME>GdkGrabOwnership</NAME>
typedef enum
{
  GDK_OWNERSHIP_NONE,
  GDK_OWNERSHIP_SURFACE,
  GDK_OWNERSHIP_APPLICATION
} GdkGrabOwnership;
</ENUM>
<ENUM>
<NAME>GdkEventMask</NAME>
typedef enum
{
  GDK_EXPOSURE_MASK             = 1 << 1,
  GDK_POINTER_MOTION_MASK       = 1 << 2,
  GDK_BUTTON_MOTION_MASK        = 1 << 4,
  GDK_BUTTON1_MOTION_MASK       = 1 << 5,
  GDK_BUTTON2_MOTION_MASK       = 1 << 6,
  GDK_BUTTON3_MOTION_MASK       = 1 << 7,
  GDK_BUTTON_PRESS_MASK         = 1 << 8,
  GDK_BUTTON_RELEASE_MASK       = 1 << 9,
  GDK_KEY_PRESS_MASK            = 1 << 10,
  GDK_KEY_RELEASE_MASK          = 1 << 11,
  GDK_ENTER_NOTIFY_MASK         = 1 << 12,
  GDK_LEAVE_NOTIFY_MASK         = 1 << 13,
  GDK_FOCUS_CHANGE_MASK         = 1 << 14,
  GDK_STRUCTURE_MASK            = 1 << 15,
  GDK_PROPERTY_CHANGE_MASK      = 1 << 16,
  GDK_PROXIMITY_IN_MASK         = 1 << 18,
  GDK_PROXIMITY_OUT_MASK        = 1 << 19,
  GDK_SUBSTRUCTURE_MASK         = 1 << 20,
  GDK_SCROLL_MASK               = 1 << 21,
  GDK_TOUCH_MASK                = 1 << 22,
  GDK_SMOOTH_SCROLL_MASK        = 1 << 23,
  GDK_TOUCHPAD_GESTURE_MASK     = 1 << 24,
  GDK_TABLET_PAD_MASK           = 1 << 25,
  GDK_ALL_EVENTS_MASK           = 0x3FFFFFE
} GdkEventMask;
</ENUM>
<ENUM>
<NAME>GdkGLError</NAME>
typedef enum {
  GDK_GL_ERROR_NOT_AVAILABLE,
  GDK_GL_ERROR_UNSUPPORTED_FORMAT,
  GDK_GL_ERROR_UNSUPPORTED_PROFILE,
  GDK_GL_ERROR_COMPILATION_FAILED,
  GDK_GL_ERROR_LINK_FAILED
} GdkGLError;
</ENUM>
<ENUM>
<NAME>GdkVulkanError</NAME>
typedef enum {
  GDK_VULKAN_ERROR_UNSUPPORTED,
  GDK_VULKAN_ERROR_NOT_AVAILABLE,
} GdkVulkanError;
</ENUM>
<ENUM>
<NAME>GdkSurfaceTypeHint</NAME>
typedef enum
{
  GDK_SURFACE_TYPE_HINT_NORMAL,
  GDK_SURFACE_TYPE_HINT_DIALOG,
  GDK_SURFACE_TYPE_HINT_MENU,		/* Torn off menu */
  GDK_SURFACE_TYPE_HINT_TOOLBAR,
  GDK_SURFACE_TYPE_HINT_SPLASHSCREEN,
  GDK_SURFACE_TYPE_HINT_UTILITY,
  GDK_SURFACE_TYPE_HINT_DOCK,
  GDK_SURFACE_TYPE_HINT_DESKTOP,
  GDK_SURFACE_TYPE_HINT_DROPDOWN_MENU,	/* A drop down menu (from a menubar) */
  GDK_SURFACE_TYPE_HINT_POPUP_MENU,	/* A popup menu (from right-click) */
  GDK_SURFACE_TYPE_HINT_TOOLTIP,
  GDK_SURFACE_TYPE_HINT_NOTIFICATION,
  GDK_SURFACE_TYPE_HINT_COMBO,
  GDK_SURFACE_TYPE_HINT_DND
} GdkSurfaceTypeHint;
</ENUM>
<ENUM>
<NAME>GdkAxisUse</NAME>
typedef enum
{
  GDK_AXIS_IGNORE,
  GDK_AXIS_X,
  GDK_AXIS_Y,
  GDK_AXIS_PRESSURE,
  GDK_AXIS_XTILT,
  GDK_AXIS_YTILT,
  GDK_AXIS_WHEEL,
  GDK_AXIS_DISTANCE,
  GDK_AXIS_ROTATION,
  GDK_AXIS_SLIDER,
  GDK_AXIS_LAST
} GdkAxisUse;
</ENUM>
<ENUM>
<NAME>GdkAxisFlags</NAME>
typedef enum
{
  GDK_AXIS_FLAG_X        = 1 << GDK_AXIS_X,
  GDK_AXIS_FLAG_Y        = 1 << GDK_AXIS_Y,
  GDK_AXIS_FLAG_PRESSURE = 1 << GDK_AXIS_PRESSURE,
  GDK_AXIS_FLAG_XTILT    = 1 << GDK_AXIS_XTILT,
  GDK_AXIS_FLAG_YTILT    = 1 << GDK_AXIS_YTILT,
  GDK_AXIS_FLAG_WHEEL    = 1 << GDK_AXIS_WHEEL,
  GDK_AXIS_FLAG_DISTANCE = 1 << GDK_AXIS_DISTANCE,
  GDK_AXIS_FLAG_ROTATION = 1 << GDK_AXIS_ROTATION,
  GDK_AXIS_FLAG_SLIDER   = 1 << GDK_AXIS_SLIDER,
} GdkAxisFlags;
</ENUM>
<ENUM>
<NAME>GdkDragAction</NAME>
typedef enum
{
  GDK_ACTION_COPY    = 1 << 0,
  GDK_ACTION_MOVE    = 1 << 1,
  GDK_ACTION_LINK    = 1 << 2,
  GDK_ACTION_ASK     = 1 << 3
} GdkDragAction;
</ENUM>
<MACRO>
<NAME>GDK_ACTION_ALL</NAME>
#define GDK_ACTION_ALL (GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK)
</MACRO>
<STRUCT>
<NAME>GdkAppLaunchContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCairoContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkClipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentFormats</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCursor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplay</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplayManager</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrag</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawingContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrop</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGeometry</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkKeymap</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPoint</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRGBA</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSeat</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSnapshot</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkVulkanContext</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_VULKAN_CONTEXT             (gdk_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_VULKAN_CONTEXT</NAME>
#define GDK_VULKAN_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_VULKAN_CONTEXT, GdkVulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_VULKAN_CONTEXT</NAME>
#define GDK_IS_VULKAN_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_VULKAN_ERROR</NAME>
#define GDK_VULKAN_ERROR                    (gdk_vulkan_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_vulkan_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_strerror</NAME>
<RETURNS>const char *</RETURNS>
VkResult           result
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_instance</NAME>
<RETURNS>VkInstance</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_physical_device</NAME>
<RETURNS>VkPhysicalDevice</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_device</NAME>
<RETURNS>VkDevice</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_queue</NAME>
<RETURNS>VkQueue</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_queue_family_index</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_image_format</NAME>
<RETURNS>VkFormat</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_n_images</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_image</NAME>
<RETURNS>VkImage</RETURNS>
GdkVulkanContext  *context, guint              id
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_draw_index</NAME>
<RETURNS>uint32_t</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_vulkan_context_get_draw_semaphore</NAME>
<RETURNS>VkSemaphore</RETURNS>
GdkVulkanContext  *context
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_CAIRO_CONTEXT</NAME>
#define GDK_TYPE_WAYLAND_CAIRO_CONTEXT		(gdk_wayland_cairo_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CAIRO_CONTEXT</NAME>
#define GDK_WAYLAND_CAIRO_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_CAIRO_CONTEXT, GdkWaylandCairoContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_CAIRO_CONTEXT</NAME>
#define GDK_IS_WAYLAND_CAIRO_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_WAYLAND_CAIRO_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_CAIRO_CONTEXT, GdkWaylandCairoContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_CAIRO_CONTEXT_CLASS</NAME>
#define GDK_IS_WAYLAND_CAIRO_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CAIRO_CONTEXT_GET_CLASS</NAME>
#define GDK_WAYLAND_CAIRO_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_CAIRO_CONTEXT, GdkWaylandCairoContextClass))
</MACRO>
<STRUCT>
<NAME>GdkWaylandCairoContext</NAME>
struct _GdkWaylandCairoContext
{
  GdkCairoContext parent_instance;

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

  GHashTable *settings;
  GsdXftSettings xft_settings;
  GDBusProxy *settings_portal;

  guint32    shell_capabilities;

  /* Startup notification */
  gchar *startup_notification_id;

  /* Most recent serial */
  guint32 serial;

  uint32_t xdg_wm_base_id;
  uint32_t zxdg_shell_v6_id;
  GdkWaylandShellVariant shell_variant;

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

  GList *async_roundtrips;

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

  GList *event_queues;

  GList *current_popups;
  GList *current_grabbing_popups;

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

  GSource *event_source;

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

  uint32_t server_decoration_mode;

  struct xkb_context *xkb_context;

  GPtrArray *monitors;

  gint64 last_bell_time_ms;

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

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

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

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

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

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

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

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

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

#define MWM_TEAROFF_WINDOW	(1L<<0)

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


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

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

  GSource *event_source;

  gint grab_count;

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

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

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

  GdkKeymap *keymap;
  guint      keymap_serial;

  gboolean have_xfixes;
  gint xfixes_event_base;

  gboolean have_xcomposite;
  gboolean have_xdamage;
  gint xdamage_event_base;

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

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

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

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

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

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

  /* X ID hashtable */
  GHashTable *xid_ht;

  /* streams reading selections */
  GSList *streams;

  /* input GdkSurface list */
  GList *input_surfaces;

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

  GPtrArray *monitors;
  int primary_monitor;

  /* Startup notification */
  gchar *startup_notification_id;

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

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

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

  GSList *error_traps;

  gint wm_moveresize_button;

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

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

  guint server_time_is_monotonic_time : 1;

  guint have_glx : 1;

  /* GLX extensions we check */
  guint has_glx_swap_interval : 1;
  guint has_glx_create_context : 1;
  guint has_glx_texture_from_pixmap : 1;
  guint has_glx_video_sync : 1;
  guint has_glx_buffer_age : 1;
  guint has_glx_sync_control : 1;
  guint has_glx_multisample : 1;
  guint has_glx_visual_rating : 1;
  guint has_glx_create_es2_context : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11DisplayClass</NAME>
struct _GdkX11DisplayClass
{
  GdkDisplayClass parent_class;

  gboolean              (* xevent)                              (GdkX11Display          *display,
                                                                 const XEvent           *event);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_display_get_max_request_size</NAME>
<RETURNS>gsize</RETURNS>
GdkDisplay             *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_request_selection_notification</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay             *display, const char             *selection
</FUNCTION>
<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;

  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>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
struct _GdkX11Monitor
{
  GdkMonitor parent;

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

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

  gint surface_scale;
  gboolean fixed_surface_scale;

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

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

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

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

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

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

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

  Window xid;

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

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

  gint surface_scale;

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

  cairo_surface_t *cairo_surface;

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

  int abs_x;
  int abs_y;

  guint64 map_time;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11SurfaceClass</NAME>
struct _GdkX11SurfaceClass 
{
  GdkSurfaceClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdkToplevelX11</NAME>
struct _GdkToplevelX11
{

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

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

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

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

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

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

  guint is_leader : 1;

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

  guint in_frame : 1;

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

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

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

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

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

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

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

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

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

  guint32 red_mask;
  guint32 green_mask;
  guint32 blue_mask;

  Visual *xvisual;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_visual_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_visual_get_xvisual</NAME>
<RETURNS>Visual *</RETURNS>
GdkX11Visual *visual
</FUNCTION>
<MACRO>
<NAME>GDK_VISUAL_XVISUAL</NAME>
#define GDK_VISUAL_XVISUAL(visual)    (gdk_x11_visual_get_xvisual (visual))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_screen_lookup_visual</NAME>
<RETURNS>GdkX11Visual *</RETURNS>
GdkX11Screen *screen, VisualID      xvisualid
</FUNCTION>
<STRUCT>
<NAME>GdkX11VisualClass</NAME>
</STRUCT>
<MACRO>
<NAME>VK_USE_PLATFORM_XLIB_KHR</NAME>
#define VK_USE_PLATFORM_XLIB_KHR
</MACRO>
<MACRO>
<NAME>GDK_TYPE_X11_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_X11_VULKAN_CONTEXT		(gdk_x11_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT</NAME>
#define GDK_X11_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VULKAN_CONTEXT</NAME>
#define GDK_IS_X11_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_X11_VULKAN_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_VULKAN_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_VULKAN_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContextClass))
</MACRO>
<STRUCT>
<NAME>GdkX11VulkanContext</NAME>
struct _GdkX11VulkanContext
{
  GdkVulkanContext parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11VulkanContextClass</NAME>
struct _GdkX11VulkanContextClass
{
  GdkVulkanContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_vulkan_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_TYPE_X11_APP_LAUNCH_CONTEXT              (gdk_x11_app_launch_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT_CLASS</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_IS_X11_APP_LAUNCH_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_APP_LAUNCH_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_APP_LAUNCH_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_APP_LAUNCH_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_APP_LAUNCH_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContextClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11AppLaunchContext</NAME>
typedef GdkAppLaunchContext GdkX11AppLaunchContext;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_app_launch_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11AppLaunchContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11AppLaunchContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_XI2</NAME>
#define GDK_TYPE_X11_DEVICE_XI2         (gdk_x11_device_xi2_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2</NAME>
#define GDK_X11_DEVICE_XI2(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2</NAME>
#define GDK_IS_X11_DEVICE_XI2(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_IS_X11_DEVICE_XI2_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_GET_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_get_id</NAME>
<RETURNS>gint</RETURNS>
GdkDevice *device
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_TYPE_X11_DEVICE_MANAGER_XI2         (gdk_x11_device_manager_xi2_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI2(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI2_CLASS</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI2_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2_GET_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2Class))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_manager_xi2_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceManagerXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_manager_lookup</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkX11DeviceManagerXI2 *device_manager, gint                    device_id
</FUNCTION>
<TYPEDEF>
<NAME>GdkX11Display</NAME>
typedef GdkDisplay GdkX11Display;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_DISPLAY</NAME>
#define GDK_TYPE_X11_DISPLAY              (gdk_x11_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY</NAME>
#define GDK_X11_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DISPLAY, GdkX11Display))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_CLASS</NAME>
#define GDK_X11_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY</NAME>
#define GDK_IS_X11_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY_CLASS</NAME>
#define GDK_IS_X11_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_GET_CLASS</NAME>
#define GDK_X11_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_open</NAME>
<RETURNS>GdkDisplay *</RETURNS>
const char  *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xdisplay</NAME>
<RETURNS>Display *</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xscreen</NAME>
<RETURNS>Screen *</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xrootwindow</NAME>
<RETURNS>Window</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xcursor</NAME>
<RETURNS>Cursor</RETURNS>
GdkDisplay  *display, GdkCursor   *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_DISPLAY_XDISPLAY</NAME>
#define GDK_DISPLAY_XDISPLAY(display) (gdk_x11_display_get_xdisplay (display))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_user_time</NAME>
<RETURNS>guint32</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_startup_notification_id</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_startup_notification_id</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const gchar *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_program_class</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const char  *program_class
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_cursor_theme</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const gchar *theme, const gint   size
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_broadcast_startup_message</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, const char *message_type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_lookup_xdisplay</NAME>
<RETURNS>GdkDisplay *</RETURNS>
Display *xdisplay
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_screen</NAME>
<RETURNS>GdkX11Screen *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_primary_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_grab</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_ungrab</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_surface_scale</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, gint scale
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_push</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop</NAME>
<RETURNS>gint</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop_ignored</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_register_standard_event_type</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, gint        event_base, gint        n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_set_sm_client_id</NAME>
<RETURNS>void</RETURNS>
const gchar *sm_client_id
</FUNCTION>
<STRUCT>
<NAME>GdkX11Display</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DisplayClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DRAG</NAME>
#define GDK_TYPE_X11_DRAG              (gdk_x11_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG</NAME>
#define GDK_X11_DRAG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DRAG, GdkX11Drag))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_CLASS</NAME>
#define GDK_X11_DRAG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DRAG, GdkX11DragClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG</NAME>
#define GDK_IS_X11_DRAG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG_CLASS</NAME>
#define GDK_IS_X11_DRAG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_GET_CLASS</NAME>
#define GDK_X11_DRAG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DRAG, GdkX11DragClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11Drag</NAME>
typedef GdkDrag GdkX11Drag;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11Drag</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DragClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_GL_CONTEXT</NAME>
#define GDK_TYPE_X11_GL_CONTEXT		(gdk_x11_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_GL_CONTEXT</NAME>
#define GDK_X11_GL_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_GL_CONTEXT, GdkX11GLContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_IS_GL_CONTEXT</NAME>
#define GDK_X11_IS_GL_CONTEXT(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_GL_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_glx_version</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display, gint       *major, gint       *minor
</FUNCTION>
<STRUCT>
<NAME>GdkX11GLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContextClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkX11Keymap</NAME>
typedef GdkKeymap GdkX11Keymap;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_KEYMAP</NAME>
#define GDK_TYPE_X11_KEYMAP              (gdk_x11_keymap_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP</NAME>
#define GDK_X11_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_KEYMAP, GdkX11Keymap))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_CLASS</NAME>
#define GDK_X11_KEYMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP</NAME>
#define GDK_IS_X11_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP_CLASS</NAME>
#define GDK_IS_X11_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_GET_CLASS</NAME>
#define GDK_X11_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_keymap_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_keymap_get_group_for_state</NAME>
<RETURNS>gint</RETURNS>
GdkKeymap *keymap, guint      state
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_keymap_key_is_modifier</NAME>
<RETURNS>gboolean</RETURNS>
GdkKeymap *keymap, guint      keycode
</FUNCTION>
<STRUCT>
<NAME>GdkX11Keymap</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11KeymapClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_MONITOR</NAME>
#define GDK_TYPE_X11_MONITOR           (gdk_x11_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_MONITOR</NAME>
#define GDK_X11_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_MONITOR, GdkX11Monitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_MONITOR</NAME>
#define GDK_IS_X11_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_MONITOR))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_monitor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_monitor_get_output</NAME>
<RETURNS>XID</RETURNS>
GdkMonitor *monitor
</FUNCTION>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11MonitorClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_get_xatom_by_name_for_display</NAME>
<RETURNS>Atom</RETURNS>
GdkDisplay  *display, const gchar *atom_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_get_xatom_name_for_display</NAME>
<RETURNS>const gchar *</RETURNS>
GdkDisplay  *display, Atom         xatom
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SCREEN</NAME>
#define GDK_TYPE_X11_SCREEN              (gdk_x11_screen_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN</NAME>
#define GDK_X11_SCREEN(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SCREEN, GdkX11Screen))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_CLASS</NAME>
#define GDK_X11_SCREEN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN</NAME>
#define GDK_IS_X11_SCREEN(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN_CLASS</NAME>
#define GDK_IS_X11_SCREEN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_GET_CLASS</NAME>
#define GDK_X11_SCREEN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_screen_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_xscreen</NAME>
<RETURNS>Screen *</RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_screen_number</NAME>
<RETURNS>int</RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_window_manager_name</NAME>
<RETURNS>const char *</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_supports_net_wm_hint</NAME>
<RETURNS>gboolean</RETURNS>
GdkX11Screen *screen, const char   *property_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_monitor_output</NAME>
<RETURNS>XID</RETURNS>
GdkX11Screen *screen, gint          monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_number_of_desktops</NAME>
<RETURNS>guint32</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_current_desktop</NAME>
<RETURNS>guint32</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<STRUCT>
<NAME>GdkX11Screen</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11ScreenClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_display_text_property_to_text_list</NAME>
<RETURNS>gint</RETURNS>
GdkDisplay   *display, const char   *encoding, gint          format, const guchar *text, gint          length, gchar      ***list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_text_list</NAME>
<RETURNS>void</RETURNS>
gchar       **list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_string_to_compound_text</NAME>
<RETURNS>gint</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, gint         *format, guchar      **ctext, gint         *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_utf8_to_compound_text</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, gint         *format, guchar      **ctext, gint         *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_compound_text</NAME>
<RETURNS>void</RETURNS>
guchar       *ctext
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SURFACE</NAME>
#define GDK_TYPE_X11_SURFACE              (gdk_x11_surface_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE</NAME>
#define GDK_X11_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SURFACE, GdkX11Surface))
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE_CLASS</NAME>
#define GDK_X11_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SURFACE</NAME>
#define GDK_IS_X11_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SURFACE_CLASS</NAME>
#define GDK_IS_X11_SURFACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE_GET_CLASS</NAME>
#define GDK_X11_SURFACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11Surface</NAME>
typedef GdkSurface GdkX11Surface;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_xid</NAME>
<RETURNS>Window</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_user_time</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, guint32      timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_utf8_property</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, const gchar *name, const gchar *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_theme_variant</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, const char  *variant
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_move_to_current_desktop</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_desktop</NAME>
<RETURNS>guint32</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_move_to_desktop</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, guint32      desktop
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_frame_sync_enabled</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean   frame_sync_enabled
</FUNCTION>
<MACRO>
<NAME>GDK_SURFACE_XDISPLAY</NAME>
#define GDK_SURFACE_XDISPLAY(win)      (GDK_DISPLAY_XDISPLAY (gdk_surface_get_display (win)))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_XID</NAME>
#define GDK_SURFACE_XID(win)           (gdk_x11_surface_get_xid (win))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_get_server_time</NAME>
<RETURNS>guint32</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_lookup_for_display</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display, Window      window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_skip_taskbar_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    skips_taskbar
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_skip_pager_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    skips_pager
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_urgency_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    urgent
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_group</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkSurface *leader
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_group</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkSurface *surface
</FUNCTION>
<STRUCT>
<NAME>GdkX11Surface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11SurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_XID_TO_POINTER</NAME>
#define GDK_XID_TO_POINTER(xid) GUINT_TO_POINTER(xid)
</MACRO>
<MACRO>
<NAME>GDK_POINTER_TO_XID</NAME>
#define GDK_POINTER_TO_XID(pointer) GPOINTER_TO_UINT(pointer)
</MACRO>
<FUNCTION>
<NAME>gdk_xsettings_root_window_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>gdk_xsettings_manager_window_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, gpointer      data
</FUNCTION>
<MACRO>
<NAME>GDK_WINDOWING_X11</NAME>
#define GDK_WINDOWING_X11
</MACRO>
<MACRO>
<NAME>GDK_WINDOWING_WAYLAND</NAME>
#define GDK_WINDOWING_WAYLAND
</MACRO>
<MACRO>
<NAME>GDK_RENDERING_VULKAN</NAME>
#define GDK_RENDERING_VULKAN
</MACRO>
<MACRO>
<NAME>GDK_TYPE_INPUT_SOURCE</NAME>
#define GDK_TYPE_INPUT_SOURCE (gdk_input_source_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TYPE</NAME>
#define GDK_TYPE_DEVICE_TYPE (gdk_device_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD_FEATURE</NAME>
#define GDK_TYPE_DEVICE_PAD_FEATURE (gdk_device_pad_feature_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL_TYPE</NAME>
#define GDK_TYPE_DEVICE_TOOL_TYPE (gdk_device_tool_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_CANCEL_REASON</NAME>
#define GDK_TYPE_DRAG_CANCEL_REASON (gdk_drag_cancel_reason_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_TYPE</NAME>
#define GDK_TYPE_EVENT_TYPE (gdk_event_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCHPAD_GESTURE_PHASE</NAME>
#define GDK_TYPE_TOUCHPAD_GESTURE_PHASE (gdk_touchpad_gesture_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SCROLL_DIRECTION</NAME>
#define GDK_TYPE_SCROLL_DIRECTION (gdk_scroll_direction_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_NOTIFY_TYPE</NAME>
#define GDK_TYPE_NOTIFY_TYPE (gdk_notify_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CROSSING_MODE</NAME>
#define GDK_TYPE_CROSSING_MODE (gdk_crossing_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_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_HINTS</NAME>
#define GDK_TYPE_SURFACE_HINTS (gdk_surface_hints_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SURFACE_EDGE</NAME>
#define GDK_TYPE_SURFACE_EDGE (gdk_surface_edge_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FULLSCREEN_MODE</NAME>
#define GDK_TYPE_FULLSCREEN_MODE (gdk_fullscreen_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SURFACE_STATE</NAME>
#define GDK_TYPE_SURFACE_STATE (gdk_surface_state_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAVITY</NAME>
#define GDK_TYPE_GRAVITY (gdk_gravity_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_BYTE_ORDER</NAME>
#define GDK_TYPE_BYTE_ORDER (gdk_byte_order_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MODIFIER_TYPE</NAME>
#define GDK_TYPE_MODIFIER_TYPE (gdk_modifier_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MODIFIER_INTENT</NAME>
#define GDK_TYPE_MODIFIER_INTENT (gdk_modifier_intent_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAB_STATUS</NAME>
#define GDK_TYPE_GRAB_STATUS (gdk_grab_status_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAB_OWNERSHIP</NAME>
#define GDK_TYPE_GRAB_OWNERSHIP (gdk_grab_ownership_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_MASK</NAME>
#define GDK_TYPE_EVENT_MASK (gdk_event_mask_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GL_ERROR</NAME>
#define GDK_TYPE_GL_ERROR (gdk_gl_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_VULKAN_ERROR</NAME>
#define GDK_TYPE_VULKAN_ERROR (gdk_vulkan_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SURFACE_TYPE_HINT</NAME>
#define GDK_TYPE_SURFACE_TYPE_HINT (gdk_surface_type_hint_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_USE</NAME>
#define GDK_TYPE_AXIS_USE (gdk_axis_use_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_FLAGS</NAME>
#define GDK_TYPE_AXIS_FLAGS (gdk_axis_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_ACTION</NAME>
#define GDK_TYPE_DRAG_ACTION (gdk_drag_action_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MAJOR_VERSION</NAME>
#define GDK_MAJOR_VERSION (3)
</MACRO>
<MACRO>
<NAME>GDK_MINOR_VERSION</NAME>
#define GDK_MINOR_VERSION (98)
</MACRO>
<MACRO>
<NAME>GDK_MICRO_VERSION</NAME>
#define GDK_MICRO_VERSION (1)
</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>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_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>
<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>
<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.
	 * @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);
};
</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_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_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>
<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>
<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>
