<MACRO>
<NAME>GDK_TYPE_APP_LAUNCH_CONTEXT</NAME>
#define GDK_TYPE_APP_LAUNCH_CONTEXT         (gdk_app_launch_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_APP_LAUNCH_CONTEXT</NAME>
#define GDK_APP_LAUNCH_CONTEXT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_APP_LAUNCH_CONTEXT, GdkAppLaunchContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_APP_LAUNCH_CONTEXT</NAME>
        #define GDK_IS_APP_LAUNCH_CONTEXT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_APP_LAUNCH_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_app_launch_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkAppLaunchContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_desktop</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, int                  desktop
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_timestamp</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, guint32              timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_icon</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, GIcon               *icon
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_icon_name</NAME>
<RETURNS>void</RETURNS>
GdkAppLaunchContext *context, const char          *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_set_source_rgba</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const GdkRGBA        *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_set_source_pixbuf</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const GdkPixbuf      *pixbuf, double                pixbuf_x, double                pixbuf_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_rectangle</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const GdkRectangle   *rectangle
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_region</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, const cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_region_create_from_surface</NAME>
<RETURNS>cairo_region_t *</RETURNS>
cairo_surface_t      *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_draw_from_gl</NAME>
<RETURNS>void</RETURNS>
cairo_t              *cr, GdkSurface            *surface, int                   source, int                   source_type, int                   buffer_scale, int                   x, int                   y, int                   width, int                   height
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_CAIRO_CONTEXT</NAME>
#define GDK_TYPE_CAIRO_CONTEXT             (gdk_cairo_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CAIRO_CONTEXT</NAME>
#define GDK_CAIRO_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_CAIRO_CONTEXT, GdkCairoContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_CAIRO_CONTEXT</NAME>
#define GDK_IS_CAIRO_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_CAIRO_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_CAIRO_ERROR</NAME>
#define GDK_CAIRO_ERROR                    (gdk_cairo_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_cairo_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_context_cairo_create</NAME>
<RETURNS>cairo_t *</RETURNS>
GdkCairoContext        *self
</FUNCTION>
<MACRO>
<NAME>GDK_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>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);

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

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

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_content_provider_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_ref_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_ref_storable_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_content_changed</NAME>
<RETURNS>void</RETURNS>
GdkContentProvider     *provider
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_write_mime_type_async</NAME>
<RETURNS>void</RETURNS>
GdkContentProvider     *provider, const char             *mime_type, GOutputStream          *stream, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_write_mime_type_finish</NAME>
<RETURNS>gboolean</RETURNS>
GdkContentProvider     *provider, GAsyncResult           *result, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_get_value</NAME>
<RETURNS>gboolean</RETURNS>
GdkContentProvider     *provider, GValue                 *value, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_for_value</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
const GValue           *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_typed</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GType                   type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_union</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GdkContentProvider    **providers, gsize                   n_providers
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_provider_new_for_bytes</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
const char             *mime_type, GBytes                 *bytes
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_CONTENT_SERIALIZER</NAME>
#define GDK_TYPE_CONTENT_SERIALIZER         (gdk_content_serializer_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_SERIALIZER</NAME>
#define GDK_CONTENT_SERIALIZER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_CONTENT_SERIALIZER, GdkContentSerializer))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_SERIALIZER</NAME>
#define GDK_IS_CONTENT_SERIALIZER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_CONTENT_SERIALIZER))
</MACRO>
<USER_FUNCTION>
<NAME>GdkContentSerializeFunc</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer *serializer
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_mime_type</NAME>
<RETURNS>const char *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_gtype</NAME>
<RETURNS>GType</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_value</NAME>
<RETURNS>const GValue *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_output_stream</NAME>
<RETURNS>GOutputStream *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_priority</NAME>
<RETURNS>int</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_cancellable</NAME>
<RETURNS>GCancellable *</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_user_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_set_task_data</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_task_data</NAME>
<RETURNS>gpointer</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_success</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_error</NAME>
<RETURNS>void</RETURNS>
GdkContentSerializer   *serializer, GError                 *error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_gtypes</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_mime_types</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_register_serializer</NAME>
<RETURNS>void</RETURNS>
GType                   type, const char             *mime_type, GdkContentSerializeFunc serialize, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_async</NAME>
<RETURNS>void</RETURNS>
GOutputStream          *stream, const char             *mime_type, const GValue           *value, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_finish</NAME>
<RETURNS>gboolean</RETURNS>
GAsyncResult           *result, GError                **error
</FUNCTION>
<STRUCT>
<NAME>GdkContentSerializer</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CURSOR</NAME>
#define GDK_TYPE_CURSOR              (gdk_cursor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CURSOR</NAME>
#define GDK_CURSOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_CURSOR, GdkCursor))
</MACRO>
<MACRO>
<NAME>GDK_IS_CURSOR</NAME>
#define GDK_IS_CURSOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_CURSOR))
</MACRO>
<FUNCTION>
<NAME>gdk_cursor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_texture</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkTexture      *texture, int              hotspot_x, int              hotspot_y, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_name</NAME>
<RETURNS>GdkCursor *</RETURNS>
const char      *name, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_fallback</NAME>
<RETURNS>GdkCursor *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_name</NAME>
<RETURNS>const char *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_texture</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_x</NAME>
<RETURNS>int</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_y</NAME>
<RETURNS>int</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE</NAME>
#define GDK_TYPE_DEVICE         (gdk_device_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE</NAME>
#define GDK_DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE, GdkDevice))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE</NAME>
#define GDK_IS_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE))
</MACRO>
<ENUM>
<NAME>GdkInputSource</NAME>
typedef enum
{
  GDK_SOURCE_MOUSE,
  GDK_SOURCE_PEN,
  GDK_SOURCE_KEYBOARD,
  GDK_SOURCE_TOUCHSCREEN,
  GDK_SOURCE_TOUCHPAD,
  GDK_SOURCE_TRACKPOINT,
  GDK_SOURCE_TABLET_PAD
} GdkInputSource;
</ENUM>
<STRUCT>
<NAME>GdkTimeCoord</NAME>
struct _GdkTimeCoord
{
  guint32 time;
  GdkAxisFlags flags;
  double axes[GDK_AXIS_LAST];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_device_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_name</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_vendor_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_product_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_source</NAME>
<RETURNS>GdkInputSource</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_has_cursor</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_num_touches</NAME>
<RETURNS>guint</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_modifier_state</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_direction</NAME>
<RETURNS>PangoDirection</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_has_bidi_layouts</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_caps_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_num_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_scroll_lock_state</NAME>
<RETURNS>gboolean</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_surface_at_position</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDevice *device, double    *win_x, double    *win_y
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD</NAME>
#define GDK_TYPE_DEVICE_PAD         (gdk_device_pad_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_PAD</NAME>
#define GDK_DEVICE_PAD(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_PAD, GdkDevicePad))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_PAD</NAME>
#define GDK_IS_DEVICE_PAD(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_PAD))
</MACRO>
<ENUM>
<NAME>GdkDevicePadFeature</NAME>
typedef enum {
  GDK_DEVICE_PAD_FEATURE_BUTTON,
  GDK_DEVICE_PAD_FEATURE_RING,
  GDK_DEVICE_PAD_FEATURE_STRIP
} GdkDevicePadFeature;
</ENUM>
<FUNCTION>
<NAME>gdk_device_pad_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_groups</NAME>
<RETURNS>int</RETURNS>
GdkDevicePad *pad
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_group_n_modes</NAME>
<RETURNS>int</RETURNS>
GdkDevicePad *pad, int           group_idx
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_features</NAME>
<RETURNS>int</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_feature_group</NAME>
<RETURNS>int</RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature, int                  feature_idx
</FUNCTION>
<STRUCT>
<NAME>GdkDevicePad</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevicePadInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL</NAME>
#define GDK_TYPE_DEVICE_TOOL    (gdk_device_tool_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_TOOL</NAME>
#define GDK_DEVICE_TOOL(o)      (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_TOOL, GdkDeviceTool))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_TOOL</NAME>
#define GDK_IS_DEVICE_TOOL(o)   (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_TOOL))
</MACRO>
<ENUM>
<NAME>GdkDeviceToolType</NAME>
typedef enum {
  GDK_DEVICE_TOOL_TYPE_UNKNOWN,
  GDK_DEVICE_TOOL_TYPE_PEN,
  GDK_DEVICE_TOOL_TYPE_ERASER,
  GDK_DEVICE_TOOL_TYPE_BRUSH,
  GDK_DEVICE_TOOL_TYPE_PENCIL,
  GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
  GDK_DEVICE_TOOL_TYPE_MOUSE,
  GDK_DEVICE_TOOL_TYPE_LENS,
} GdkDeviceToolType;
</ENUM>
<FUNCTION>
<NAME>gdk_device_tool_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_serial</NAME>
<RETURNS>guint64</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_hardware_id</NAME>
<RETURNS>guint64</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_tool_type</NAME>
<RETURNS>GdkDeviceToolType</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_axes</NAME>
<RETURNS>GdkAxisFlags</RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<STRUCT>
<NAME>GdkDeviceTool</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DISPLAY</NAME>
#define GDK_TYPE_DISPLAY              (gdk_display_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY</NAME>
#define GDK_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY, GdkDisplay))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY</NAME>
#define GDK_IS_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY))
</MACRO>
<FUNCTION>
<NAME>gdk_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_open</NAME>
<RETURNS>GdkDisplay *</RETURNS>
const char *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_name</NAME>
<RETURNS>const char *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_device_is_grabbed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display, GdkDevice   *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_beep</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_sync</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_flush</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_close</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_closed</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_composited</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_rgba</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_input_shapes</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default</NAME>
<RETURNS>GdkDisplay *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_primary_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_notify_startup_complete</NAME>
<RETURNS>void</RETURNS>
GdkDisplay    *display, const char    *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_startup_notification_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_app_launch_context</NAME>
<RETURNS>GdkAppLaunchContext *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_list_seats</NAME>
<RETURNS>GList *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitors</NAME>
<RETURNS>GListModel *</RETURNS>
GdkDisplay *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor_at_surface</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display, GdkSurface  *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_put_event</NAME>
<RETURNS>void</RETURNS>
GdkDisplay     *display, GdkEvent       *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_map_keyval</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display, guint          keyval, GdkKeymapKey **keys, int           *n_keys
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_map_keycode</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay    *display, guint          keycode, GdkKeymapKey **keys, guint        **keyvals, int           *n_entries
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_translate_key</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay      *display, guint            keycode, GdkModifierType  state, int              group, guint           *keyval, int             *effective_group, int             *level, GdkModifierType *consumed
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_setting</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display, const char *name, GValue     *value
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DISPLAY_MANAGER</NAME>
#define GDK_TYPE_DISPLAY_MANAGER              (gdk_display_manager_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_MANAGER</NAME>
#define GDK_DISPLAY_MANAGER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MANAGER, GdkDisplayManager))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY_MANAGER</NAME>
#define GDK_IS_DISPLAY_MANAGER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_MANAGER))
</MACRO>
<FUNCTION>
<NAME>gdk_display_manager_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get</NAME>
<RETURNS>GdkDisplayManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get_default_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_set_default_display</NAME>
<RETURNS>void</RETURNS>
GdkDisplayManager *manager, GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_list_displays</NAME>
<RETURNS>GSList *</RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_open_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDisplayManager *manager, const char        *name
</FUNCTION>
<FUNCTION>
<NAME>gdk_set_allowed_backends</NAME>
<RETURNS>void</RETURNS>
const char        *backends
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG</NAME>
#define GDK_TYPE_DRAG              (gdk_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAG</NAME>
#define GDK_DRAG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG, GdkDrag))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAG</NAME>
#define GDK_IS_DRAG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG))
</MACRO>
<ENUM>
<NAME>GdkDragCancelReason</NAME>
typedef enum {
  GDK_DRAG_CANCEL_NO_TARGET,
  GDK_DRAG_CANCEL_USER_CANCELLED,
  GDK_DRAG_CANCEL_ERROR
} GdkDragCancelReason;
</ENUM>
<FUNCTION>
<NAME>gdk_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_selected_action</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_action_is_unique</NAME>
<RETURNS>gboolean</RETURNS>
GdkDragAction   action
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_begin</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkSurface         *surface, GdkDevice          *device, GdkContentProvider *content, GdkDragAction       actions, double              dx, double              dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_drop_done</NAME>
<RETURNS>void</RETURNS>
GdkDrag  *drag, gboolean  success
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_drag_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_set_hotspot</NAME>
<RETURNS>void</RETURNS>
GdkDrag *drag, int      hot_x, int      hot_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_content</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrag *drag
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG_SURFACE</NAME>
#define GDK_TYPE_DRAG_SURFACE (gdk_drag_surface_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_drag_surface_present</NAME>
<RETURNS>gboolean</RETURNS>
GdkDragSurface *drag_surface, int             width, int             height
</FUNCTION>
<STRUCT>
<NAME>GdkDragSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDragSurfaceInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DRAW_CONTEXT</NAME>
#define GDK_TYPE_DRAW_CONTEXT             (gdk_draw_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAW_CONTEXT</NAME>
#define GDK_DRAW_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_DRAW_CONTEXT, GdkDrawContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAW_CONTEXT</NAME>
#define GDK_IS_DRAW_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_DRAW_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_draw_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_begin_frame</NAME>
<RETURNS>void</RETURNS>
GdkDrawContext         *context, const cairo_region_t   *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_end_frame</NAME>
<RETURNS>void</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_is_in_frame</NAME>
<RETURNS>gboolean</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_draw_context_get_frame_region</NAME>
<RETURNS>const cairo_region_t *</RETURNS>
GdkDrawContext         *context
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DROP</NAME>
#define GDK_TYPE_DROP              (gdk_drop_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DROP</NAME>
#define GDK_DROP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DROP, GdkDrop))
</MACRO>
<MACRO>
<NAME>GDK_IS_DROP</NAME>
#define GDK_IS_DROP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DROP))
</MACRO>
<FUNCTION>
<NAME>gdk_drop_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_get_drag</NAME>
<RETURNS>GdkDrag *</RETURNS>
GdkDrop                *self
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_status</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, GdkDragAction           actions, GdkDragAction           preferred
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_finish</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, GdkDragAction           action
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_async</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, const char            **mime_types, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_finish</NAME>
<RETURNS>GInputStream *</RETURNS>
GdkDrop                *self, GAsyncResult           *result, const char            **out_mime_type, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_value_async</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *self, GType                   type, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_value_finish</NAME>
<RETURNS>const GValue *</RETURNS>
GdkDrop                *self, GAsyncResult           *result, GError                **error
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_EVENT</NAME>
#define GDK_TYPE_EVENT          (gdk_event_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_SEQUENCE</NAME>
#define GDK_TYPE_EVENT_SEQUENCE (gdk_event_sequence_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_IS_EVENT</NAME>
#define GDK_IS_EVENT(obj)       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_EVENT))
</MACRO>
<MACRO>
<NAME>GDK_EVENT</NAME>
#define GDK_EVENT(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_EVENT, GdkEvent))
</MACRO>
<MACRO>
<NAME>GDK_IS_EVENT_TYPE</NAME>
#define GDK_IS_EVENT_TYPE(event, type)  (gdk_event_get_event_type ((event)) == (type))
</MACRO>
<MACRO>
<NAME>GDK_PRIORITY_EVENTS</NAME>
#define GDK_PRIORITY_EVENTS	(G_PRIORITY_DEFAULT)
</MACRO>
<MACRO>
<NAME>GDK_PRIORITY_REDRAW</NAME>
#define GDK_PRIORITY_REDRAW     (G_PRIORITY_HIGH_IDLE + 20)
</MACRO>
<MACRO>
<NAME>GDK_EVENT_PROPAGATE</NAME>
#define GDK_EVENT_PROPAGATE     (FALSE)
</MACRO>
<MACRO>
<NAME>GDK_EVENT_STOP</NAME>
#define GDK_EVENT_STOP          (TRUE)
</MACRO>
<MACRO>
<NAME>GDK_BUTTON_PRIMARY</NAME>
#define GDK_BUTTON_PRIMARY      (1)
</MACRO>
<MACRO>
<NAME>GDK_BUTTON_MIDDLE</NAME>
#define GDK_BUTTON_MIDDLE       (2)
</MACRO>
<MACRO>
<NAME>GDK_BUTTON_SECONDARY</NAME>
#define GDK_BUTTON_SECONDARY    (3)
</MACRO>
<MACRO>
<NAME>GDK_TYPE_BUTTON_EVENT</NAME>
#define GDK_TYPE_BUTTON_EVENT (gdk_button_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CROSSING_EVENT</NAME>
#define GDK_TYPE_CROSSING_EVENT (gdk_crossing_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DELETE_EVENT</NAME>
#define GDK_TYPE_DELETE_EVENT (gdk_delete_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DND_EVENT</NAME>
#define GDK_TYPE_DND_EVENT (gdk_dnd_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FOCUS_EVENT</NAME>
#define GDK_TYPE_FOCUS_EVENT (gdk_focus_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAB_BROKEN_EVENT</NAME>
#define GDK_TYPE_GRAB_BROKEN_EVENT (gdk_grab_broken_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_KEY_EVENT</NAME>
#define GDK_TYPE_KEY_EVENT (gdk_key_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MOTION_EVENT</NAME>
#define GDK_TYPE_MOTION_EVENT (gdk_motion_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PAD_EVENT</NAME>
#define GDK_TYPE_PAD_EVENT (gdk_pad_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PROXIMITY_EVENT</NAME>
#define GDK_TYPE_PROXIMITY_EVENT (gdk_proximity_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SCROLL_EVENT</NAME>
#define GDK_TYPE_SCROLL_EVENT (gdk_scroll_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCH_EVENT</NAME>
#define GDK_TYPE_TOUCH_EVENT (gdk_touch_event_get_type())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCHPAD_EVENT</NAME>
#define GDK_TYPE_TOUCHPAD_EVENT (gdk_touchpad_event_get_type())
</MACRO>
<ENUM>
<NAME>GdkEventType</NAME>
typedef enum
{
  GDK_DELETE,
  GDK_MOTION_NOTIFY,
  GDK_BUTTON_PRESS,
  GDK_BUTTON_RELEASE,
  GDK_KEY_PRESS,
  GDK_KEY_RELEASE,
  GDK_ENTER_NOTIFY,
  GDK_LEAVE_NOTIFY,
  GDK_FOCUS_CHANGE,
  GDK_PROXIMITY_IN,
  GDK_PROXIMITY_OUT,
  GDK_DRAG_ENTER,
  GDK_DRAG_LEAVE,
  GDK_DRAG_MOTION,
  GDK_DROP_START,
  GDK_SCROLL,
  GDK_GRAB_BROKEN,
  GDK_TOUCH_BEGIN,
  GDK_TOUCH_UPDATE,
  GDK_TOUCH_END,
  GDK_TOUCH_CANCEL,
  GDK_TOUCHPAD_SWIPE,
  GDK_TOUCHPAD_PINCH,
  GDK_PAD_BUTTON_PRESS,
  GDK_PAD_BUTTON_RELEASE,
  GDK_PAD_RING,
  GDK_PAD_STRIP,
  GDK_PAD_GROUP_MODE,
  GDK_EVENT_LAST        /* helper variable for decls */
} GdkEventType;
</ENUM>
<ENUM>
<NAME>GdkTouchpadGesturePhase</NAME>
typedef enum
{
  GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
  GDK_TOUCHPAD_GESTURE_PHASE_UPDATE,
  GDK_TOUCHPAD_GESTURE_PHASE_END,
  GDK_TOUCHPAD_GESTURE_PHASE_CANCEL
} GdkTouchpadGesturePhase;
</ENUM>
<ENUM>
<NAME>GdkScrollDirection</NAME>
typedef enum
{
  GDK_SCROLL_UP,
  GDK_SCROLL_DOWN,
  GDK_SCROLL_LEFT,
  GDK_SCROLL_RIGHT,
  GDK_SCROLL_SMOOTH
} GdkScrollDirection;
</ENUM>
<ENUM>
<NAME>GdkNotifyType</NAME>
typedef enum
{
  GDK_NOTIFY_ANCESTOR		= 0,
  GDK_NOTIFY_VIRTUAL		= 1,
  GDK_NOTIFY_INFERIOR		= 2,
  GDK_NOTIFY_NONLINEAR		= 3,
  GDK_NOTIFY_NONLINEAR_VIRTUAL	= 4,
  GDK_NOTIFY_UNKNOWN		= 5
} GdkNotifyType;
</ENUM>
<ENUM>
<NAME>GdkCrossingMode</NAME>
typedef enum
{
  GDK_CROSSING_NORMAL,
  GDK_CROSSING_GRAB,
  GDK_CROSSING_UNGRAB,
  GDK_CROSSING_GTK_GRAB,
  GDK_CROSSING_GTK_UNGRAB,
  GDK_CROSSING_STATE_CHANGED,
  GDK_CROSSING_TOUCH_BEGIN,
  GDK_CROSSING_TOUCH_END,
  GDK_CROSSING_DEVICE_SWITCH
} GdkCrossingMode;
</ENUM>
<FUNCTION>
<NAME>gdk_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_sequence_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_ref</NAME>
<RETURNS>GdkEvent *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_unref</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_type</NAME>
<RETURNS>GdkEventType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_seat</NAME>
<RETURNS>GdkSeat *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_time</NAME>
<RETURNS>guint32</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_sequence</NAME>
<RETURNS>GdkEventSequence *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_modifier_state</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_position</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent  *event, double	   *x, double	   *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axes</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent  *event, double   **axes, guint     *n_axes
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axis</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent   *event, GdkAxisUse  axis_use, double     *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_history</NAME>
<RETURNS>GdkTimeCoord *</RETURNS>
GdkEvent *event, guint    *out_n_coords
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_pointer_emulated</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_button_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_button_event_get_button</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_get_direction</NAME>
<RETURNS>GdkScrollDirection</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_get_deltas</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, double   *delta_x, double   *delta_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_scroll_event_is_stop</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_keyval</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_keycode</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_consumed_modifiers</NAME>
<RETURNS>GdkModifierType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_layout</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_level</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_is_modifier</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_focus_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_focus_event_get_in</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touch_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_touch_event_get_emulating_pointer</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_mode</NAME>
<RETURNS>GdkCrossingMode</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_detail</NAME>
<RETURNS>GdkNotifyType</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_crossing_event_get_focus</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_gesture_phase</NAME>
<RETURNS>GdkTouchpadGesturePhase</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_n_fingers</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_deltas</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, double   *dx, double   *dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_pinch_angle_delta</NAME>
<RETURNS>double</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_touchpad_event_get_pinch_scale</NAME>
<RETURNS>double</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_button</NAME>
<RETURNS>guint</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_axis_value</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, guint    *index, double   *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_pad_event_get_group_mode</NAME>
<RETURNS>void</RETURNS>
GdkEvent *event, guint    *group, guint    *mode
</FUNCTION>
<FUNCTION>
<NAME>gdk_dnd_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_dnd_event_get_drop</NAME>
<RETURNS>GdkDrop *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_grab_broken_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_grab_broken_event_get_grab_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_grab_broken_event_get_implicit</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_motion_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_delete_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_proximity_event_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_triggers_context_menu</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_distance</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event1, GdkEvent *event2, double   *distance
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_angle</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event1, GdkEvent *event2, double   *angle
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_center</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent *event1, GdkEvent *event2, double   *x, double   *y
</FUNCTION>
<ENUM>
<NAME>GdkKeyMatch</NAME>
typedef enum {
  GDK_KEY_MATCH_NONE,
  GDK_KEY_MATCH_PARTIAL,
  GDK_KEY_MATCH_EXACT
} GdkKeyMatch;
</ENUM>
<FUNCTION>
<NAME>gdk_key_event_matches</NAME>
<RETURNS>GdkKeyMatch</RETURNS>
GdkEvent        *event, guint            keyval, GdkModifierType  modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_key_event_get_match</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent        *event, guint           *keyval, GdkModifierType *modifiers
</FUNCTION>
<STRUCT>
<NAME>GdkButtonEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCrossingEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDNDEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDeleteEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventSequence</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFocusEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGrabBrokenEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkKeyEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkMotionEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPadEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkProximityEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkScrollEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTouchEvent</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTouchpadEvent</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK</NAME>
#define GDK_TYPE_FRAME_CLOCK            (gdk_frame_clock_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK</NAME>
#define GDK_FRAME_CLOCK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClock))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_CLASS</NAME>
#define GDK_FRAME_CLOCK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK</NAME>
#define GDK_IS_FRAME_CLOCK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK_CLASS</NAME>
#define GDK_IS_FRAME_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_GET_CLASS</NAME>
#define GDK_FRAME_CLOCK_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<ENUM>
<NAME>GdkFrameClockPhase</NAME>
typedef enum {
  GDK_FRAME_CLOCK_PHASE_NONE          = 0,
  GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS  = 1 << 0,
  GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT  = 1 << 1,
  GDK_FRAME_CLOCK_PHASE_UPDATE        = 1 << 2,
  GDK_FRAME_CLOCK_PHASE_LAYOUT        = 1 << 3,
  GDK_FRAME_CLOCK_PHASE_PAINT         = 1 << 4,
  GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS = 1 << 5,
  GDK_FRAME_CLOCK_PHASE_AFTER_PAINT   = 1 << 6
} GdkFrameClockPhase;
</ENUM>
<FUNCTION>
<NAME>gdk_frame_clock_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_request_phase</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock, GdkFrameClockPhase  phase
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_begin_updating</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_end_updating</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_counter</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_history_start</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_timings</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameClock *frame_clock, gint64         frame_counter
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_current_timings</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_refresh_info</NAME>
<RETURNS>void</RETURNS>
GdkFrameClock *frame_clock, gint64         base_time, gint64        *refresh_interval_return, gint64        *presentation_time_return
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_fps</NAME>
<RETURNS>double</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<STRUCT>
<NAME>GdkFrameClock</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_frame_timings_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_ref</NAME>
<RETURNS>GdkFrameTimings *</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_unref</NAME>
<RETURNS>void</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_frame_counter</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_complete</NAME>
<RETURNS>gboolean</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_frame_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_presentation_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_refresh_interval</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_timings_get_predicted_presentation_time</NAME>
<RETURNS>gint64</RETURNS>
GdkFrameTimings *timings
</FUNCTION>
<STRUCT>
<NAME>GdkFrameTimings</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_GL_CONTEXT</NAME>
#define GDK_TYPE_GL_CONTEXT             (gdk_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_GL_CONTEXT</NAME>
#define GDK_GL_CONTEXT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_CONTEXT, GdkGLContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_GL_CONTEXT</NAME>
#define GDK_IS_GL_CONTEXT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_GL_ERROR</NAME>
#define GDK_GL_ERROR       (gdk_gl_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gdk_gl_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_shared_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int           *major, int           *minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_is_legacy</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_required_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int            major, int            minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_required_version</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int           *major, int           *minor
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_debug_enabled</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, gboolean       enabled
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_debug_enabled</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_forward_compatible</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, gboolean       compatible
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_forward_compatible</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_set_use_es</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context, int            use_es
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_use_es</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_realize</NAME>
<RETURNS>gboolean</RETURNS>
GdkGLContext  *context, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_make_current</NAME>
<RETURNS>void</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_get_current</NAME>
<RETURNS>GdkGLContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_context_clear_current</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_GL_TEXTURE</NAME>
#define GDK_TYPE_GL_TEXTURE (gdk_gl_texture_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_GL_TEXTURE</NAME>
#define GDK_GL_TEXTURE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_GL_TEXTURE, GdkGLTexture))
</MACRO>
<MACRO>
<NAME>GDK_IS_GL_TEXTURE</NAME>
#define GDK_IS_GL_TEXTURE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_GL_TEXTURE))
</MACRO>
<FUNCTION>
<NAME>gdk_gl_texture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_texture_new</NAME>
<RETURNS>GdkTexture *</RETURNS>
GdkGLContext    *context, guint            id, int              width, int              height, GDestroyNotify   destroy, gpointer         data
</FUNCTION>
<FUNCTION>
<NAME>gdk_gl_texture_release</NAME>
<RETURNS>void</RETURNS>
GdkGLTexture    *self
</FUNCTION>
<STRUCT>
<NAME>GdkGLTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLTextureClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_keyval_name</NAME>
<RETURNS>const char *</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_from_name</NAME>
<RETURNS>guint</RETURNS>
const char *keyval_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_convert_case</NAME>
<RETURNS>void</RETURNS>
guint        symbol, guint       *lower, guint       *upper
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_upper</NAME>
<RETURNS>guint</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_lower</NAME>
<RETURNS>guint</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_upper</NAME>
<RETURNS>gboolean</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_lower</NAME>
<RETURNS>gboolean</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_unicode</NAME>
<RETURNS>guint32</RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_unicode_to_keyval</NAME>
<RETURNS>guint</RETURNS>
guint32      wc
</FUNCTION>
<ENUM>
<NAME>GdkMemoryFormat</NAME>
typedef enum {
  GDK_MEMORY_B8G8R8A8_PREMULTIPLIED,
  GDK_MEMORY_A8R8G8B8_PREMULTIPLIED,
  GDK_MEMORY_R8G8B8A8_PREMULTIPLIED,
  GDK_MEMORY_B8G8R8A8,
  GDK_MEMORY_A8R8G8B8,
  GDK_MEMORY_R8G8B8A8,
  GDK_MEMORY_A8B8G8R8,
  GDK_MEMORY_R8G8B8,
  GDK_MEMORY_B8G8R8,

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

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

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

  GDK_SUPER_MASK    = 1 << 26,
  GDK_HYPER_MASK    = 1 << 27,
  GDK_META_MASK     = 1 << 28,
} GdkModifierType;
</ENUM>
<MACRO>
<NAME>GDK_MODIFIER_MASK</NAME>
#define GDK_MODIFIER_MASK (GDK_SHIFT_MASK|GDK_LOCK_MASK|GDK_CONTROL_MASK| \
                           GDK_ALT_MASK|GDK_SUPER_MASK|GDK_HYPER_MASK|GDK_META_MASK| \
                           GDK_BUTTON1_MASK|GDK_BUTTON2_MASK|GDK_BUTTON3_MASK| \
                           GDK_BUTTON4_MASK|GDK_BUTTON5_MASK)
</MACRO>
<ENUM>
<NAME>GdkGLError</NAME>
typedef enum {
  GDK_GL_ERROR_NOT_AVAILABLE,
  GDK_GL_ERROR_UNSUPPORTED_FORMAT,
  GDK_GL_ERROR_UNSUPPORTED_PROFILE,
  GDK_GL_ERROR_COMPILATION_FAILED,
  GDK_GL_ERROR_LINK_FAILED
} GdkGLError;
</ENUM>
<ENUM>
<NAME>GdkVulkanError</NAME>
typedef enum {
  GDK_VULKAN_ERROR_UNSUPPORTED,
  GDK_VULKAN_ERROR_NOT_AVAILABLE,
} GdkVulkanError;
</ENUM>
<ENUM>
<NAME>GdkAxisUse</NAME>
typedef enum
{
  GDK_AXIS_IGNORE,
  GDK_AXIS_X,
  GDK_AXIS_Y,
  GDK_AXIS_DELTA_X,
  GDK_AXIS_DELTA_Y,
  GDK_AXIS_PRESSURE,
  GDK_AXIS_XTILT,
  GDK_AXIS_YTILT,
  GDK_AXIS_WHEEL,
  GDK_AXIS_DISTANCE,
  GDK_AXIS_ROTATION,
  GDK_AXIS_SLIDER,
  GDK_AXIS_LAST
} GdkAxisUse;
</ENUM>
<ENUM>
<NAME>GdkAxisFlags</NAME>
typedef enum
{
  GDK_AXIS_FLAG_X        = 1 << GDK_AXIS_X,
  GDK_AXIS_FLAG_Y        = 1 << GDK_AXIS_Y,
  GDK_AXIS_FLAG_DELTA_X  = 1 << GDK_AXIS_DELTA_X,
  GDK_AXIS_FLAG_DELTA_Y  = 1 << GDK_AXIS_DELTA_Y,
  GDK_AXIS_FLAG_PRESSURE = 1 << GDK_AXIS_PRESSURE,
  GDK_AXIS_FLAG_XTILT    = 1 << GDK_AXIS_XTILT,
  GDK_AXIS_FLAG_YTILT    = 1 << GDK_AXIS_YTILT,
  GDK_AXIS_FLAG_WHEEL    = 1 << GDK_AXIS_WHEEL,
  GDK_AXIS_FLAG_DISTANCE = 1 << GDK_AXIS_DISTANCE,
  GDK_AXIS_FLAG_ROTATION = 1 << GDK_AXIS_ROTATION,
  GDK_AXIS_FLAG_SLIDER   = 1 << GDK_AXIS_SLIDER,
} GdkAxisFlags;
</ENUM>
<ENUM>
<NAME>GdkDragAction</NAME>
typedef enum
{
  GDK_ACTION_COPY    = 1 << 0,
  GDK_ACTION_MOVE    = 1 << 1,
  GDK_ACTION_LINK    = 1 << 2,
  GDK_ACTION_ASK     = 1 << 3
} GdkDragAction;
</ENUM>
<MACRO>
<NAME>GDK_ACTION_ALL</NAME>
#define GDK_ACTION_ALL (GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK)
</MACRO>
<MACRO>
<NAME>GDK_DECLARE_INTERNAL_TYPE</NAME>
#define GDK_DECLARE_INTERNAL_TYPE(ModuleObjName, module_obj_name, MODULE, OBJ_NAME, ParentName) \
  GType module_obj_name##_get_type (void);                                                               \
  G_GNUC_BEGIN_IGNORE_DEPRECATIONS                                                                       \
  typedef struct _##ModuleObjName ModuleObjName;                                                         \
  typedef struct _##ModuleObjName##Class ModuleObjName##Class;                                           \
                                                                                                         \
  _GLIB_DEFINE_AUTOPTR_CHAINUP (ModuleObjName, ParentName)                                               \
  G_DEFINE_AUTOPTR_CLEANUP_FUNC (ModuleObjName##Class, g_type_class_unref)                               \
                                                                                                         \
  G_GNUC_UNUSED static inline ModuleObjName * MODULE##_##OBJ_NAME (gpointer ptr) {                       \
    return G_TYPE_CHECK_INSTANCE_CAST (ptr, module_obj_name##_get_type (), ModuleObjName); }             \
  G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_CLASS (gpointer ptr) {        \
    return G_TYPE_CHECK_CLASS_CAST (ptr, module_obj_name##_get_type (), ModuleObjName##Class); }         \
  G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME (gpointer ptr) {                           \
    return G_TYPE_CHECK_INSTANCE_TYPE (ptr, module_obj_name##_get_type ()); }                            \
  G_GNUC_UNUSED static inline gboolean MODULE##_IS_##OBJ_NAME##_CLASS (gpointer ptr) {                   \
    return G_TYPE_CHECK_CLASS_TYPE (ptr, module_obj_name##_get_type ()); }                               \
  G_GNUC_UNUSED static inline ModuleObjName##Class * MODULE##_##OBJ_NAME##_GET_CLASS (gpointer ptr) {    \
    return G_TYPE_INSTANCE_GET_CLASS (ptr, module_obj_name##_get_type (), ModuleObjName##Class); }       \
  G_GNUC_END_IGNORE_DEPRECATIONS
</MACRO>
<STRUCT>
<NAME>GdkKeymapKey</NAME>
struct _GdkKeymapKey
{
  guint keycode;
  int   group;
  int   level;
};
</STRUCT>
<MACRO>
<NAME>GDK_EXTERN_VAR</NAME>
#        define GDK_EXTERN_VAR __declspec(dllexport)
</MACRO>
<STRUCT>
<NAME>GdkAppLaunchContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCairoContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkClipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentFormats</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkContentProvider</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkCursor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplay</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDisplayManager</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrag</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawingContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrop</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>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>
<TYPEDEF>
<NAME>GdkWaylandDevice</NAME>
typedef GdkDevice GdkWaylandDevice;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_DEVICE</NAME>
#define GDK_TYPE_WAYLAND_DEVICE         (gdk_wayland_device_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE</NAME>
#define GDK_WAYLAND_DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDevice))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE_CLASS</NAME>
#define GDK_WAYLAND_DEVICE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDeviceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DEVICE</NAME>
#define GDK_IS_WAYLAND_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_DEVICE))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DEVICE_CLASS</NAME>
#define GDK_IS_WAYLAND_DEVICE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_WAYLAND_DEVICE))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE_GET_CLASS</NAME>
#define GDK_WAYLAND_DEVICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDeviceClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_device_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_seat</NAME>
<RETURNS>struct wl_seat *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_pointer</NAME>
<RETURNS>struct wl_pointer *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_keyboard</NAME>
<RETURNS>struct wl_keyboard *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_node_path</NAME>
<RETURNS>const char *</RETURNS>
GdkDevice *device
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDeviceClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkWaylandDisplay</NAME>
typedef GdkDisplay GdkWaylandDisplay;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_DISPLAY</NAME>
#define GDK_TYPE_WAYLAND_DISPLAY              (gdk_wayland_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY</NAME>
#define GDK_WAYLAND_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplay))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY_CLASS</NAME>
#define GDK_WAYLAND_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplayClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DISPLAY</NAME>
#define GDK_IS_WAYLAND_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DISPLAY_CLASS</NAME>
#define GDK_IS_WAYLAND_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY_GET_CLASS</NAME>
#define GDK_WAYLAND_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplayClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_wl_display</NAME>
<RETURNS>struct wl_display *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_wl_compositor</NAME>
<RETURNS>struct wl_compositor *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_set_cursor_theme</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const char *name, int          size
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_startup_notification_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_set_startup_notification_id</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, const char *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_query_registry</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay  *display, const char *global
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandDisplay</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDisplayClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_GL_CONTEXT</NAME>
#define GDK_TYPE_WAYLAND_GL_CONTEXT		(gdk_wayland_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_GL_CONTEXT</NAME>
#define GDK_WAYLAND_GL_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_GL_CONTEXT, GdkWaylandGLContext))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_IS_GL_CONTEXT</NAME>
#define GDK_WAYLAND_IS_GL_CONTEXT(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_GL_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandGLContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_MONITOR</NAME>
#define GDK_TYPE_WAYLAND_MONITOR           (gdk_wayland_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_MONITOR</NAME>
#define GDK_WAYLAND_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_MONITOR, GdkWaylandMonitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_MONITOR</NAME>
#define GDK_IS_WAYLAND_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_MONITOR))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_monitor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_monitor_get_wl_output</NAME>
<RETURNS>struct wl_output *</RETURNS>
GdkMonitor *monitor
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandMonitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandMonitorClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkWaylandSeat</NAME>
typedef GdkSeat GdkWaylandSeat;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_SEAT</NAME>
#define GDK_TYPE_WAYLAND_SEAT         (gdk_wayland_seat_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SEAT</NAME>
#define GDK_WAYLAND_SEAT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_WAYLAND_SEAT, GdkWaylandSeat))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SEAT</NAME>
#define GDK_IS_WAYLAND_SEAT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_SEAT))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_seat_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_get_wl_seat</NAME>
<RETURNS>struct wl_seat *</RETURNS>
GdkSeat *seat
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandSeat</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandSeatClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkWaylandSurface</NAME>
typedef GdkSurface GdkWaylandSurface;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkWaylandToplevel</NAME>
typedef GdkToplevel GdkWaylandToplevel;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkWaylandPopup</NAME>
typedef GdkPopup GdkWaylandPopup;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_SURFACE</NAME>
#define GDK_TYPE_WAYLAND_SURFACE              (gdk_wayland_surface_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SURFACE</NAME>
#define GDK_WAYLAND_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_SURFACE, GdkWaylandSurface))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SURFACE</NAME>
#define GDK_IS_WAYLAND_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_TOPLEVEL</NAME>
#define GDK_TYPE_WAYLAND_TOPLEVEL             (gdk_wayland_toplevel_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_TOPLEVEL</NAME>
#define GDK_WAYLAND_TOPLEVEL(object)          (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_TOPLEVEL, GdkWaylandToplevel))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_TOPLEVEL</NAME>
#define GDK_IS_WAYLAND_TOPLEVEL(object)       (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_TOPLEVEL))
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_POPUP</NAME>
#define GDK_TYPE_WAYLAND_POPUP                (gdk_wayland_popup_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_POPUP</NAME>
#define GDK_WAYLAND_POPUP(object)             (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_POPUP, GdkWaylandPopup))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_POPUP</NAME>
#define GDK_IS_WAYLAND_POPUP(object)          (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_POPUP))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_popup_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_surface_get_wl_surface</NAME>
<RETURNS>struct wl_surface *</RETURNS>
GdkSurface *surface
</FUNCTION>
<USER_FUNCTION>
<NAME>GdkWaylandToplevelExported</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel, const char  *handle, gpointer     user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_export_handle</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel              *toplevel, GdkWaylandToplevelExported callback, gpointer                 user_data, GDestroyNotify           destroy_func
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_unexport_handle</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_set_transient_for_exported</NAME>
<RETURNS>gboolean</RETURNS>
GdkToplevel *toplevel, const char   *parent_handle_str
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_toplevel_set_application_id</NAME>
<RETURNS>void</RETURNS>
GdkToplevel *toplevel, const char  *application_id
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandPopup</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandSurface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandToplevel</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_TYPE_X11_APP_LAUNCH_CONTEXT              (gdk_x11_app_launch_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT_CLASS</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_APP_LAUNCH_CONTEXT</NAME>
#define GDK_IS_X11_APP_LAUNCH_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_APP_LAUNCH_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_APP_LAUNCH_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_APP_LAUNCH_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_APP_LAUNCH_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_APP_LAUNCH_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_APP_LAUNCH_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_APP_LAUNCH_CONTEXT, GdkX11AppLaunchContextClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11AppLaunchContext</NAME>
typedef GdkAppLaunchContext GdkX11AppLaunchContext;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_app_launch_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11AppLaunchContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11AppLaunchContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_XI2</NAME>
#define GDK_TYPE_X11_DEVICE_XI2         (gdk_x11_device_xi2_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2</NAME>
#define GDK_X11_DEVICE_XI2(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2</NAME>
#define GDK_IS_X11_DEVICE_XI2(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_IS_X11_DEVICE_XI2_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_GET_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<ENUM>
<NAME>GdkX11DeviceType</NAME>
typedef enum {
  GDK_X11_DEVICE_TYPE_LOGICAL,
  GDK_X11_DEVICE_TYPE_PHYSICAL,
  GDK_X11_DEVICE_TYPE_FLOATING
} GdkX11DeviceType;
</ENUM>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_get_id</NAME>
<RETURNS>int</RETURNS>
GdkDevice *device
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_TYPE_X11_DEVICE_MANAGER_XI2         (gdk_x11_device_manager_xi2_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI2</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI2(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI2_CLASS</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI2_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI2_GET_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI2_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI2, GdkX11DeviceManagerXI2Class))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_manager_xi2_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceManagerXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_manager_lookup</NAME>
<RETURNS>GdkDevice *</RETURNS>
GdkX11DeviceManagerXI2 *device_manager, int                     device_id
</FUNCTION>
<TYPEDEF>
<NAME>GdkX11Display</NAME>
typedef GdkDisplay GdkX11Display;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_DISPLAY</NAME>
#define GDK_TYPE_X11_DISPLAY              (gdk_x11_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY</NAME>
#define GDK_X11_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DISPLAY, GdkX11Display))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_CLASS</NAME>
#define GDK_X11_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY</NAME>
#define GDK_IS_X11_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY_CLASS</NAME>
#define GDK_IS_X11_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_GET_CLASS</NAME>
#define GDK_X11_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_open</NAME>
<RETURNS>GdkDisplay *</RETURNS>
const char  *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xdisplay</NAME>
<RETURNS>Display *</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xscreen</NAME>
<RETURNS>Screen *</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xrootwindow</NAME>
<RETURNS>Window</RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xcursor</NAME>
<RETURNS>Cursor</RETURNS>
GdkDisplay  *display, GdkCursor   *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_DISPLAY_XDISPLAY</NAME>
#define GDK_DISPLAY_XDISPLAY(display) (gdk_x11_display_get_xdisplay (display))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_user_time</NAME>
<RETURNS>guint32</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_startup_notification_id</NAME>
<RETURNS>const char *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_startup_notification_id</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const char *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_program_class</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const char  *program_class
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_cursor_theme</NAME>
<RETURNS>void</RETURNS>
GdkDisplay  *display, const char *theme, const int    size
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_broadcast_startup_message</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, const char *message_type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_lookup_xdisplay</NAME>
<RETURNS>GdkDisplay *</RETURNS>
Display *xdisplay
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_screen</NAME>
<RETURNS>GdkX11Screen *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_primary_monitor</NAME>
<RETURNS>GdkMonitor *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_grab</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_ungrab</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_surface_scale</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display, int scale
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_push</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop</NAME>
<RETURNS>int</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop_ignored</NAME>
<RETURNS>void</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_set_sm_client_id</NAME>
<RETURNS>void</RETURNS>
const char *sm_client_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_default_group</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display
</FUNCTION>
<STRUCT>
<NAME>GdkX11Display</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DisplayClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DRAG</NAME>
#define GDK_TYPE_X11_DRAG              (gdk_x11_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG</NAME>
#define GDK_X11_DRAG(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DRAG, GdkX11Drag))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_CLASS</NAME>
#define GDK_X11_DRAG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DRAG, GdkX11DragClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG</NAME>
#define GDK_IS_X11_DRAG(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG_CLASS</NAME>
#define GDK_IS_X11_DRAG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DRAG))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_GET_CLASS</NAME>
#define GDK_X11_DRAG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DRAG, GdkX11DragClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11Drag</NAME>
typedef GdkDrag GdkX11Drag;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11Drag</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DragClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_GL_CONTEXT</NAME>
#define GDK_TYPE_X11_GL_CONTEXT		(gdk_x11_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_GL_CONTEXT</NAME>
#define GDK_X11_GL_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_GL_CONTEXT, GdkX11GLContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_IS_GL_CONTEXT</NAME>
#define GDK_X11_IS_GL_CONTEXT(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_GL_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_gl_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_glx_version</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay *display, int        *major, int        *minor
</FUNCTION>
<STRUCT>
<NAME>GdkX11GLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_MONITOR</NAME>
#define GDK_TYPE_X11_MONITOR           (gdk_x11_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_MONITOR</NAME>
#define GDK_X11_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_MONITOR, GdkX11Monitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_MONITOR</NAME>
#define GDK_IS_X11_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_MONITOR))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_monitor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_monitor_get_output</NAME>
<RETURNS>XID</RETURNS>
GdkMonitor *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_monitor_get_workarea</NAME>
<RETURNS>void</RETURNS>
GdkMonitor   *monitor, GdkRectangle *workarea
</FUNCTION>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11MonitorClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_get_xatom_by_name_for_display</NAME>
<RETURNS>Atom</RETURNS>
GdkDisplay  *display, const char *atom_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_get_xatom_name_for_display</NAME>
<RETURNS>const char *</RETURNS>
GdkDisplay  *display, Atom         xatom
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SCREEN</NAME>
#define GDK_TYPE_X11_SCREEN              (gdk_x11_screen_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN</NAME>
#define GDK_X11_SCREEN(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SCREEN, GdkX11Screen))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_CLASS</NAME>
#define GDK_X11_SCREEN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN</NAME>
#define GDK_IS_X11_SCREEN(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN_CLASS</NAME>
#define GDK_IS_X11_SCREEN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_GET_CLASS</NAME>
#define GDK_X11_SCREEN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_screen_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_xscreen</NAME>
<RETURNS>Screen *</RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_screen_number</NAME>
<RETURNS>int</RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_window_manager_name</NAME>
<RETURNS>const char *</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_supports_net_wm_hint</NAME>
<RETURNS>gboolean</RETURNS>
GdkX11Screen *screen, const char   *property_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_monitor_output</NAME>
<RETURNS>XID</RETURNS>
GdkX11Screen *screen, int           monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_number_of_desktops</NAME>
<RETURNS>guint32</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_current_desktop</NAME>
<RETURNS>guint32</RETURNS>
GdkX11Screen *screen
</FUNCTION>
<STRUCT>
<NAME>GdkX11Screen</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11ScreenClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_display_text_property_to_text_list</NAME>
<RETURNS>int</RETURNS>
GdkDisplay   *display, const char   *encoding, int           format, const guchar *text, int           length, char       ***list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_text_list</NAME>
<RETURNS>void</RETURNS>
char        **list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_string_to_compound_text</NAME>
<RETURNS>int</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, int          *format, guchar      **ctext, int          *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_utf8_to_compound_text</NAME>
<RETURNS>gboolean</RETURNS>
GdkDisplay   *display, const char   *str, const char  **encoding, int          *format, guchar      **ctext, int          *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_compound_text</NAME>
<RETURNS>void</RETURNS>
guchar       *ctext
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SURFACE</NAME>
#define GDK_TYPE_X11_SURFACE              (gdk_x11_surface_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE</NAME>
#define GDK_X11_SURFACE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SURFACE, GdkX11Surface))
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE_CLASS</NAME>
#define GDK_X11_SURFACE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SURFACE</NAME>
#define GDK_IS_X11_SURFACE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SURFACE_CLASS</NAME>
#define GDK_IS_X11_SURFACE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SURFACE))
</MACRO>
<MACRO>
<NAME>GDK_X11_SURFACE_GET_CLASS</NAME>
#define GDK_X11_SURFACE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SURFACE, GdkX11SurfaceClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11Surface</NAME>
typedef GdkSurface GdkX11Surface;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_surface_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_xid</NAME>
<RETURNS>Window</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_user_time</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, guint32      timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_utf8_property</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, const char *name, const char *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_theme_variant</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, const char  *variant
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_move_to_current_desktop</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_desktop</NAME>
<RETURNS>guint32</RETURNS>
GdkSurface   *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_move_to_desktop</NAME>
<RETURNS>void</RETURNS>
GdkSurface   *surface, guint32      desktop
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_frame_sync_enabled</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean   frame_sync_enabled
</FUNCTION>
<MACRO>
<NAME>GDK_SURFACE_XDISPLAY</NAME>
#define GDK_SURFACE_XDISPLAY(win)      (GDK_DISPLAY_XDISPLAY (gdk_surface_get_display (win)))
</MACRO>
<MACRO>
<NAME>GDK_SURFACE_XID</NAME>
#define GDK_SURFACE_XID(win)           (gdk_x11_surface_get_xid (win))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_get_server_time</NAME>
<RETURNS>guint32</RETURNS>
GdkSurface       *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_lookup_for_display</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkDisplay *display, Window      window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_skip_taskbar_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    skips_taskbar
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_skip_pager_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    skips_pager
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_urgency_hint</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, gboolean    urgent
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_set_group</NAME>
<RETURNS>void</RETURNS>
GdkSurface *surface, GdkSurface *leader
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_surface_get_group</NAME>
<RETURNS>GdkSurface *</RETURNS>
GdkSurface *surface
</FUNCTION>
<STRUCT>
<NAME>GdkX11Surface</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11SurfaceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_XID_TO_POINTER</NAME>
#define GDK_XID_TO_POINTER(xid) GUINT_TO_POINTER(xid)
</MACRO>
<MACRO>
<NAME>GDK_POINTER_TO_XID</NAME>
#define GDK_POINTER_TO_XID(pointer) GPOINTER_TO_UINT(pointer)
</MACRO>
<MACRO>
<NAME>GDK_WINDOWING_X11</NAME>
#define GDK_WINDOWING_X11
</MACRO>
<MACRO>
<NAME>GDK_WINDOWING_WAYLAND</NAME>
#define GDK_WINDOWING_WAYLAND
</MACRO>
<MACRO>
<NAME>GDK_RENDERING_VULKAN</NAME>
#define GDK_RENDERING_VULKAN
</MACRO>
<MACRO>
<NAME>GDK_TYPE_INPUT_SOURCE</NAME>
#define GDK_TYPE_INPUT_SOURCE (gdk_input_source_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD_FEATURE</NAME>
#define GDK_TYPE_DEVICE_PAD_FEATURE (gdk_device_pad_feature_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL_TYPE</NAME>
#define GDK_TYPE_DEVICE_TOOL_TYPE (gdk_device_tool_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_CANCEL_REASON</NAME>
#define GDK_TYPE_DRAG_CANCEL_REASON (gdk_drag_cancel_reason_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_TYPE</NAME>
#define GDK_TYPE_EVENT_TYPE (gdk_event_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCHPAD_GESTURE_PHASE</NAME>
#define GDK_TYPE_TOUCHPAD_GESTURE_PHASE (gdk_touchpad_gesture_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SCROLL_DIRECTION</NAME>
#define GDK_TYPE_SCROLL_DIRECTION (gdk_scroll_direction_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_NOTIFY_TYPE</NAME>
#define GDK_TYPE_NOTIFY_TYPE (gdk_notify_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CROSSING_MODE</NAME>
#define GDK_TYPE_CROSSING_MODE (gdk_crossing_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_KEY_MATCH</NAME>
#define GDK_TYPE_KEY_MATCH (gdk_key_match_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK_PHASE</NAME>
#define GDK_TYPE_FRAME_CLOCK_PHASE (gdk_frame_clock_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MEMORY_FORMAT</NAME>
#define GDK_TYPE_MEMORY_FORMAT (gdk_memory_format_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SUBPIXEL_LAYOUT</NAME>
#define GDK_TYPE_SUBPIXEL_LAYOUT (gdk_subpixel_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_PAINTABLE_FLAGS</NAME>
#define GDK_TYPE_PAINTABLE_FLAGS (gdk_paintable_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_ANCHOR_HINTS</NAME>
#define GDK_TYPE_ANCHOR_HINTS (gdk_anchor_hints_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SEAT_CAPABILITIES</NAME>
#define GDK_TYPE_SEAT_CAPABILITIES (gdk_seat_capabilities_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SURFACE_EDGE</NAME>
#define GDK_TYPE_SURFACE_EDGE (gdk_surface_edge_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FULLSCREEN_MODE</NAME>
#define GDK_TYPE_FULLSCREEN_MODE (gdk_fullscreen_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOPLEVEL_STATE</NAME>
#define GDK_TYPE_TOPLEVEL_STATE (gdk_toplevel_state_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAVITY</NAME>
#define GDK_TYPE_GRAVITY (gdk_gravity_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MODIFIER_TYPE</NAME>
#define GDK_TYPE_MODIFIER_TYPE (gdk_modifier_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GL_ERROR</NAME>
#define GDK_TYPE_GL_ERROR (gdk_gl_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_VULKAN_ERROR</NAME>
#define GDK_TYPE_VULKAN_ERROR (gdk_vulkan_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_USE</NAME>
#define GDK_TYPE_AXIS_USE (gdk_axis_use_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_FLAGS</NAME>
#define GDK_TYPE_AXIS_FLAGS (gdk_axis_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_ACTION</NAME>
#define GDK_TYPE_DRAG_ACTION (gdk_drag_action_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MAJOR_VERSION</NAME>
#define GDK_MAJOR_VERSION (4)
</MACRO>
<MACRO>
<NAME>GDK_MINOR_VERSION</NAME>
#define GDK_MINOR_VERSION (0)
</MACRO>
<MACRO>
<NAME>GDK_MICRO_VERSION</NAME>
#define GDK_MICRO_VERSION (0)
</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_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>
