<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_set_desktop</NAME>
<RETURNS>void                  </RETURNS>
GdkAppLaunchContext *context, gint                 desktop
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_timestamp</NAME>
<RETURNS>void                  </RETURNS>
GdkAppLaunchContext *context, guint32              timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_icon</NAME>
<RETURNS>void                  </RETURNS>
GdkAppLaunchContext *context, GIcon               *icon
</FUNCTION>
<FUNCTION>
<NAME>gdk_app_launch_context_set_icon_name</NAME>
<RETURNS>void                  </RETURNS>
GdkAppLaunchContext *context, const char          *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_get_clip_rectangle</NAME>
<RETURNS>gboolean    </RETURNS>
cairo_t            *cr, GdkRectangle       *rect
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_set_source_rgba</NAME>
<RETURNS>void        </RETURNS>
cairo_t              *cr, const GdkRGBA        *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_set_source_pixbuf</NAME>
<RETURNS>void        </RETURNS>
cairo_t              *cr, const GdkPixbuf      *pixbuf, gdouble               pixbuf_x, gdouble               pixbuf_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_rectangle</NAME>
<RETURNS>void        </RETURNS>
cairo_t              *cr, const GdkRectangle   *rectangle
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_region</NAME>
<RETURNS>void        </RETURNS>
cairo_t              *cr, const cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_region_create_from_surface</NAME>
<RETURNS>cairo_region_t *</RETURNS>
cairo_surface_t      *surface
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_surface_create_from_pixbuf</NAME>
<RETURNS>cairo_surface_t  * </RETURNS>
const GdkPixbuf *pixbuf, int scale, GdkWindow *for_window
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_draw_from_gl</NAME>
<RETURNS>void        </RETURNS>
cairo_t              *cr, GdkWindow            *window, int                   source, int                   source_type, int                   buffer_scale, int                   x, int                   y, int                   width, int                   height
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_get_drawing_context</NAME>
<RETURNS>GdkDrawingContext  *     </RETURNS>
cairo_t *cr
</FUNCTION>
<FUNCTION>
<NAME>gdk_cairo_surface_upload_to_gl</NAME>
<RETURNS>void       </RETURNS>
cairo_surface_t *surface, int              target, int              width, int              height, GdkGLContext    *context
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_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, const char           **out_mime_type, GAsyncResult          *result, 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>
GdkContentFormats              *formats, gsize                          *n_gtypes
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_get_mime_types</NAME>
<RETURNS>const char  * const *</RETURNS>
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>
<FUNCTION>
<NAME>gdk_content_formats_builder_new</NAME>
<RETURNS>GdkContentFormatsBuilder *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_free</NAME>
<RETURNS>GdkContentFormats  *     </RETURNS>
GdkContentFormatsBuilder       *builder
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_add_formats</NAME>
<RETURNS>void                     </RETURNS>
GdkContentFormatsBuilder       *builder, const GdkContentFormats        *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_add_mime_type</NAME>
<RETURNS>void                     </RETURNS>
GdkContentFormatsBuilder      *builder, const char                     *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_builder_add_gtype</NAME>
<RETURNS>void                     </RETURNS>
GdkContentFormatsBuilder       *builder, GType                           type
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_FILE_LIST</NAME>
#define GDK_TYPE_FILE_LIST (gdk_file_list_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_file_list_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkContentFormatsBuilder</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CONTENT_PROVIDER</NAME>
#define GDK_TYPE_CONTENT_PROVIDER            (gdk_content_provider_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_PROVIDER</NAME>
#define GDK_CONTENT_PROVIDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_CONTENT_PROVIDER, GdkContentProvider))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_PROVIDER</NAME>
#define GDK_IS_CONTENT_PROVIDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_CONTENT_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_PROVIDER_CLASS</NAME>
#define GDK_CONTENT_PROVIDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_CONTENT_PROVIDER, GdkContentProviderClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_PROVIDER_CLASS</NAME>
#define GDK_IS_CONTENT_PROVIDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_CONTENT_PROVIDER))
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_PROVIDER_GET_CLASS</NAME>
#define GDK_CONTENT_PROVIDER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_CONTENT_PROVIDER, GdkContentProviderClass))
</MACRO>
<STRUCT>
<NAME>GdkContentProvider</NAME>
struct _GdkContentProvider
{
  GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>GdkContentProviderClass</NAME>
struct _GdkContentProviderClass
{
  GObjectClass parent_class;

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

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

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

  /*< private >*/
  /* Padding for future expansion */
  void (*_gdk_reserved1) (void);
  void (*_gdk_reserved2) (void);
  void (*_gdk_reserved3) (void);
  void (*_gdk_reserved4) (void);
  void (*_gdk_reserved5) (void);
  void (*_gdk_reserved6) (void);
  void (*_gdk_reserved7) (void);
  void (*_gdk_reserved8) (void);
};
</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_for_bytes</NAME>
<RETURNS>GdkContentProvider  *    </RETURNS>
const char             *mime_type, GBytes                 *bytes
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_CONTENT_SERIALIZER</NAME>
#define GDK_TYPE_CONTENT_SERIALIZER         (gdk_content_serializer_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CONTENT_SERIALIZER</NAME>
#define GDK_CONTENT_SERIALIZER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_CONTENT_SERIALIZER, GdkContentSerializer))
</MACRO>
<MACRO>
<NAME>GDK_IS_CONTENT_SERIALIZER</NAME>
#define GDK_IS_CONTENT_SERIALIZER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_CONTENT_SERIALIZER))
</MACRO>
<USER_FUNCTION>
<NAME>GdkContentSerializeFunc</NAME>
<RETURNS>void </RETURNS>
GdkContentSerializer *serializer
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_mime_type</NAME>
<RETURNS>const char  *            </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_gtype</NAME>
<RETURNS>GType                    </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_value</NAME>
<RETURNS>const GValue  *          </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_output_stream</NAME>
<RETURNS>GOutputStream  *         </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_priority</NAME>
<RETURNS>int                      </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_cancellable</NAME>
<RETURNS>GCancellable  *          </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_user_data</NAME>
<RETURNS>gpointer                 </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_set_task_data</NAME>
<RETURNS>void                     </RETURNS>
GdkContentSerializer   *serializer, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_get_task_data</NAME>
<RETURNS>gpointer                 </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_success</NAME>
<RETURNS>void                     </RETURNS>
GdkContentSerializer   *serializer
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serializer_return_error</NAME>
<RETURNS>void                     </RETURNS>
GdkContentSerializer   *serializer, GError                 *error
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_gtypes</NAME>
<RETURNS>GdkContentFormats  *     </RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_formats_union_serialize_mime_types</NAME>
<RETURNS>GdkContentFormats  *     </RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_register_serializer</NAME>
<RETURNS>void                     </RETURNS>
GType                   type, const char             *mime_type, GdkContentSerializeFunc serialize, gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_async</NAME>
<RETURNS>void                     </RETURNS>
GOutputStream          *stream, const char             *mime_type, const GValue           *value, int                     io_priority, GCancellable           *cancellable, GAsyncReadyCallback     callback, gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_content_serialize_finish</NAME>
<RETURNS>gboolean                 </RETURNS>
GAsyncResult           *result, GError                **error
</FUNCTION>
<STRUCT>
<NAME>GdkContentSerializer</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_CURSOR</NAME>
#define GDK_TYPE_CURSOR              (gdk_cursor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_CURSOR</NAME>
#define GDK_CURSOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_CURSOR, GdkCursor))
</MACRO>
<MACRO>
<NAME>GDK_IS_CURSOR</NAME>
#define GDK_IS_CURSOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_CURSOR))
</MACRO>
<FUNCTION>
<NAME>gdk_cursor_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_texture</NAME>
<RETURNS>GdkCursor * </RETURNS>
GdkTexture      *texture, int              hotspot_x, int              hotspot_y, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_new_from_name</NAME>
<RETURNS>GdkCursor *  </RETURNS>
const gchar     *name, GdkCursor       *fallback
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_fallback</NAME>
<RETURNS>GdkCursor  * </RETURNS>
GdkCursor	  *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_name</NAME>
<RETURNS>const char  *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_texture</NAME>
<RETURNS>GdkTexture  *</RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_x</NAME>
<RETURNS>int          </RETURNS>
GdkCursor       *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_cursor_get_hotspot_y</NAME>
<RETURNS>int          </RETURNS>
GdkCursor       *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE</NAME>
#define GDK_TYPE_DEVICE         (gdk_device_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE</NAME>
#define GDK_DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE, GdkDevice))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE</NAME>
#define GDK_IS_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE))
</MACRO>
<ENUM>
<NAME>GdkInputSource</NAME>
typedef enum
{
  GDK_SOURCE_MOUSE,
  GDK_SOURCE_PEN,
  GDK_SOURCE_ERASER,
  GDK_SOURCE_CURSOR,
  GDK_SOURCE_KEYBOARD,
  GDK_SOURCE_TOUCHSCREEN,
  GDK_SOURCE_TOUCHPAD,
  GDK_SOURCE_TRACKPOINT,
  GDK_SOURCE_TABLET_PAD
} GdkInputSource;
</ENUM>
<ENUM>
<NAME>GdkInputMode</NAME>
typedef enum
{
  GDK_MODE_DISABLED,
  GDK_MODE_SCREEN,
  GDK_MODE_WINDOW
} GdkInputMode;
</ENUM>
<ENUM>
<NAME>GdkDeviceType</NAME>
typedef enum {
  GDK_DEVICE_TYPE_MASTER,
  GDK_DEVICE_TYPE_SLAVE,
  GDK_DEVICE_TYPE_FLOATING
} GdkDeviceType;
</ENUM>
<MACRO>
<NAME>GDK_MAX_TIMECOORD_AXES</NAME>
#define GDK_MAX_TIMECOORD_AXES 128
</MACRO>
<STRUCT>
<NAME>GdkTimeCoord</NAME>
struct _GdkTimeCoord
{
  guint32 time;
  gdouble axes[GDK_MAX_TIMECOORD_AXES];
};
</STRUCT>
<FUNCTION>
<NAME>gdk_device_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_name</NAME>
<RETURNS>const gchar  *         </RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_has_cursor</NAME>
<RETURNS>gboolean               </RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_source</NAME>
<RETURNS>GdkInputSource  </RETURNS>
GdkDevice      *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_mode</NAME>
<RETURNS>GdkInputMode    </RETURNS>
GdkDevice      *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_set_mode</NAME>
<RETURNS>gboolean        </RETURNS>
GdkDevice      *device, GdkInputMode    mode
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_n_keys</NAME>
<RETURNS>gint            </RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_key</NAME>
<RETURNS>gboolean        </RETURNS>
GdkDevice       *device, guint            index_, guint           *keyval, GdkModifierType *modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_set_key</NAME>
<RETURNS>void            </RETURNS>
GdkDevice      *device, guint           index_, guint           keyval, GdkModifierType modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_use</NAME>
<RETURNS>GdkAxisUse      </RETURNS>
GdkDevice         *device, guint              index_
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_set_axis_use</NAME>
<RETURNS>void            </RETURNS>
GdkDevice         *device, guint              index_, GdkAxisUse         use
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_state</NAME>
<RETURNS>void      </RETURNS>
GdkDevice         *device, GdkWindow         *window, gdouble           *axes, GdkModifierType   *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_position</NAME>
<RETURNS>void      </RETURNS>
GdkDevice         *device, gint              *x, gint              *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_window_at_position</NAME>
<RETURNS>GdkWindow *</RETURNS>
GdkDevice         *device, gint              *win_x, gint              *win_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_position_double</NAME>
<RETURNS>void      </RETURNS>
GdkDevice         *device, gdouble           *x, gdouble           *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_window_at_position_double</NAME>
<RETURNS>GdkWindow *</RETURNS>
GdkDevice         *device, gdouble           *win_x, gdouble           *win_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_history</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDevice         *device, GdkWindow         *window, guint32            start, guint32            stop, GdkTimeCoord    ***events, gint              *n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_free_history</NAME>
<RETURNS>void      </RETURNS>
GdkTimeCoord     **events, gint               n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_n_axes</NAME>
<RETURNS>gint      </RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_list_axes</NAME>
<RETURNS>GList  *  </RETURNS>
GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis_value</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDevice       *device, gdouble         *axes, GdkAtom          axis_label, gdouble         *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axis</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDevice         *device, gdouble           *axes, GdkAxisUse         use, gdouble           *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_display</NAME>
<RETURNS>GdkDisplay  * </RETURNS>
GdkDevice      *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_associated_device</NAME>
<RETURNS>GdkDevice   * </RETURNS>
GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_list_slave_devices</NAME>
<RETURNS>GList  *      </RETURNS>
GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_device_type</NAME>
<RETURNS>GdkDeviceType  </RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_grab</NAME>
<DEPRECATED/>
<RETURNS>GdkGrabStatus  </RETURNS>
GdkDevice        *device, GdkWindow        *window, GdkGrabOwnership  grab_ownership, gboolean          owner_events, GdkEventMask      event_mask, GdkCursor        *cursor, guint32           time_
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_ungrab</NAME>
<DEPRECATED/>
<RETURNS>void           </RETURNS>
GdkDevice        *device, guint32           time_
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_warp</NAME>
<RETURNS>void           </RETURNS>
GdkDevice        *device, gint              x, gint              y
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_last_event_window</NAME>
<RETURNS>GdkWindow  *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_vendor_id</NAME>
<RETURNS>const gchar  *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_product_id</NAME>
<RETURNS>const gchar  *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_seat</NAME>
<RETURNS>GdkSeat      *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_get_axes</NAME>
<RETURNS>GdkAxisFlags  </RETURNS>
GdkDevice *device
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD</NAME>
#define GDK_TYPE_DEVICE_PAD         (gdk_device_pad_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_PAD</NAME>
#define GDK_DEVICE_PAD(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_PAD, GdkDevicePad))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_PAD</NAME>
#define GDK_IS_DEVICE_PAD(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_PAD))
</MACRO>
<ENUM>
<NAME>GdkDevicePadFeature</NAME>
typedef enum {
  GDK_DEVICE_PAD_FEATURE_BUTTON,
  GDK_DEVICE_PAD_FEATURE_RING,
  GDK_DEVICE_PAD_FEATURE_STRIP
} GdkDevicePadFeature;
</ENUM>
<FUNCTION>
<NAME>gdk_device_pad_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_groups</NAME>
<RETURNS>gint   </RETURNS>
GdkDevicePad *pad
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_group_n_modes</NAME>
<RETURNS>gint   </RETURNS>
GdkDevicePad *pad, gint          group_idx
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_n_features</NAME>
<RETURNS>gint   </RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_pad_get_feature_group</NAME>
<RETURNS>gint   </RETURNS>
GdkDevicePad        *pad, GdkDevicePadFeature  feature, gint                 feature_idx
</FUNCTION>
<STRUCT>
<NAME>GdkDevicePad</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDevicePadInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_DEVICE_PAD_GET_IFACE</NAME>
#define GDK_DEVICE_PAD_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GDK_TYPE_DEVICE_PAD, GdkDevicePadInterface))
</MACRO>
<STRUCT>
<NAME>GdkDevicePadInterface</NAME>
struct _GdkDevicePadInterface {
  GTypeInterface parent_interface;

  gint (* get_n_groups)      (GdkDevicePad        *pad);

  gint (* get_group_n_modes) (GdkDevicePad        *pad,
                              gint                 group);
  gint (* get_n_features)    (GdkDevicePad        *pad,
                              GdkDevicePadFeature  feature);
  gint (* get_feature_group) (GdkDevicePad        *pad,
                              GdkDevicePadFeature  feature,
                              gint                 idx);
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL</NAME>
#define GDK_TYPE_DEVICE_TOOL    (gdk_device_tool_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DEVICE_TOOL</NAME>
#define GDK_DEVICE_TOOL(o)      (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_DEVICE_TOOL, GdkDeviceTool))
</MACRO>
<MACRO>
<NAME>GDK_IS_DEVICE_TOOL</NAME>
#define GDK_IS_DEVICE_TOOL(o)   (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_DEVICE_TOOL))
</MACRO>
<ENUM>
<NAME>GdkDeviceToolType</NAME>
typedef enum {
  GDK_DEVICE_TOOL_TYPE_UNKNOWN,
  GDK_DEVICE_TOOL_TYPE_PEN,
  GDK_DEVICE_TOOL_TYPE_ERASER,
  GDK_DEVICE_TOOL_TYPE_BRUSH,
  GDK_DEVICE_TOOL_TYPE_PENCIL,
  GDK_DEVICE_TOOL_TYPE_AIRBRUSH,
  GDK_DEVICE_TOOL_TYPE_MOUSE,
  GDK_DEVICE_TOOL_TYPE_LENS,
} GdkDeviceToolType;
</ENUM>
<FUNCTION>
<NAME>gdk_device_tool_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_serial</NAME>
<RETURNS>guint64  </RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_hardware_id</NAME>
<RETURNS>guint64  </RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_device_tool_get_tool_type</NAME>
<RETURNS>GdkDeviceToolType  </RETURNS>
GdkDeviceTool *tool
</FUNCTION>
<STRUCT>
<NAME>GdkDeviceTool</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDeviceTool</NAME>
struct _GdkDeviceTool
{
  GObject parent_instance;
  guint64 serial;
  guint64 hw_id;
  GdkDeviceToolType type;
  GdkAxisFlags tool_axes;
};
</STRUCT>
<STRUCT>
<NAME>GdkDeviceToolClass</NAME>
struct _GdkDeviceToolClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_device_tool_new</NAME>
<RETURNS>GdkDeviceTool  *</RETURNS>
guint64            serial, guint64            hw_id, GdkDeviceToolType  type, GdkAxisFlags       tool_axes
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DISPLAY</NAME>
#define GDK_TYPE_DISPLAY              (gdk_display_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY</NAME>
#define GDK_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY, GdkDisplay))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY</NAME>
#define GDK_IS_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY))
</MACRO>
<FUNCTION>
<NAME>gdk_display_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_open</NAME>
<RETURNS>GdkDisplay  *</RETURNS>
const gchar *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_name</NAME>
<RETURNS>const gchar  * </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_device_is_grabbed</NAME>
<RETURNS>gboolean     </RETURNS>
GdkDisplay  *display, GdkDevice   *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_beep</NAME>
<RETURNS>void         </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_sync</NAME>
<RETURNS>void         </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_flush</NAME>
<RETURNS>void         </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_close</NAME>
<RETURNS>void         </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_closed</NAME>
<RETURNS>gboolean     </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_composited</NAME>
<RETURNS>gboolean     </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_is_rgba</NAME>
<RETURNS>gboolean     </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_event</NAME>
<RETURNS>GdkEvent * </RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_peek_event</NAME>
<RETURNS>GdkEvent * </RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_put_event</NAME>
<RETURNS>void       </RETURNS>
GdkDisplay     *display, const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_has_pending</NAME>
<RETURNS>gboolean   </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default</NAME>
<RETURNS>GdkDisplay  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_cursor_alpha</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_cursor_color</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_cursor_size</NAME>
<RETURNS>guint     </RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_maximal_cursor_size</NAME>
<RETURNS>void      </RETURNS>
GdkDisplay    *display, guint         *width, guint         *height
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_group</NAME>
<RETURNS>GdkWindow  *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_clipboard</NAME>
<RETURNS>GdkClipboard  *          </RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_primary_clipboard</NAME>
<RETURNS>GdkClipboard  *          </RETURNS>
GdkDisplay     *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_shapes</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_supports_input_shapes</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_notify_startup_complete</NAME>
<RETURNS>void      </RETURNS>
GdkDisplay    *display, const gchar   *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_app_launch_context</NAME>
<RETURNS>GdkAppLaunchContext  *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_default_seat</NAME>
<RETURNS>GdkSeat  * </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_list_seats</NAME>
<RETURNS>GList    * </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_n_monitors</NAME>
<RETURNS>int           </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor</NAME>
<RETURNS>GdkMonitor  * </RETURNS>
GdkDisplay *display, int         monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_primary_monitor</NAME>
<RETURNS>GdkMonitor  * </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor_at_point</NAME>
<RETURNS>GdkMonitor  * </RETURNS>
GdkDisplay *display, int         x, int         y
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_monitor_at_window</NAME>
<RETURNS>GdkMonitor  * </RETURNS>
GdkDisplay *display, GdkWindow  *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_keymap</NAME>
<RETURNS>GdkKeymap  *  </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_get_setting</NAME>
<RETURNS>gboolean      </RETURNS>
GdkDisplay *display, const char *name, GValue     *value
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DISPLAY_MANAGER</NAME>
#define GDK_TYPE_DISPLAY_MANAGER              (gdk_display_manager_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_MANAGER</NAME>
#define GDK_DISPLAY_MANAGER(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DISPLAY_MANAGER, GdkDisplayManager))
</MACRO>
<MACRO>
<NAME>GDK_IS_DISPLAY_MANAGER</NAME>
#define GDK_IS_DISPLAY_MANAGER(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DISPLAY_MANAGER))
</MACRO>
<FUNCTION>
<NAME>gdk_display_manager_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get</NAME>
<RETURNS>GdkDisplayManager  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_get_default_display</NAME>
<RETURNS>GdkDisplay  *       </RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_set_default_display</NAME>
<RETURNS>void                </RETURNS>
GdkDisplayManager *manager, GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_list_displays</NAME>
<RETURNS>GSList  *           </RETURNS>
GdkDisplayManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gdk_display_manager_open_display</NAME>
<RETURNS>GdkDisplay  *       </RETURNS>
GdkDisplayManager *manager, const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gdk_set_allowed_backends</NAME>
<RETURNS>void                </RETURNS>
const gchar       *backends
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAG_CONTEXT</NAME>
#define GDK_TYPE_DRAG_CONTEXT              (gdk_drag_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAG_CONTEXT</NAME>
#define GDK_DRAG_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG_CONTEXT, GdkDragContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAG_CONTEXT</NAME>
#define GDK_IS_DRAG_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG_CONTEXT))
</MACRO>
<ENUM>
<NAME>GdkDragAction</NAME>
typedef enum
{
  GDK_ACTION_DEFAULT = 1 << 0,
  GDK_ACTION_COPY    = 1 << 1,
  GDK_ACTION_MOVE    = 1 << 2,
  GDK_ACTION_LINK    = 1 << 3,
  GDK_ACTION_PRIVATE = 1 << 4,
  GDK_ACTION_ASK     = 1 << 5
} GdkDragAction;
</ENUM>
<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_context_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_display</NAME>
<RETURNS>GdkDisplay  *     </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_device</NAME>
<RETURNS>GdkDevice  *      </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_formats</NAME>
<RETURNS>GdkContentFormats  *</RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_actions</NAME>
<RETURNS>GdkDragAction     </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_suggested_action</NAME>
<RETURNS>GdkDragAction     </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_selected_action</NAME>
<RETURNS>GdkDragAction     </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_source_window</NAME>
<RETURNS>GdkWindow        *</RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_dest_window</NAME>
<RETURNS>GdkWindow        *</RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_status</NAME>
<RETURNS>void              </RETURNS>
GdkDragContext   *context, GdkDragAction     action, guint32           time_
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_reply</NAME>
<RETURNS>void              </RETURNS>
GdkDragContext   *context, gboolean          accepted, guint32           time_
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_finish</NAME>
<RETURNS>void              </RETURNS>
GdkDragContext   *context, gboolean          success, guint32           time_
</FUNCTION>
<FUNCTION>
<NAME>gdk_drop_read_async</NAME>
<RETURNS>void                     </RETURNS>
GdkDragContext        *context, 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>
GdkDragContext        *context, const char           **out_mime_type, GAsyncResult          *result, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_begin</NAME>
<RETURNS>GdkDragContext  *        </RETURNS>
GdkWindow              *window, GdkDevice              *device, GdkContentProvider     *content, GdkDragAction           actions, gint                    dx, gint                    dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_drop_succeeded</NAME>
<RETURNS>gboolean         </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_drop_done</NAME>
<RETURNS>void             </RETURNS>
GdkDragContext *context, gboolean        success
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_get_drag_window</NAME>
<RETURNS>GdkWindow       *</RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drag_context_set_hotspot</NAME>
<RETURNS>void             </RETURNS>
GdkDragContext *context, gint            hot_x, gint            hot_y
</FUNCTION>
<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_window</NAME>
<RETURNS>GdkWindow  *             </RETURNS>
GdkDrawContext  *context
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_DRAWING_CONTEXT</NAME>
#define GDK_TYPE_DRAWING_CONTEXT (gdk_drawing_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_DRAWING_CONTEXT</NAME>
#define GDK_DRAWING_CONTEXT(obj)        (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_DRAWING_CONTEXT, GdkDrawingContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAWING_CONTEXT</NAME>
#define GDK_IS_DRAWING_CONTEXT(obj)     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_DRAWING_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_drawing_context_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_drawing_context_get_window</NAME>
<RETURNS>GdkWindow  *     </RETURNS>
GdkDrawingContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drawing_context_get_paint_context</NAME>
<RETURNS>GdkDrawContext * </RETURNS>
GdkDrawingContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drawing_context_get_clip</NAME>
<RETURNS>cairo_region_t  *</RETURNS>
GdkDrawingContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drawing_context_is_valid</NAME>
<RETURNS>gboolean         </RETURNS>
GdkDrawingContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_drawing_context_get_cairo_context</NAME>
<RETURNS>cairo_t  *       </RETURNS>
GdkDrawingContext *context
</FUNCTION>
<STRUCT>
<NAME>GdkDrawingContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_DRAWING_CONTEXT_CLASS</NAME>
#define GDK_DRAWING_CONTEXT_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAWING_CONTEXT, GdkDrawingContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_DRAWING_CONTEXT_CLASS</NAME>
#define GDK_IS_DRAWING_CONTEXT_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAWING_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_DRAWING_CONTEXT_GET_CLASS</NAME>
#define GDK_DRAWING_CONTEXT_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAWING_CONTEXT, GdkDrawingContextClass))
</MACRO>
<STRUCT>
<NAME>GdkDrawingContext</NAME>
struct _GdkDrawingContext
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GdkDrawingContextClass</NAME>
struct _GdkDrawingContextClass
{
  GObjectClass parent_instance;
};
</STRUCT>
<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_EVENT</NAME>
#define GDK_EVENT(object)       (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_EVENT, GdkEvent))
</MACRO>
<MACRO>
<NAME>GDK_IS_EVENT</NAME>
#define GDK_IS_EVENT(object)    (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_EVENT))
</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>
<USER_FUNCTION>
<NAME>GdkEventFunc</NAME>
<RETURNS>void </RETURNS>
GdkEvent *event,
			      gpointer	data
</USER_FUNCTION>
<TYPEDEF>
<NAME>GdkXEvent</NAME>
typedef void GdkXEvent;	  /* Can be cast to window system specific
</TYPEDEF>
<ENUM>
<NAME>GdkFilterReturn</NAME>
typedef enum {
  GDK_FILTER_CONTINUE,	  /* Event not handled, continue processesing */
  GDK_FILTER_TRANSLATE,	  /* Native event translated into a GDK event and
                             stored in the "event" structure that was
                             passed in */
  GDK_FILTER_REMOVE	  /* Terminate processing, removing event */
} GdkFilterReturn;
</ENUM>
<USER_FUNCTION>
<NAME>GdkFilterFunc</NAME>
<RETURNS>GdkFilterReturn </RETURNS>
GdkXEvent *xevent,
					  GdkEvent *event,
					  gpointer  data
</USER_FUNCTION>
<ENUM>
<NAME>GdkEventType</NAME>
typedef enum
{
  GDK_NOTHING,
  GDK_DELETE,
  GDK_DESTROY,
  GDK_EXPOSE,
  GDK_MOTION_NOTIFY,
  GDK_BUTTON_PRESS,
  GDK_BUTTON_RELEASE,
  GDK_KEY_PRESS,
  GDK_KEY_RELEASE,
  GDK_ENTER_NOTIFY,
  GDK_LEAVE_NOTIFY,
  GDK_FOCUS_CHANGE,
  GDK_CONFIGURE,
  GDK_MAP,
  GDK_UNMAP,
  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_new</NAME>
<RETURNS>GdkEvent * </RETURNS>
GdkEventType    type
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_copy</NAME>
<RETURNS>GdkEvent * </RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_free</NAME>
<RETURNS>void 	  </RETURNS>
GdkEvent 	*event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_window</NAME>
<RETURNS>GdkWindow  *</RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_time</NAME>
<RETURNS>guint32    </RETURNS>
const GdkEvent  *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_state</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent  *event, GdkModifierType *state
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_coords</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent  *event, gdouble	 *x_win, gdouble	 *y_win
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_set_coords</NAME>
<RETURNS>void       </RETURNS>
GdkEvent *event, gdouble   x, gdouble   y
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_root_coords</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, gdouble	*x_root, gdouble	*y_root
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_button</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, guint          *button
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_click_count</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, guint          *click_count
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_keyval</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, guint          *keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_set_keyval</NAME>
<RETURNS>void       </RETURNS>
GdkEvent *event, guint     keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_keycode</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, guint16        *keycode
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_key_is_modifier</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, gboolean       *is_modifier
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_key_group</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, guint          *group
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_string</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent  *event, const char     **string
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_scroll_direction</NAME>
<RETURNS>gboolean  </RETURNS>
const GdkEvent *event, GdkScrollDirection *direction
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_scroll_deltas</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event, gdouble         *delta_x, gdouble         *delta_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_is_scroll_stop_event</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axis</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkEvent  *event, GdkAxisUse       axis_use, gdouble         *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_set_device</NAME>
<RETURNS>void        </RETURNS>
GdkEvent        *event, GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device</NAME>
<RETURNS>GdkDevice * </RETURNS>
const GdkEvent  *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_set_source_device</NAME>
<RETURNS>void        </RETURNS>
GdkEvent        *event, GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_source_device</NAME>
<RETURNS>GdkDevice * </RETURNS>
const GdkEvent  *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_triggers_context_menu</NAME>
<RETURNS>gboolean    </RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_distance</NAME>
<RETURNS>gboolean   </RETURNS>
GdkEvent        *event1, GdkEvent        *event2, gdouble         *distance
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_angle</NAME>
<RETURNS>gboolean   </RETURNS>
GdkEvent        *event1, GdkEvent        *event2, gdouble         *angle
</FUNCTION>
<FUNCTION>
<NAME>gdk_events_get_center</NAME>
<RETURNS>gboolean   </RETURNS>
GdkEvent        *event1, GdkEvent        *event2, gdouble         *x, gdouble         *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_handler_set</NAME>
<RETURNS>void 	  </RETURNS>
GdkEventFunc    func, gpointer        data, GDestroyNotify  notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_set_display</NAME>
<RETURNS>void        </RETURNS>
GdkEvent        *event, GdkDisplay      *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_display</NAME>
<RETURNS>GdkDisplay  *</RETURNS>
const GdkEvent  *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_sequence</NAME>
<RETURNS>GdkEventSequence  *</RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_event_type</NAME>
<RETURNS>GdkEventType  </RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_seat</NAME>
<RETURNS>GdkSeat   *</RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_set_show_events</NAME>
<RETURNS>void 	  </RETURNS>
gboolean	 show_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_get_show_events</NAME>
<RETURNS>gboolean   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_device_tool</NAME>
<RETURNS>GdkDeviceTool  *</RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_set_device_tool</NAME>
<RETURNS>void            </RETURNS>
GdkEvent       *event, GdkDeviceTool  *tool
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_scancode</NAME>
<RETURNS>int             </RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_pointer_emulated</NAME>
<RETURNS>gboolean        </RETURNS>
GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_set_user_data</NAME>
<RETURNS>void            </RETURNS>
GdkEvent *event, GObject  *user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_is_sent</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_drag_context</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent  *event, GdkDragContext **context
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_crossing_mode</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent  *event, GdkCrossingMode *mode
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_crossing_detail</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, GdkNotifyType  *detail
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_touchpad_gesture_phase</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent          *event, GdkTouchpadGesturePhase *phase
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_touchpad_gesture_n_fingers</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, guint          *n_fingers
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_touchpad_deltas</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, double         *dx, double         *dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_touchpad_angle_delta</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, double         *delta
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_touchpad_scale</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, double         *scale
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_touch_emulating_pointer</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, gboolean       *emulating
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_grab_window</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent  *event, GdkWindow      **window
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_focus_in</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, gboolean       *focus_in
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_pad_group_mode</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, guint          *group, guint          *mode
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_pad_button</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, guint          *button
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_pad_axis_value</NAME>
<RETURNS>gboolean        </RETURNS>
const GdkEvent *event, guint          *index, gdouble        *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_axes</NAME>
<RETURNS>gboolean        </RETURNS>
GdkEvent  *event, gdouble  **axes, guint     *n_axes
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_get_history</NAME>
<RETURNS>GList         * </RETURNS>
const GdkEvent  *event
</FUNCTION>
<UNION>
<NAME>GdkEvent</NAME>
</UNION>
<STRUCT>
<NAME>GdkEventAny</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventButton</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventConfigure</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventCrossing</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventDND</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventExpose</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventFocus</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventGrabBroken</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventKey</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventMotion</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventPadAxis</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventPadButton</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventPadGroupMode</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventProximity</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventScroll</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventSequence</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventSetting</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventTouch</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventTouchpadPinch</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkEventTouchpadSwipe</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK</NAME>
#define GDK_TYPE_FRAME_CLOCK            (gdk_frame_clock_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK</NAME>
#define GDK_FRAME_CLOCK(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClock))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_CLASS</NAME>
#define GDK_FRAME_CLOCK_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK</NAME>
#define GDK_IS_FRAME_CLOCK(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK_CLASS</NAME>
#define GDK_IS_FRAME_CLOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_FRAME_CLOCK))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_GET_CLASS</NAME>
#define GDK_FRAME_CLOCK_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_FRAME_CLOCK, GdkFrameClockClass))
</MACRO>
<ENUM>
<NAME>GdkFrameClockPhase</NAME>
typedef enum {
  GDK_FRAME_CLOCK_PHASE_NONE          = 0,
  GDK_FRAME_CLOCK_PHASE_FLUSH_EVENTS  = 1 << 0,
  GDK_FRAME_CLOCK_PHASE_BEFORE_PAINT  = 1 << 1,
  GDK_FRAME_CLOCK_PHASE_UPDATE        = 1 << 2,
  GDK_FRAME_CLOCK_PHASE_LAYOUT        = 1 << 3,
  GDK_FRAME_CLOCK_PHASE_PAINT         = 1 << 4,
  GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS = 1 << 5,
  GDK_FRAME_CLOCK_PHASE_AFTER_PAINT   = 1 << 6
} GdkFrameClockPhase;
</ENUM>
<FUNCTION>
<NAME>gdk_frame_clock_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_time</NAME>
<RETURNS>gint64    </RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_request_phase</NAME>
<RETURNS>void                </RETURNS>
GdkFrameClock      *frame_clock, GdkFrameClockPhase  phase
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_begin_updating</NAME>
<RETURNS>void                </RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_end_updating</NAME>
<RETURNS>void                </RETURNS>
GdkFrameClock      *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_frame_counter</NAME>
<RETURNS>gint64            </RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_history_start</NAME>
<RETURNS>gint64            </RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_timings</NAME>
<RETURNS>GdkFrameTimings  *</RETURNS>
GdkFrameClock *frame_clock, gint64         frame_counter
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_current_timings</NAME>
<RETURNS>GdkFrameTimings  *</RETURNS>
GdkFrameClock *frame_clock
</FUNCTION>
<FUNCTION>
<NAME>gdk_frame_clock_get_refresh_info</NAME>
<RETURNS>void  </RETURNS>
GdkFrameClock *frame_clock, gint64         base_time, gint64        *refresh_interval_return, gint64        *presentation_time_return
</FUNCTION>
<STRUCT>
<NAME>GdkFrameClock</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK_IDLE</NAME>
#define GDK_TYPE_FRAME_CLOCK_IDLE            (gdk_frame_clock_idle_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_IDLE</NAME>
#define GDK_FRAME_CLOCK_IDLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_FRAME_CLOCK_IDLE, GdkFrameClockIdle))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_IDLE_CLASS</NAME>
#define GDK_FRAME_CLOCK_IDLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_FRAME_CLOCK_IDLE, GdkFrameClockIdleClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK_IDLE</NAME>
#define GDK_IS_FRAME_CLOCK_IDLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_FRAME_CLOCK_IDLE))
</MACRO>
<MACRO>
<NAME>GDK_IS_FRAME_CLOCK_IDLE_CLASS</NAME>
#define GDK_IS_FRAME_CLOCK_IDLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_FRAME_CLOCK_IDLE))
</MACRO>
<MACRO>
<NAME>GDK_FRAME_CLOCK_IDLE_GET_CLASS</NAME>
#define GDK_FRAME_CLOCK_IDLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_FRAME_CLOCK_IDLE, GdkFrameClockIdleClass))
</MACRO>
<STRUCT>
<NAME>GdkFrameClockIdle</NAME>
struct _GdkFrameClockIdle
{
  GdkFrameClock parent_instance;

  /*< private >*/
  GdkFrameClockIdlePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GdkFrameClockIdleClass</NAME>
struct _GdkFrameClockIdleClass
{
  GdkFrameClockClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_frame_clock_idle_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkFrameClockIdlePrivate</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_window</NAME>
<RETURNS>GdkWindow  *             </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_get_damage</NAME>
<RETURNS>cairo_region_t  *        </RETURNS>
GdkGLContext  *context
</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>
<STRUCT>
<NAME>GdkKeymapKey</NAME>
struct _GdkKeymapKey
{
  guint keycode;
  gint  group;
  gint  level;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_KEYMAP</NAME>
#define GDK_TYPE_KEYMAP              (gdk_keymap_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_KEYMAP</NAME>
#define GDK_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_KEYMAP, GdkKeymap))
</MACRO>
<MACRO>
<NAME>GDK_IS_KEYMAP</NAME>
#define GDK_IS_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_KEYMAP))
</MACRO>
<FUNCTION>
<NAME>gdk_keymap_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_display</NAME>
<RETURNS>GdkDisplay  *   </RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_lookup_key</NAME>
<RETURNS>guint           </RETURNS>
GdkKeymap           *keymap, const GdkKeymapKey  *key
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_translate_keyboard_state</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap, guint                hardware_keycode, GdkModifierType      state, gint                 group, guint               *keyval, gint                *effective_group, gint                *level, GdkModifierType     *consumed_modifiers
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_entries_for_keyval</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap, guint                keyval, GdkKeymapKey       **keys, gint                *n_keys
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_entries_for_keycode</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap, guint                hardware_keycode, GdkKeymapKey       **keys, guint              **keyvals, gint                *n_entries
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_direction</NAME>
<RETURNS>PangoDirection  </RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_have_bidi_layouts</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_caps_lock_state</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_num_lock_state</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_scroll_lock_state</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_modifier_state</NAME>
<RETURNS>guint           </RETURNS>
GdkKeymap           *keymap
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_add_virtual_modifiers</NAME>
<RETURNS>void            </RETURNS>
GdkKeymap           *keymap, GdkModifierType     *state
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_map_virtual_modifiers</NAME>
<RETURNS>gboolean        </RETURNS>
GdkKeymap           *keymap, GdkModifierType     *state
</FUNCTION>
<FUNCTION>
<NAME>gdk_keymap_get_modifier_mask</NAME>
<RETURNS>GdkModifierType  </RETURNS>
GdkKeymap           *keymap, GdkModifierIntent    intent
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_name</NAME>
<RETURNS>gchar *   </RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_from_name</NAME>
<RETURNS>guint     </RETURNS>
const gchar *keyval_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_convert_case</NAME>
<RETURNS>void      </RETURNS>
guint        symbol, guint       *lower, guint       *upper
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_upper</NAME>
<RETURNS>guint     </RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_lower</NAME>
<RETURNS>guint     </RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_upper</NAME>
<RETURNS>gboolean  </RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_is_lower</NAME>
<RETURNS>gboolean  </RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_keyval_to_unicode</NAME>
<RETURNS>guint32   </RETURNS>
guint        keyval
</FUNCTION>
<FUNCTION>
<NAME>gdk_unicode_to_keyval</NAME>
<RETURNS>guint     </RETURNS>
guint32      wc
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_MONITOR</NAME>
#define GDK_TYPE_MONITOR           (gdk_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MONITOR</NAME>
#define GDK_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_MONITOR, GdkMonitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_MONITOR</NAME>
#define GDK_IS_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_MONITOR))
</MACRO>
<ENUM>
<NAME>GdkSubpixelLayout</NAME>
typedef enum {
  GDK_SUBPIXEL_LAYOUT_UNKNOWN,
  GDK_SUBPIXEL_LAYOUT_NONE,
  GDK_SUBPIXEL_LAYOUT_HORIZONTAL_RGB,
  GDK_SUBPIXEL_LAYOUT_HORIZONTAL_BGR,
  GDK_SUBPIXEL_LAYOUT_VERTICAL_RGB,
  GDK_SUBPIXEL_LAYOUT_VERTICAL_BGR
} GdkSubpixelLayout;
</ENUM>
<FUNCTION>
<NAME>gdk_monitor_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_display</NAME>
<RETURNS>GdkDisplay   *     </RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_geometry</NAME>
<RETURNS>void               </RETURNS>
GdkMonitor   *monitor, GdkRectangle *geometry
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_workarea</NAME>
<RETURNS>void               </RETURNS>
GdkMonitor   *monitor, GdkRectangle *workarea
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_width_mm</NAME>
<RETURNS>int                </RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_height_mm</NAME>
<RETURNS>int                </RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_manufacturer</NAME>
<RETURNS>const char  *      </RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_model</NAME>
<RETURNS>const char  *      </RETURNS>
GdkMonitor   *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_monitor_get_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_primary</NAME>
<RETURNS>gboolean           </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>
<FUNCTION>
<NAME>gdk_pango_layout_line_get_clip_region</NAME>
<RETURNS>cairo_region_t     *</RETURNS>
PangoLayoutLine *line, gint             x_origin, gint             y_origin, const gint      *index_ranges, gint             n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pango_layout_get_clip_region</NAME>
<RETURNS>cairo_region_t     *</RETURNS>
PangoLayout     *layout, gint             x_origin, gint             y_origin, const gint      *index_ranges, gint             n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gdk_pixbuf_get_from_surface</NAME>
<RETURNS>GdkPixbuf  *</RETURNS>
cairo_surface_t *surface, gint             src_x, gint             src_y, gint             width, gint             height
</FUNCTION>
<FUNCTION>
<NAME>gdk_text_property_to_utf8_list_for_display</NAME>
<RETURNS>gint    </RETURNS>
GdkDisplay     *display, GdkAtom         encoding, gint            format, const guchar   *text, gint            length, gchar        ***list
</FUNCTION>
<FUNCTION>
<NAME>gdk_utf8_to_string_target</NAME>
<RETURNS>gchar  *</RETURNS>
const gchar    *str
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_intersect</NAME>
<RETURNS>gboolean  </RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_union</NAME>
<RETURNS>void      </RETURNS>
const GdkRectangle *src1, const GdkRectangle *src2, GdkRectangle       *dest
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_equal</NAME>
<RETURNS>gboolean  </RETURNS>
const GdkRectangle *rect1, const GdkRectangle *rect2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_contains_point</NAME>
<RETURNS>gboolean  </RETURNS>
const GdkRectangle *rect, int                 x, int                 y
</FUNCTION>
<FUNCTION>
<NAME>gdk_rectangle_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_RECTANGLE</NAME>
#define GDK_TYPE_RECTANGLE (gdk_rectangle_get_type ())
</MACRO>
<STRUCT>
<NAME>GdkRGBA</NAME>
struct _GdkRGBA
{
  gdouble red;
  gdouble green;
  gdouble blue;
  gdouble alpha;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_RGBA</NAME>
#define GDK_TYPE_RGBA (gdk_rgba_get_type ())
</MACRO>
<FUNCTION>
<NAME>gdk_rgba_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_copy</NAME>
<RETURNS>GdkRGBA  * </RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_free</NAME>
<RETURNS>void       </RETURNS>
GdkRGBA       *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_clear</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_is_opaque</NAME>
<RETURNS>gboolean   </RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_hash</NAME>
<RETURNS>guint      </RETURNS>
gconstpointer  p
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_equal</NAME>
<RETURNS>gboolean   </RETURNS>
gconstpointer  p1, gconstpointer  p2
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_parse</NAME>
<RETURNS>gboolean   </RETURNS>
GdkRGBA       *rgba, const gchar   *spec
</FUNCTION>
<FUNCTION>
<NAME>gdk_rgba_to_string</NAME>
<RETURNS>gchar  *   </RETURNS>
const GdkRGBA *rgba
</FUNCTION>
<MACRO>
<NAME>GDK_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>
<USER_FUNCTION>
<NAME>GdkSeatGrabPrepareFunc</NAME>
<RETURNS>void </RETURNS>
GdkSeat   *seat,
                                         GdkWindow *window,
                                         gpointer   user_data
</USER_FUNCTION>
<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_grab</NAME>
<RETURNS>GdkGrabStatus   </RETURNS>
GdkSeat                *seat, GdkWindow              *window, GdkSeatCapabilities     capabilities, gboolean                owner_events, GdkCursor              *cursor, const GdkEvent         *event, GdkSeatGrabPrepareFunc  prepare_func, gpointer                prepare_func_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_ungrab</NAME>
<RETURNS>void            </RETURNS>
GdkSeat                *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_display</NAME>
<RETURNS>GdkDisplay  *   </RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_capabilities</NAME>
<RETURNS>GdkSeatCapabilities</RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_slaves</NAME>
<RETURNS>GList  *        </RETURNS>
GdkSeat             *seat, GdkSeatCapabilities  capabilities
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_pointer</NAME>
<RETURNS>GdkDevice  *    </RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_keyboard</NAME>
<RETURNS>GdkDevice  *    </RETURNS>
GdkSeat             *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_seat_get_master_pointers</NAME>
<RETURNS>GList  *        </RETURNS>
GdkSeat             *seat, GdkSeatCapabilities  capabilities
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_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_data</NAME>
<RETURNS>GdkTexture  *            </RETURNS>
const guchar    *data, int              width, int              height, int              stride
</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>
<STRUCT>
<NAME>GdkTextureClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_THREADS_DEPRECATED</NAME>
#define GDK_THREADS_DEPRECATED _GDK_EXTERN
</MACRO>
<FUNCTION>
<NAME>gdk_threads_init</NAME>
<DEPRECATED/>
<RETURNS>void      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_enter</NAME>
<DEPRECATED/>
<RETURNS>void      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_leave</NAME>
<DEPRECATED/>
<RETURNS>void      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_add_idle_full</NAME>
<RETURNS>guint     </RETURNS>
gint           priority, GSourceFunc    function, gpointer       data, GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_add_idle</NAME>
<RETURNS>guint     </RETURNS>
GSourceFunc    function, gpointer       data
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_add_timeout_full</NAME>
<RETURNS>guint     </RETURNS>
gint           priority, guint          interval, GSourceFunc    function, gpointer       data, GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_add_timeout</NAME>
<RETURNS>guint     </RETURNS>
guint          interval, GSourceFunc    function, gpointer       data
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_add_timeout_seconds_full</NAME>
<RETURNS>guint     </RETURNS>
gint           priority, guint          interval, GSourceFunc    function, gpointer       data, GDestroyNotify notify
</FUNCTION>
<FUNCTION>
<NAME>gdk_threads_add_timeout_seconds</NAME>
<RETURNS>guint     </RETURNS>
guint          interval, GSourceFunc    function, gpointer       data
</FUNCTION>
<MACRO>
<NAME>GDK_THREADS_ENTER</NAME>
#define GDK_THREADS_ENTER() gdk_threads_enter()
</MACRO>
<MACRO>
<NAME>GDK_THREADS_LEAVE</NAME>
#define GDK_THREADS_LEAVE() gdk_threads_leave()
</MACRO>
<MACRO>
<NAME>GDK_CURRENT_TIME</NAME>
#define GDK_CURRENT_TIME     0L
</MACRO>
<MACRO>
<NAME>GDK_PARENT_RELATIVE</NAME>
#define GDK_PARENT_RELATIVE  1L
</MACRO>
<STRUCT>
<NAME>GdkPoint</NAME>
struct _GdkPoint
{
  gint x;
  gint y;
};
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
struct _GdkRectangle
{
    int x, y;
    int width, height;
};
</STRUCT>
<TYPEDEF>
<NAME>GdkAtom</NAME>
typedef const char                   *GdkAtom;
</TYPEDEF>
<ENUM>
<NAME>GdkByteOrder</NAME>
typedef enum
{
  GDK_LSB_FIRST,
  GDK_MSB_FIRST
} GdkByteOrder;
</ENUM>
<ENUM>
<NAME>GdkModifierType</NAME>
typedef enum
{
  GDK_SHIFT_MASK    = 1 << 0,
  GDK_LOCK_MASK     = 1 << 1,
  GDK_CONTROL_MASK  = 1 << 2,
  GDK_MOD1_MASK     = 1 << 3,
  GDK_MOD2_MASK     = 1 << 4,
  GDK_MOD3_MASK     = 1 << 5,
  GDK_MOD4_MASK     = 1 << 6,
  GDK_MOD5_MASK     = 1 << 7,
  GDK_BUTTON1_MASK  = 1 << 8,
  GDK_BUTTON2_MASK  = 1 << 9,
  GDK_BUTTON3_MASK  = 1 << 10,
  GDK_BUTTON4_MASK  = 1 << 11,
  GDK_BUTTON5_MASK  = 1 << 12,

  GDK_MODIFIER_RESERVED_13_MASK  = 1 << 13,
  GDK_MODIFIER_RESERVED_14_MASK  = 1 << 14,
  GDK_MODIFIER_RESERVED_15_MASK  = 1 << 15,
  GDK_MODIFIER_RESERVED_16_MASK  = 1 << 16,
  GDK_MODIFIER_RESERVED_17_MASK  = 1 << 17,
  GDK_MODIFIER_RESERVED_18_MASK  = 1 << 18,
  GDK_MODIFIER_RESERVED_19_MASK  = 1 << 19,
  GDK_MODIFIER_RESERVED_20_MASK  = 1 << 20,
  GDK_MODIFIER_RESERVED_21_MASK  = 1 << 21,
  GDK_MODIFIER_RESERVED_22_MASK  = 1 << 22,
  GDK_MODIFIER_RESERVED_23_MASK  = 1 << 23,
  GDK_MODIFIER_RESERVED_24_MASK  = 1 << 24,
  GDK_MODIFIER_RESERVED_25_MASK  = 1 << 25,

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

  GDK_RELEASE_MASK  = 1 << 30,

  /* Combination of GDK_SHIFT_MASK..GDK_BUTTON5_MASK + GDK_SUPER_MASK
     + GDK_HYPER_MASK + GDK_META_MASK + GDK_RELEASE_MASK */
  GDK_MODIFIER_MASK = 0x5c001fff
} GdkModifierType;
</ENUM>
<ENUM>
<NAME>GdkModifierIntent</NAME>
typedef enum
{
  GDK_MODIFIER_INTENT_PRIMARY_ACCELERATOR,
  GDK_MODIFIER_INTENT_CONTEXT_MENU,
  GDK_MODIFIER_INTENT_EXTEND_SELECTION,
  GDK_MODIFIER_INTENT_MODIFY_SELECTION,
  GDK_MODIFIER_INTENT_NO_TEXT_INPUT,
  GDK_MODIFIER_INTENT_SHIFT_GROUP,
  GDK_MODIFIER_INTENT_DEFAULT_MOD_MASK,
} GdkModifierIntent;
</ENUM>
<ENUM>
<NAME>GdkStatus</NAME>
typedef enum
{
  GDK_OK          = 0,
  GDK_ERROR       = -1,
  GDK_ERROR_PARAM = -2,
  GDK_ERROR_FILE  = -3,
  GDK_ERROR_MEM   = -4
} GdkStatus;
</ENUM>
<ENUM>
<NAME>GdkGrabStatus</NAME>
typedef enum
{
  GDK_GRAB_SUCCESS         = 0,
  GDK_GRAB_ALREADY_GRABBED = 1,
  GDK_GRAB_INVALID_TIME    = 2,
  GDK_GRAB_NOT_VIEWABLE    = 3,
  GDK_GRAB_FROZEN          = 4,
  GDK_GRAB_FAILED          = 5
} GdkGrabStatus;
</ENUM>
<ENUM>
<NAME>GdkGrabOwnership</NAME>
typedef enum
{
  GDK_OWNERSHIP_NONE,
  GDK_OWNERSHIP_WINDOW,
  GDK_OWNERSHIP_APPLICATION
} GdkGrabOwnership;
</ENUM>
<ENUM>
<NAME>GdkEventMask</NAME>
typedef enum
{
  GDK_EXPOSURE_MASK             = 1 << 1,
  GDK_POINTER_MOTION_MASK       = 1 << 2,
  GDK_BUTTON_MOTION_MASK        = 1 << 4,
  GDK_BUTTON1_MOTION_MASK       = 1 << 5,
  GDK_BUTTON2_MOTION_MASK       = 1 << 6,
  GDK_BUTTON3_MOTION_MASK       = 1 << 7,
  GDK_BUTTON_PRESS_MASK         = 1 << 8,
  GDK_BUTTON_RELEASE_MASK       = 1 << 9,
  GDK_KEY_PRESS_MASK            = 1 << 10,
  GDK_KEY_RELEASE_MASK          = 1 << 11,
  GDK_ENTER_NOTIFY_MASK         = 1 << 12,
  GDK_LEAVE_NOTIFY_MASK         = 1 << 13,
  GDK_FOCUS_CHANGE_MASK         = 1 << 14,
  GDK_STRUCTURE_MASK            = 1 << 15,
  GDK_PROPERTY_CHANGE_MASK      = 1 << 16,
  GDK_PROXIMITY_IN_MASK         = 1 << 18,
  GDK_PROXIMITY_OUT_MASK        = 1 << 19,
  GDK_SUBSTRUCTURE_MASK         = 1 << 20,
  GDK_SCROLL_MASK               = 1 << 21,
  GDK_TOUCH_MASK                = 1 << 22,
  GDK_SMOOTH_SCROLL_MASK        = 1 << 23,
  GDK_TOUCHPAD_GESTURE_MASK     = 1 << 24,
  GDK_TABLET_PAD_MASK           = 1 << 25,
  GDK_ALL_EVENTS_MASK           = 0x3FFFFFE
} GdkEventMask;
</ENUM>
<ENUM>
<NAME>GdkGLError</NAME>
typedef enum {
  GDK_GL_ERROR_NOT_AVAILABLE,
  GDK_GL_ERROR_UNSUPPORTED_FORMAT,
  GDK_GL_ERROR_UNSUPPORTED_PROFILE,
  GDK_GL_ERROR_COMPILATION_FAILED,
  GDK_GL_ERROR_LINK_FAILED
} GdkGLError;
</ENUM>
<ENUM>
<NAME>GdkVulkanError</NAME>
typedef enum {
  GDK_VULKAN_ERROR_UNSUPPORTED,
  GDK_VULKAN_ERROR_NOT_AVAILABLE,
} GdkVulkanError;
</ENUM>
<ENUM>
<NAME>GdkWindowTypeHint</NAME>
typedef enum
{
  GDK_WINDOW_TYPE_HINT_NORMAL,
  GDK_WINDOW_TYPE_HINT_DIALOG,
  GDK_WINDOW_TYPE_HINT_MENU,		/* Torn off menu */
  GDK_WINDOW_TYPE_HINT_TOOLBAR,
  GDK_WINDOW_TYPE_HINT_SPLASHSCREEN,
  GDK_WINDOW_TYPE_HINT_UTILITY,
  GDK_WINDOW_TYPE_HINT_DOCK,
  GDK_WINDOW_TYPE_HINT_DESKTOP,
  GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU,	/* A drop down menu (from a menubar) */
  GDK_WINDOW_TYPE_HINT_POPUP_MENU,	/* A popup menu (from right-click) */
  GDK_WINDOW_TYPE_HINT_TOOLTIP,
  GDK_WINDOW_TYPE_HINT_NOTIFICATION,
  GDK_WINDOW_TYPE_HINT_COMBO,
  GDK_WINDOW_TYPE_HINT_DND
} GdkWindowTypeHint;
</ENUM>
<ENUM>
<NAME>GdkAxisUse</NAME>
typedef enum
{
  GDK_AXIS_IGNORE,
  GDK_AXIS_X,
  GDK_AXIS_Y,
  GDK_AXIS_PRESSURE,
  GDK_AXIS_XTILT,
  GDK_AXIS_YTILT,
  GDK_AXIS_WHEEL,
  GDK_AXIS_DISTANCE,
  GDK_AXIS_ROTATION,
  GDK_AXIS_SLIDER,
  GDK_AXIS_LAST
} GdkAxisUse;
</ENUM>
<ENUM>
<NAME>GdkAxisFlags</NAME>
typedef enum
{
  GDK_AXIS_FLAG_X        = 1 << GDK_AXIS_X,
  GDK_AXIS_FLAG_Y        = 1 << GDK_AXIS_Y,
  GDK_AXIS_FLAG_PRESSURE = 1 << GDK_AXIS_PRESSURE,
  GDK_AXIS_FLAG_XTILT    = 1 << GDK_AXIS_XTILT,
  GDK_AXIS_FLAG_YTILT    = 1 << GDK_AXIS_YTILT,
  GDK_AXIS_FLAG_WHEEL    = 1 << GDK_AXIS_WHEEL,
  GDK_AXIS_FLAG_DISTANCE = 1 << GDK_AXIS_DISTANCE,
  GDK_AXIS_FLAG_ROTATION = 1 << GDK_AXIS_ROTATION,
  GDK_AXIS_FLAG_SLIDER   = 1 << GDK_AXIS_SLIDER,
} GdkAxisFlags;
</ENUM>
<STRUCT>
<NAME>GdkAppLaunchContext</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>GdkDragContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkDrawingContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkGLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkKeymap</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkPoint</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRGBA</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkRectangle</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkSeat</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkVulkanContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWindow</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>
<ENUM>
<NAME>GdkWindowType</NAME>
typedef enum
{
  GDK_WINDOW_ROOT,
  GDK_WINDOW_TOPLEVEL,
  GDK_WINDOW_CHILD,
  GDK_WINDOW_TEMP,
  GDK_WINDOW_FOREIGN,
  GDK_WINDOW_SUBSURFACE
} GdkWindowType;
</ENUM>
<ENUM>
<NAME>GdkWindowHints</NAME>
typedef enum
{
  GDK_HINT_POS	       = 1 << 0,
  GDK_HINT_MIN_SIZE    = 1 << 1,
  GDK_HINT_MAX_SIZE    = 1 << 2,
  GDK_HINT_BASE_SIZE   = 1 << 3,
  GDK_HINT_ASPECT      = 1 << 4,
  GDK_HINT_RESIZE_INC  = 1 << 5,
  GDK_HINT_WIN_GRAVITY = 1 << 6,
  GDK_HINT_USER_POS    = 1 << 7,
  GDK_HINT_USER_SIZE   = 1 << 8
} GdkWindowHints;
</ENUM>
<ENUM>
<NAME>GdkWMDecoration</NAME>
typedef enum
{
  GDK_DECOR_ALL		= 1 << 0,
  GDK_DECOR_BORDER	= 1 << 1,
  GDK_DECOR_RESIZEH	= 1 << 2,
  GDK_DECOR_TITLE	= 1 << 3,
  GDK_DECOR_MENU	= 1 << 4,
  GDK_DECOR_MINIMIZE	= 1 << 5,
  GDK_DECOR_MAXIMIZE	= 1 << 6
} GdkWMDecoration;
</ENUM>
<ENUM>
<NAME>GdkWMFunction</NAME>
typedef enum
{
  GDK_FUNC_ALL		= 1 << 0,
  GDK_FUNC_RESIZE	= 1 << 1,
  GDK_FUNC_MOVE		= 1 << 2,
  GDK_FUNC_MINIMIZE	= 1 << 3,
  GDK_FUNC_MAXIMIZE	= 1 << 4,
  GDK_FUNC_CLOSE	= 1 << 5
} GdkWMFunction;
</ENUM>
<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>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>
<ENUM>
<NAME>GdkWindowEdge</NAME>
typedef enum
{
  GDK_WINDOW_EDGE_NORTH_WEST,
  GDK_WINDOW_EDGE_NORTH,
  GDK_WINDOW_EDGE_NORTH_EAST,
  GDK_WINDOW_EDGE_WEST,
  GDK_WINDOW_EDGE_EAST,
  GDK_WINDOW_EDGE_SOUTH_WEST,
  GDK_WINDOW_EDGE_SOUTH,
  GDK_WINDOW_EDGE_SOUTH_EAST  
} GdkWindowEdge;
</ENUM>
<ENUM>
<NAME>GdkFullscreenMode</NAME>
typedef enum
{
  GDK_FULLSCREEN_ON_CURRENT_MONITOR,
  GDK_FULLSCREEN_ON_ALL_MONITORS
} GdkFullscreenMode;
</ENUM>
<STRUCT>
<NAME>GdkGeometry</NAME>
struct _GdkGeometry
{
  gint min_width;
  gint min_height;
  gint max_width;
  gint max_height;
  gint base_width;
  gint base_height;
  gint width_inc;
  gint height_inc;
  gdouble min_aspect;
  gdouble max_aspect;
  GdkGravity win_gravity;
};
</STRUCT>
<ENUM>
<NAME>GdkWindowState</NAME>
typedef enum
{
  GDK_WINDOW_STATE_WITHDRAWN        = 1 << 0,
  GDK_WINDOW_STATE_ICONIFIED        = 1 << 1,
  GDK_WINDOW_STATE_MAXIMIZED        = 1 << 2,
  GDK_WINDOW_STATE_STICKY           = 1 << 3,
  GDK_WINDOW_STATE_FULLSCREEN       = 1 << 4,
  GDK_WINDOW_STATE_ABOVE            = 1 << 5,
  GDK_WINDOW_STATE_BELOW            = 1 << 6,
  GDK_WINDOW_STATE_FOCUSED          = 1 << 7,
  GDK_WINDOW_STATE_TILED            = 1 << 8,
  GDK_WINDOW_STATE_TOP_TILED        = 1 << 9,
  GDK_WINDOW_STATE_TOP_RESIZABLE    = 1 << 10,
  GDK_WINDOW_STATE_RIGHT_TILED      = 1 << 11,
  GDK_WINDOW_STATE_RIGHT_RESIZABLE  = 1 << 12,
  GDK_WINDOW_STATE_BOTTOM_TILED     = 1 << 13,
  GDK_WINDOW_STATE_BOTTOM_RESIZABLE = 1 << 14,
  GDK_WINDOW_STATE_LEFT_TILED       = 1 << 15,
  GDK_WINDOW_STATE_LEFT_RESIZABLE   = 1 << 16
} GdkWindowState;
</ENUM>
<MACRO>
<NAME>GDK_TYPE_WINDOW</NAME>
#define GDK_TYPE_WINDOW              (gdk_window_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WINDOW</NAME>
#define GDK_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW, GdkWindow))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_CLASS</NAME>
#define GDK_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW, GdkWindowClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WINDOW</NAME>
#define GDK_IS_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW))
</MACRO>
<MACRO>
<NAME>GDK_IS_WINDOW_CLASS</NAME>
#define GDK_IS_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_GET_CLASS</NAME>
#define GDK_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW, GdkWindowClass))
</MACRO>
<STRUCT>
<NAME>GdkWindowClass</NAME>
struct _GdkWindowClass
{
  GObjectClass      parent_class;

  /* Padding for future expansion */
  void (*_gdk_reserved1) (void);
  void (*_gdk_reserved2) (void);
  void (*_gdk_reserved3) (void);
  void (*_gdk_reserved4) (void);
  void (*_gdk_reserved5) (void);
  void (*_gdk_reserved6) (void);
  void (*_gdk_reserved7) (void);
  void (*_gdk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_window_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_new_toplevel</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkDisplay    *display, int            width, int            height
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_new_popup</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkDisplay    *display, const GdkRectangle *position
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_new_temp</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkDisplay    *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_new_child</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkWindow     *parent, const GdkRectangle *position
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_destroy</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_window_type</NAME>
<RETURNS>GdkWindowType  </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_is_destroyed</NAME>
<RETURNS>gboolean       </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_display</NAME>
<RETURNS>GdkDisplay  *  </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_show</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_hide</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_withdraw</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_show_unraised</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_move</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, gint           x, gint           y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_resize</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, gint           width, gint           height
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_move_resize</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, gint           x, gint           y, gint           width, gint           height
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_raise</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_lower</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_restack</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, GdkWindow     *sibling, gboolean       above
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_focus</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, guint32        timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_user_data</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, gpointer       user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_accept_focus</NAME>
<RETURNS>gboolean       </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_accept_focus</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, gboolean       accept_focus
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_focus_on_map</NAME>
<RETURNS>gboolean       </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_focus_on_map</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, gboolean       focus_on_map
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_add_filter</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, GdkFilterFunc  function, gpointer       data
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_remove_filter</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, GdkFilterFunc  function, gpointer       data
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_scroll</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, gint           dx, gint           dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_move_region</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow       *window, const cairo_region_t *region, gint             dx, gint             dy
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_shape_combine_region</NAME>
<RETURNS>void  </RETURNS>
GdkWindow	      *window, const cairo_region_t *shape_region, gint	       offset_x, gint	       offset_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_child_shapes</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_merge_child_shapes</NAME>
<RETURNS>void  </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_input_shape_combine_region</NAME>
<RETURNS>void  </RETURNS>
GdkWindow       *window, const cairo_region_t *shape_region, gint             offset_x, gint             offset_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_child_input_shapes</NAME>
<RETURNS>void  </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_merge_child_input_shapes</NAME>
<RETURNS>void  </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_pass_through</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window, gboolean   pass_through
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_pass_through</NAME>
<RETURNS>gboolean  </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_is_visible</NAME>
<RETURNS>gboolean  </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_is_viewable</NAME>
<RETURNS>gboolean  </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_is_input_only</NAME>
<RETURNS>gboolean  </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_is_shaped</NAME>
<RETURNS>gboolean  </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_state</NAME>
<RETURNS>GdkWindowState  </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_has_native</NAME>
<RETURNS>gboolean       </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_type_hint</NAME>
<RETURNS>void               </RETURNS>
GdkWindow        *window, GdkWindowTypeHint hint
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_type_hint</NAME>
<RETURNS>GdkWindowTypeHint  </RETURNS>
GdkWindow        *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_modal_hint</NAME>
<RETURNS>gboolean       </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_modal_hint</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window, gboolean         modal
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_skip_taskbar_hint</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window, gboolean   skips_taskbar
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_skip_pager_hint</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window, gboolean   skips_pager
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_urgency_hint</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window, gboolean   urgent
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_geometry_hints</NAME>
<RETURNS>void           </RETURNS>
GdkWindow          *window, const GdkGeometry  *geometry, GdkWindowHints      geom_mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_clip_region</NAME>
<RETURNS>cairo_region_t  *</RETURNS>
GdkWindow          *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_visible_region</NAME>
<RETURNS>cairo_region_t  *</RETURNS>
GdkWindow         *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_begin_draw_frame</NAME>
<RETURNS>GdkDrawingContext  *</RETURNS>
GdkWindow            *window, GdkDrawContext       *context, const cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_end_draw_frame</NAME>
<RETURNS>void           </RETURNS>
GdkWindow            *window, GdkDrawingContext    *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_title</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, const gchar	  *title
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_role</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, const gchar   *role
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_startup_id</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, const gchar   *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_transient_for</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, GdkWindow     *parent
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_cursor</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, GdkCursor	  *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_cursor</NAME>
<RETURNS>GdkCursor     *</RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_device_cursor</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, GdkDevice     *device, GdkCursor	  *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_device_cursor</NAME>
<RETURNS>GdkCursor     *</RETURNS>
GdkWindow     *window, GdkDevice     *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_user_data</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, gpointer	  *data
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_geometry</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, gint		  *x, gint		  *y, gint		  *width, gint		  *height
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_width</NAME>
<RETURNS>int            </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_height</NAME>
<RETURNS>int            </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_position</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, gint		  *x, gint		  *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_origin</NAME>
<RETURNS>gint 	      </RETURNS>
GdkWindow	  *window, gint		  *x, gint		  *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_root_coords</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, gint             x, gint             y, gint		  *root_x, gint		  *root_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_coords_to_parent</NAME>
<RETURNS>void        </RETURNS>
GdkWindow       *window, gdouble          x, gdouble          y, gdouble         *parent_x, gdouble         *parent_y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_coords_from_parent</NAME>
<RETURNS>void        </RETURNS>
GdkWindow       *window, gdouble          parent_x, gdouble          parent_y, gdouble         *x, gdouble         *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_root_origin</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, gint		  *x, gint		  *y
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_frame_extents</NAME>
<RETURNS>void           </RETURNS>
GdkWindow     *window, GdkRectangle  *rect
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_scale_factor</NAME>
<RETURNS>gint           </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_device_position</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkWindow       *window, GdkDevice       *device, gint            *x, gint            *y, GdkModifierType *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_device_position_double</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkWindow       *window, GdkDevice       *device, gdouble         *x, gdouble         *y, GdkModifierType *mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_parent</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_toplevel</NAME>
<RETURNS>GdkWindow  *   </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_children</NAME>
<RETURNS>GList  *	      </RETURNS>
GdkWindow	  *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_peek_children</NAME>
<RETURNS>GList  *       </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_children_with_user_data</NAME>
<RETURNS>GList  *       </RETURNS>
GdkWindow *window, gpointer   user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_events</NAME>
<RETURNS>GdkEventMask   </RETURNS>
GdkWindow	  *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_events</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, GdkEventMask	   event_mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_device_events</NAME>
<RETURNS>void           </RETURNS>
GdkWindow    *window, GdkDevice    *device, GdkEventMask  event_mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_device_events</NAME>
<RETURNS>GdkEventMask   </RETURNS>
GdkWindow    *window, GdkDevice    *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_icon_list</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window, GList           *surfaces
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_icon_name</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, const gchar	  *name
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_group</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, GdkWindow	  *leader
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_group</NAME>
<RETURNS>GdkWindow *    </RETURNS>
GdkWindow	  *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_decorations</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, GdkWMDecoration  decorations
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_decorations</NAME>
<RETURNS>gboolean       </RETURNS>
GdkWindow       *window, GdkWMDecoration *decorations
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_functions</NAME>
<RETURNS>void 	      </RETURNS>
GdkWindow	  *window, GdkWMFunction	   functions
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_create_similar_surface</NAME>
<RETURNS>cairo_surface_t  *</RETURNS>
GdkWindow *window, cairo_content_t  content, int              width, int              height
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_create_similar_image_surface</NAME>
<RETURNS>cairo_surface_t  *</RETURNS>
GdkWindow *window, cairo_format_t format, int            width, int            height, int            scale
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_beep</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_iconify</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_deiconify</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_stick</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_unstick</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_maximize</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_unmaximize</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_fullscreen</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_fullscreen_on_monitor</NAME>
<RETURNS>void           </RETURNS>
GdkWindow      *window, GdkMonitor     *monitor
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_fullscreen_mode</NAME>
<RETURNS>void           </RETURNS>
GdkWindow   *window, GdkFullscreenMode mode
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_fullscreen_mode</NAME>
<RETURNS>GdkFullscreenMode</RETURNS>
GdkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_unfullscreen</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_keep_above</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window, gboolean         setting
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_keep_below</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window, gboolean         setting
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_opacity</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window, gdouble          opacity
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_register_dnd</NAME>
<RETURNS>void           </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_begin_resize_drag</NAME>
<RETURNS>void  </RETURNS>
GdkWindow     *window, GdkWindowEdge  edge, gint           button, gint           root_x, gint           root_y, guint32        timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_begin_resize_drag_for_device</NAME>
<RETURNS>void  </RETURNS>
GdkWindow     *window, GdkWindowEdge  edge, GdkDevice     *device, gint           button, gint           root_x, gint           root_y, guint32        timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_begin_move_drag</NAME>
<RETURNS>void  </RETURNS>
GdkWindow     *window, gint           button, gint           root_x, gint           root_y, guint32        timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_begin_move_drag_for_device</NAME>
<RETURNS>void  </RETURNS>
GdkWindow     *window, GdkDevice     *device, gint           button, gint           root_x, gint           root_y, guint32        timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_invalidate_rect</NAME>
<RETURNS>void        </RETURNS>
GdkWindow          *window, const GdkRectangle *rect, gboolean            invalidate_children
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_invalidate_region</NAME>
<RETURNS>void        </RETURNS>
GdkWindow          *window, const cairo_region_t    *region, gboolean            invalidate_children
</FUNCTION>
<USER_FUNCTION>
<NAME>GdkWindowChildFunc</NAME>
<RETURNS>gboolean </RETURNS>
GdkWindow *window,
                                                 gpointer   user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_window_invalidate_maybe_recurse</NAME>
<RETURNS>void        </RETURNS>
GdkWindow            *window, const cairo_region_t *region, GdkWindowChildFunc    child_func, gpointer              user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_update_area</NAME>
<RETURNS>cairo_region_t  *</RETURNS>
GdkWindow            *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_freeze_updates</NAME>
<RETURNS>void        </RETURNS>
GdkWindow    *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_thaw_updates</NAME>
<RETURNS>void        </RETURNS>
GdkWindow    *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_constrain_size</NAME>
<RETURNS>void        </RETURNS>
GdkGeometry    *geometry, GdkWindowHints  flags, gint            width, gint            height, gint           *new_width, gint           *new_height
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_support_multidevice</NAME>
<RETURNS>void        </RETURNS>
GdkWindow *window, gboolean   support_multidevice
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_support_multidevice</NAME>
<RETURNS>gboolean    </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_get_frame_clock</NAME>
<RETURNS>GdkFrameClock * </RETURNS>
GdkWindow     *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_opaque_region</NAME>
<RETURNS>void        </RETURNS>
GdkWindow      *window, cairo_region_t *region
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_set_shadow_width</NAME>
<RETURNS>void        </RETURNS>
GdkWindow      *window, gint            left, gint            right, gint            top, gint            bottom
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_show_window_menu</NAME>
<RETURNS>gboolean   </RETURNS>
GdkWindow      *window, GdkEvent       *event
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_create_gl_context</NAME>
<RETURNS>GdkGLContext  * </RETURNS>
GdkWindow      *window, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_create_vulkan_context</NAME>
<RETURNS>GdkVulkanContext  *</RETURNS>
GdkWindow      *window, GError        **error
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WINDOW_IMPL</NAME>
#define GDK_TYPE_WINDOW_IMPL           (gdk_window_impl_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IMPL</NAME>
#define GDK_WINDOW_IMPL(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL, GdkWindowImpl))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IMPL_CLASS</NAME>
#define GDK_WINDOW_IMPL_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL, GdkWindowImplClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WINDOW_IMPL</NAME>
#define GDK_IS_WINDOW_IMPL(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL))
</MACRO>
<MACRO>
<NAME>GDK_IS_WINDOW_IMPL_CLASS</NAME>
#define GDK_IS_WINDOW_IMPL_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IMPL_GET_CLASS</NAME>
#define GDK_WINDOW_IMPL_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL, GdkWindowImplClass))
</MACRO>
<STRUCT>
<NAME>GdkWindowImpl</NAME>
struct _GdkWindowImpl
{
  GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>GdkWindowImplClass</NAME>
struct _GdkWindowImplClass
{
  GObjectClass parent_class;

  cairo_surface_t *
               (* ref_cairo_surface)    (GdkWindow       *window);
  cairo_surface_t *
               (* create_similar_image_surface) (GdkWindow *     window,
                                                 cairo_format_t  format,
                                                 int             width,
                                                 int             height);

  void         (* show)                 (GdkWindow       *window,
					 gboolean         already_mapped);
  void         (* hide)                 (GdkWindow       *window);
  void         (* withdraw)             (GdkWindow       *window);
  void         (* raise)                (GdkWindow       *window);
  void         (* lower)                (GdkWindow       *window);
  void         (* restack_toplevel)     (GdkWindow       *window,
					 GdkWindow       *sibling,
					 gboolean        above);

  void         (* move_resize)          (GdkWindow       *window,
                                         gboolean         with_move,
                                         gint             x,
                                         gint             y,
                                         gint             width,
                                         gint             height);
  void         (* move_to_rect)         (GdkWindow       *window,
                                         const GdkRectangle *rect,
                                         GdkGravity       rect_anchor,
                                         GdkGravity       window_anchor,
                                         GdkAnchorHints   anchor_hints,
                                         gint             rect_anchor_dx,
                                         gint             rect_anchor_dy);

  GdkEventMask (* get_events)           (GdkWindow       *window);
  void         (* set_events)           (GdkWindow       *window,
                                         GdkEventMask     event_mask);

  void         (* get_geometry)         (GdkWindow       *window,
                                         gint            *x,
                                         gint            *y,
                                         gint            *width,
                                         gint            *height);
  void         (* get_root_coords)      (GdkWindow       *window,
					 gint             x,
					 gint             y,
                                         gint            *root_x,
                                         gint            *root_y);
  gboolean     (* get_device_state)     (GdkWindow       *window,
                                         GdkDevice       *device,
                                         gdouble         *x,
                                         gdouble         *y,
                                         GdkModifierType *mask);
  gboolean    (* begin_paint)           (GdkWindow       *window);
  void        (* end_paint)             (GdkWindow       *window);

  void         (* shape_combine_region) (GdkWindow       *window,
                                         const cairo_region_t *shape_region,
                                         gint             offset_x,
                                         gint             offset_y);
  void         (* input_shape_combine_region) (GdkWindow       *window,
					       const cairo_region_t *shape_region,
					       gint             offset_x,
					       gint             offset_y);

  /* Called before processing updates for a window. This gives the windowing
   * layer a chance to save the region for later use in avoiding duplicate
   * exposes.
   */
  void     (* queue_antiexpose)     (GdkWindow       *window,
                                     cairo_region_t  *update_area);

/* Called to do the windowing system specific part of gdk_window_destroy(),
 *
 * window: The window being destroyed
 * recursing: If TRUE, then this is being called because a parent
 *     was destroyed. This generally means that the call to the windowing
 *     system to destroy the window can be omitted, since it will be
 *     destroyed as a result of the parent being destroyed.
 *     Unless @foreign_destroy
 * foreign_destroy: If TRUE, the window or a parent was destroyed by some
 *     external agency. The window has already been destroyed and no
 *     windowing system calls should be made. (This may never happen
 *     for some windowing systems.)
 */
  void         (* destroy)              (GdkWindow       *window,
					 gboolean         recursing,
					 gboolean         foreign_destroy);


  /* optional */
  gboolean     (* beep)                 (GdkWindow       *window);

  void         (* focus)                (GdkWindow       *window,
					 guint32          timestamp);
  void         (* set_type_hint)        (GdkWindow       *window,
					 GdkWindowTypeHint hint);
  GdkWindowTypeHint (* get_type_hint)   (GdkWindow       *window);
  void         (* set_modal_hint)       (GdkWindow *window,
					 gboolean   modal);
  void         (* set_skip_taskbar_hint) (GdkWindow *window,
					  gboolean   skips_taskbar);
  void         (* set_skip_pager_hint)  (GdkWindow *window,
					 gboolean   skips_pager);
  void         (* set_urgency_hint)     (GdkWindow *window,
					 gboolean   urgent);
  void         (* set_geometry_hints)   (GdkWindow         *window,
					 const GdkGeometry *geometry,
					 GdkWindowHints     geom_mask);
  void         (* set_title)            (GdkWindow   *window,
					 const gchar *title);
  void         (* set_role)             (GdkWindow   *window,
					 const gchar *role);
  void         (* set_startup_id)       (GdkWindow   *window,
					 const gchar *startup_id);
  void         (* set_transient_for)    (GdkWindow *window,
					 GdkWindow *parent);
  void         (* get_frame_extents)    (GdkWindow    *window,
					 GdkRectangle *rect);
  void         (* set_accept_focus)     (GdkWindow *window,
					 gboolean accept_focus);
  void         (* set_focus_on_map)     (GdkWindow *window,
					 gboolean focus_on_map);
  void         (* set_icon_list)        (GdkWindow *window,
					 GList     *pixbufs);
  void         (* set_icon_name)        (GdkWindow   *window,
					 const gchar *name);
  void         (* iconify)              (GdkWindow *window);
  void         (* deiconify)            (GdkWindow *window);
  void         (* stick)                (GdkWindow *window);
  void         (* unstick)              (GdkWindow *window);
  void         (* maximize)             (GdkWindow *window);
  void         (* unmaximize)           (GdkWindow *window);
  void         (* fullscreen)           (GdkWindow *window);
  void         (* fullscreen_on_monitor) (GdkWindow  *window,
                                          GdkMonitor *monitor);
  void         (* apply_fullscreen_mode) (GdkWindow *window);
  void         (* unfullscreen)         (GdkWindow *window);
  void         (* set_keep_above)       (GdkWindow *window,
					 gboolean   setting);
  void         (* set_keep_below)       (GdkWindow *window,
					 gboolean   setting);
  GdkWindow *  (* get_group)            (GdkWindow *window);
  void         (* set_group)            (GdkWindow *window,
					 GdkWindow *leader);
  void         (* set_decorations)      (GdkWindow      *window,
					 GdkWMDecoration decorations);
  gboolean     (* get_decorations)      (GdkWindow       *window,
					 GdkWMDecoration *decorations);
  void         (* set_functions)        (GdkWindow    *window,
					 GdkWMFunction functions);
  void         (* begin_resize_drag)    (GdkWindow     *window,
                                         GdkWindowEdge  edge,
                                         GdkDevice     *device,
                                         gint           button,
                                         gint           root_x,
                                         gint           root_y,
                                         guint32        timestamp);
  void         (* begin_move_drag)      (GdkWindow *window,
                                         GdkDevice     *device,
                                         gint       button,
                                         gint       root_x,
                                         gint       root_y,
                                         guint32    timestamp);
  void         (* enable_synchronized_configure) (GdkWindow *window);
  void         (* configure_finished)   (GdkWindow *window);
  void         (* set_opacity)          (GdkWindow *window,
					 gdouble    opacity);
  void         (* destroy_notify)       (GdkWindow *window);
  void         (* register_dnd)         (GdkWindow *window);
  GdkDragContext * (*drag_begin)        (GdkWindow        *window,
                                         GdkDevice        *device,
                                         GdkContentProvider*content,
                                         GdkDragAction     actions,
                                         gint              dx,
                                         gint              dy);

  void         (*process_updates_recurse) (GdkWindow      *window,
                                           cairo_region_t *region);

  gint         (* get_scale_factor)       (GdkWindow      *window);
  void         (* get_unscaled_size)      (GdkWindow      *window,
                                           int            *unscaled_width,
                                           int            *unscaled_height);

  void         (* set_opaque_region)      (GdkWindow      *window,
                                           cairo_region_t *region);
  void         (* set_shadow_width)       (GdkWindow      *window,
                                           gint            left,
                                           gint            right,
                                           gint            top,
                                           gint            bottom);
  gboolean     (* show_window_menu)       (GdkWindow      *window,
                                           GdkEvent       *event);
  GdkGLContext *(*create_gl_context)      (GdkWindow      *window,
					   gboolean        attached,
                                           GdkGLContext   *share,
                                           GError        **error);
  gboolean     (* supports_edge_constraints)(GdkWindow    *window);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_window_impl_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_CLIPBOARD</NAME>
#define GDK_TYPE_WAYLAND_CLIPBOARD    (gdk_wayland_clipboard_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_CLIPBOARD</NAME>
#define GDK_WAYLAND_CLIPBOARD(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_CLIPBOARD, GdkWaylandClipboard))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_CLIPBOARD</NAME>
#define GDK_IS_WAYLAND_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_CLIPBOARD))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_clipboard_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_clipboard_new</NAME>
<RETURNS>GdkClipboard  *          </RETURNS>
GdkDisplay             *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_clipboard_claim_remote</NAME>
<RETURNS>void                     </RETURNS>
GdkWaylandClipboard    *cb, struct wl_data_offer   *offer, GdkContentFormats      *formats
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandClipboard</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_WAYLAND_MAX_THEME_SCALE</NAME>
#define GDK_WAYLAND_MAX_THEME_SCALE 3
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_THEME_SCALES_COUNT</NAME>
#define GDK_WAYLAND_THEME_SCALES_COUNT GDK_WAYLAND_MAX_THEME_SCALE
</MACRO>
<MACRO>
<NAME>GDK_ZWP_POINTER_GESTURES_V1_VERSION</NAME>
#define GDK_ZWP_POINTER_GESTURES_V1_VERSION 1
</MACRO>
<STRUCT>
<NAME>GsdXftSettings</NAME>
typedef struct {
        gboolean     antialias;
        gboolean     hinting;
        gint         dpi;
        const gchar *rgba;
        const gchar *hintstyle;
} GsdXftSettings;
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDisplay</NAME>
struct _GdkWaylandDisplay
{
  GdkDisplay parent_instance;
  GList *toplevels;

  GHashTable *settings;
  GsdXftSettings xft_settings;

  guint32    shell_capabilities;

  /* Startup notification */
  gchar *startup_notification_id;

  /* Most recent serial */
  guint32 serial;

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

  GList *async_roundtrips;

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

  /* Keep a list of orphaned dialogs (i.e. without parent) */
  GList *orphan_dialogs;

  GList *current_popups;

  struct wl_cursor_theme *scaled_cursor_themes[GDK_WAYLAND_THEME_SCALES_COUNT];
  gchar *cursor_theme_name;
  int cursor_theme_size;
  GHashTable *cursor_surface_cache;

  GSource *event_source;

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

  uint32_t server_decoration_mode;

  struct xkb_context *xkb_context;

  GdkWaylandSelection *selection;

  GPtrArray *monitors;

  gint64 last_bell_time_ms;

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

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

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

  guint32 id;
  guint32 version;
  struct wl_output *output;
  gboolean added;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandMonitorClass</NAME>
struct _GdkWaylandMonitorClass {
  GdkMonitorClass parent_class;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_PRIMARY</NAME>
#define GDK_TYPE_WAYLAND_PRIMARY    (gdk_wayland_primary_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_PRIMARY</NAME>
#define GDK_WAYLAND_PRIMARY(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_PRIMARY, GdkWaylandPrimary))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_PRIMARY</NAME>
#define GDK_IS_WAYLAND_PRIMARY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_PRIMARY))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_primary_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_primary_new</NAME>
<RETURNS>GdkClipboard  *          </RETURNS>
GdkWaylandSeat         *seat
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandPrimary</NAME>
</STRUCT>
<MACRO>
<NAME>WL_SURFACE_HAS_BUFFER_SCALE</NAME>
#define WL_SURFACE_HAS_BUFFER_SCALE 3
</MACRO>
<MACRO>
<NAME>WL_POINTER_HAS_FRAME</NAME>
#define WL_POINTER_HAS_FRAME 5
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IS_WAYLAND</NAME>
#define GDK_WINDOW_IS_WAYLAND(win)    (GDK_IS_WINDOW_IMPL_WAYLAND (((GdkWindow *)win)->impl))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_display_system_bell</NAME>
<RETURNS>void        </RETURNS>
GdkDisplay *display, GdkWindow  *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_sync</NAME>
<RETURNS>void        </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drag_context_set_action</NAME>
<RETURNS>void  </RETURNS>
GdkDragContext *context, GdkDragAction   action
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drag_context_lookup_by_data_source</NAME>
<RETURNS>GdkDragContext  * </RETURNS>
struct wl_data_source *source
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drag_context_lookup_by_source_window</NAME>
<RETURNS>GdkDragContext  * </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drag_context_get_data_source</NAME>
<RETURNS>struct wl_data_source  * </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_drop_context_update_targets</NAME>
<RETURNS>void  </RETURNS>
GdkDragContext *context
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_data_device</NAME>
<RETURNS>struct wl_data_device  * </RETURNS>
GdkDevice *gdk_device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_set_selection</NAME>
<RETURNS>void  </RETURNS>
GdkDevice             *gdk_device, struct wl_data_source *source
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_drop_context</NAME>
<RETURNS>GdkDragContext  * </RETURNS>
GdkDevice *gdk_device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_unset_touch_grab</NAME>
<RETURNS>void  </RETURNS>
GdkDevice        *device, GdkEventSequence *sequence
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_toplevel_windows</NAME>
<RETURNS>GList  *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_output_refresh_rate</NAME>
<RETURNS>int  </RETURNS>
GdkWaylandDisplay *display_wayland, struct wl_output  *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_output_scale</NAME>
<RETURNS>guint32  </RETURNS>
GdkWaylandDisplay *display_wayland, struct wl_output  *output
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_wl_output</NAME>
<RETURNS>struct wl_output  *</RETURNS>
GdkDisplay *display, int         monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_selection</NAME>
<RETURNS>GdkWaylandSelection  * </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_new</NAME>
<RETURNS>GdkWaylandSelection  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_free</NAME>
<RETURNS>void  </RETURNS>
GdkWaylandSelection *selection
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_ensure_offer</NAME>
<RETURNS>void  </RETURNS>
GdkDisplay           *display, struct wl_data_offer *wl_offer
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_ensure_primary_offer</NAME>
<RETURNS>void  </RETURNS>
GdkDisplay                         *display, struct gtk_primary_selection_offer *wp_offer
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_steal_offer</NAME>
<RETURNS>GdkContentFormats  *</RETURNS>
GdkDisplay *display, gpointer wl_offer
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_set_offer</NAME>
<RETURNS>void  </RETURNS>
GdkDisplay           *display, gpointer              offer
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_get_offer</NAME>
<RETURNS>gpointer  </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_get_targets</NAME>
<RETURNS>GdkContentFormats  *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_get_data_source</NAME>
<RETURNS>struct wl_data_source  * </RETURNS>
GdkWindow *owner
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_unset_data_source</NAME>
<RETURNS>void  </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_selection_set_current_offer_actions</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDisplay *display, uint32_t    actions
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_get_egl_surface</NAME>
<RETURNS>EGLSurface  </RETURNS>
GdkWindow *window, EGLConfig config
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_get_dummy_egl_surface</NAME>
<RETURNS>EGLSurface  </RETURNS>
GdkWindow *window, EGLConfig config
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_get_gtk_surface</NAME>
<RETURNS>struct gtk_surface1  * </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_set_global_cursor</NAME>
<RETURNS>void  </RETURNS>
GdkSeat   *seat, GdkCursor *cursor
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_get_wl_output</NAME>
<RETURNS>struct wl_output  *</RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_inhibit_shortcuts</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window, GdkSeat   *gdk_seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_restore_shortcuts</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window, GdkSeat   *gdk_seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_update_scale</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_SEAT</NAME>
#define GDK_TYPE_WAYLAND_SEAT         (gdk_wayland_seat_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SEAT</NAME>
#define GDK_WAYLAND_SEAT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_WAYLAND_SEAT, GdkWaylandSeat))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SEAT_CLASS</NAME>
#define GDK_WAYLAND_SEAT_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_WAYLAND_SEAT, GdkWaylandSeatClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SEAT</NAME>
#define GDK_IS_WAYLAND_SEAT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_SEAT))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_SEAT_CLASS</NAME>
#define GDK_IS_WAYLAND_SEAT_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_WAYLAND_SEAT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_SEAT_GET_CLASS</NAME>
#define GDK_WAYLAND_SEAT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_WAYLAND_SEAT, GdkWaylandSeatClass))
</MACRO>
<STRUCT>
<NAME>GdkWaylandSeatClass</NAME>
struct _GdkWaylandSeatClass
{
  GdkSeatClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_wayland_seat_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandSeat</NAME>
</STRUCT>
<MACRO>
<NAME>VK_USE_PLATFORM_WAYLAND_KHR</NAME>
#define VK_USE_PLATFORM_WAYLAND_KHR
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_WAYLAND_VULKAN_CONTEXT		(gdk_wayland_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_VULKAN_CONTEXT</NAME>
#define GDK_WAYLAND_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_WAYLAND_VULKAN_CONTEXT, GdkWaylandVulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_VULKAN_CONTEXT</NAME>
#define GDK_IS_WAYLAND_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_WAYLAND_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_WAYLAND_VULKAN_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_VULKAN_CONTEXT, GdkWaylandVulkanContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_IS_WAYLAND_VULKAN_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_VULKAN_CONTEXT_GET_CLASS</NAME>
#define GDK_WAYLAND_VULKAN_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_VULKAN_CONTEXT, GdkWaylandVulkanContextClass))
</MACRO>
<STRUCT>
<NAME>GdkWaylandVulkanContext</NAME>
struct _GdkWaylandVulkanContext
{
  GdkVulkanContext parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GdkWaylandVulkanContextClass</NAME>
struct _GdkWaylandVulkanContextClass
{
  GdkVulkanContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_wayland_vulkan_context_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<TYPEDEF>
<NAME>GdkWaylandDevice</NAME>
typedef GdkDevice GdkWaylandDevice;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_DEVICE</NAME>
#define GDK_TYPE_WAYLAND_DEVICE         (gdk_wayland_device_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE</NAME>
#define GDK_WAYLAND_DEVICE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDevice))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE_CLASS</NAME>
#define GDK_WAYLAND_DEVICE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDeviceClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DEVICE</NAME>
#define GDK_IS_WAYLAND_DEVICE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_WAYLAND_DEVICE))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DEVICE_CLASS</NAME>
#define GDK_IS_WAYLAND_DEVICE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_WAYLAND_DEVICE))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DEVICE_GET_CLASS</NAME>
#define GDK_WAYLAND_DEVICE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_WAYLAND_DEVICE, GdkWaylandDeviceClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_device_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_seat</NAME>
<RETURNS>struct wl_seat       *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_pointer</NAME>
<RETURNS>struct wl_pointer    *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_wl_keyboard</NAME>
<RETURNS>struct wl_keyboard   *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_seat_get_wl_seat</NAME>
<RETURNS>struct wl_seat       *</RETURNS>
GdkSeat   *seat
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_get_node_path</NAME>
<RETURNS>const gchar          *</RETURNS>
GdkDevice *device
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_device_pad_set_feedback</NAME>
<RETURNS>void                  </RETURNS>
GdkDevice           *device, GdkDevicePadFeature  element, guint                idx, const gchar         *label
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandDevice</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandDeviceClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkWaylandDisplay</NAME>
typedef GdkDisplay GdkWaylandDisplay;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_DISPLAY</NAME>
#define GDK_TYPE_WAYLAND_DISPLAY              (gdk_wayland_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY</NAME>
#define GDK_WAYLAND_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplay))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY_CLASS</NAME>
#define GDK_WAYLAND_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplayClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DISPLAY</NAME>
#define GDK_IS_WAYLAND_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_DISPLAY_CLASS</NAME>
#define GDK_IS_WAYLAND_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_DISPLAY_GET_CLASS</NAME>
#define GDK_WAYLAND_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_DISPLAY, GdkWaylandDisplayClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_display_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_wl_display</NAME>
<RETURNS>struct wl_display       *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_get_wl_compositor</NAME>
<RETURNS>struct wl_compositor    *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_set_cursor_theme</NAME>
<RETURNS>void                     </RETURNS>
GdkDisplay  *display, const gchar *theme, gint         size
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_set_startup_notification_id</NAME>
<RETURNS>void                     </RETURNS>
GdkDisplay *display, const char *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_display_prefers_ssd</NAME>
<RETURNS>gboolean                 </RETURNS>
GdkDisplay *display
</FUNCTION>
<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>GdkWaylandWindow</NAME>
typedef GdkWindow GdkWaylandWindow;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_WAYLAND_WINDOW</NAME>
#define GDK_TYPE_WAYLAND_WINDOW              (gdk_wayland_window_get_type())
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_WINDOW</NAME>
#define GDK_WAYLAND_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_WINDOW, GdkWaylandWindow))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_WINDOW_CLASS</NAME>
#define GDK_WAYLAND_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_WINDOW, GdkWaylandWindowClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_WINDOW</NAME>
#define GDK_IS_WAYLAND_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_WINDOW))
</MACRO>
<MACRO>
<NAME>GDK_IS_WAYLAND_WINDOW_CLASS</NAME>
#define GDK_IS_WAYLAND_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_WINDOW))
</MACRO>
<MACRO>
<NAME>GDK_WAYLAND_WINDOW_GET_CLASS</NAME>
#define GDK_WAYLAND_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_WINDOW, GdkWaylandWindowClass))
</MACRO>
<FUNCTION>
<NAME>gdk_wayland_window_get_type</NAME>
<RETURNS>GType                     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_new_subsurface</NAME>
<RETURNS>GdkWindow  *              </RETURNS>
GdkDisplay            *display, const GdkRectangle    *position
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_get_wl_surface</NAME>
<RETURNS>struct wl_surface        *</RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_set_use_custom_surface</NAME>
<RETURNS>void                      </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_set_dbus_properties_libgtk_only</NAME>
<RETURNS>void                      </RETURNS>
GdkWindow  *window, const char *application_id, const char *app_menu_path, const char *menubar_path, const char *window_object_path, const char *application_object_path, const char *unique_bus_name
</FUNCTION>
<USER_FUNCTION>
<NAME>GdkWaylandWindowExported</NAME>
<RETURNS>void </RETURNS>
GdkWindow  *window,
                                          const char *handle,
                                          gpointer    user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_export_handle</NAME>
<RETURNS>gboolean                  </RETURNS>
GdkWindow               *window, GdkWaylandWindowExported callback, gpointer                 user_data, GDestroyNotify           destroy_func
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_unexport_handle</NAME>
<RETURNS>void                      </RETURNS>
GdkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_set_transient_for_exported</NAME>
<RETURNS>gboolean                  </RETURNS>
GdkWindow *window, char      *parent_handle_str
</FUNCTION>
<FUNCTION>
<NAME>gdk_wayland_window_announce_csd</NAME>
<RETURNS>void  </RETURNS>
GdkWindow *window
</FUNCTION>
<STRUCT>
<NAME>GdkWaylandWindow</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkWaylandWindowClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>translate_wm_button_layout_to_gtk</NAME>
<RETURNS>void  </RETURNS>
char *layout
</FUNCTION>
<STRUCT>
<NAME>MotifWmInfo</NAME>
typedef struct {
    unsigned long flags;
    unsigned long functions;
    unsigned long decorations;
    long input_mode;
    unsigned long status;
} MotifWmHints, MwmHints;

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

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

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

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

#define MWM_TEAROFF_WINDOW	(1L<<0)

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


/*
 * _MWM_INFO property
 */
typedef struct {
    long flags;
    Window wm_window;
} MotifWmInfo;
</STRUCT>
<TYPEDEF>
<NAME>MwmInfo</NAME>
typedef MotifWmInfo MwmInfo;
</TYPEDEF>
<MACRO>
<NAME>MWM_INFO_STARTUP_STANDARD</NAME>
#define MWM_INFO_STARTUP_STANDARD	(1L<<0)
</MACRO>
<MACRO>
<NAME>MWM_INFO_STARTUP_CUSTOM</NAME>
#define MWM_INFO_STARTUP_CUSTOM		(1L<<1)
</MACRO>
<STRUCT>
<NAME>PropMotifWmHints</NAME>
typedef struct {
    unsigned long flags;
    unsigned long functions;
    unsigned long decorations;
    long inputMode;
    unsigned long status;
} PropMotifWmHints;
</STRUCT>
<TYPEDEF>
<NAME>PropMwmHints</NAME>
typedef PropMotifWmHints PropMwmHints;
</TYPEDEF>
<MACRO>
<NAME>PROP_MOTIF_WM_HINTS_ELEMENTS</NAME>
#define PROP_MOTIF_WM_HINTS_ELEMENTS 5
</MACRO>
<MACRO>
<NAME>PROP_MWM_HINTS_ELEMENTS</NAME>
#define PROP_MWM_HINTS_ELEMENTS PROP_MOTIF_WM_HINTS_ELEMENTS
</MACRO>
<STRUCT>
<NAME>PropMotifWmInfo</NAME>
typedef struct {
    unsigned long flags;
    unsigned long wmWindow;
} PropMotifWmInfo;
</STRUCT>
<TYPEDEF>
<NAME>PropMwmInfo</NAME>
typedef PropMotifWmInfo PropMwmInfo;
</TYPEDEF>
<MACRO>
<NAME>PROP_MOTIF_WM_INFO_ELEMENTS</NAME>
#define PROP_MOTIF_WM_INFO_ELEMENTS 2
</MACRO>
<MACRO>
<NAME>PROP_MWM_INFO_ELEMENTS</NAME>
#define PROP_MWM_INFO_ELEMENTS PROP_MOTIF_WM_INFO_ELEMENTS
</MACRO>
<USER_FUNCTION>
<NAME>GdkSendXEventCallback</NAME>
<RETURNS>void </RETURNS>
Window   window,
				       gboolean success,
				       gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GdkRoundTripCallback</NAME>
<RETURNS>void </RETURNS>
GdkDisplay *display,
				       gpointer data,
				       gulong serial
</USER_FUNCTION>
<STRUCT>
<NAME>GdkChildInfoX11</NAME>
struct _GdkChildInfoX11
{
  Window window;
  gint x;
  gint y;
  gint width;
  gint height;
  guint is_mapped : 1;
  guint has_wm_state : 1;
  guint window_class : 2;
};
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_CLIPBOARD</NAME>
#define GDK_TYPE_X11_CLIPBOARD    (gdk_x11_clipboard_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_CLIPBOARD</NAME>
#define GDK_X11_CLIPBOARD(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_CLIPBOARD, GdkX11Clipboard))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_CLIPBOARD</NAME>
#define GDK_IS_X11_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_CLIPBOARD))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_clipboard_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_clipboard_new</NAME>
<RETURNS>GdkClipboard  *          </RETURNS>
GdkDisplay             *display, const gchar            *selection
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_clipboard_formats_to_targets</NAME>
<RETURNS>GSList  *                </RETURNS>
GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_clipboard_formats_to_atoms</NAME>
<RETURNS>Atom  *                  </RETURNS>
GdkDisplay             *display, gboolean                include_special, GdkContentFormats      *formats, gsize                  *n_atoms
</FUNCTION>
<STRUCT>
<NAME>GdkX11Clipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerCore</NAME>
struct _GdkX11DeviceManagerCore
{
  GObject parent_instance;
  GdkDisplay *display;
  GdkDevice *core_pointer;
  GdkDevice *core_keyboard;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerCoreClass</NAME>
struct _GdkX11DeviceManagerCoreClass
{
  GObjectClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11Display</NAME>
struct _GdkX11Display
{
  GdkDisplay parent_instance;
  Display *xdisplay;
  GdkX11Screen *screen;
  GList *screens;
  GList *toplevels;
  GdkX11DeviceManagerCore *device_manager;

  GSource *event_source;

  gint grab_count;

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

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

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

  GdkKeymap *keymap;
  guint      keymap_serial;

  gboolean have_xfixes;
  gint xfixes_event_base;

  gboolean have_xcomposite;
  gboolean have_xdamage;
  gint xdamage_event_base;

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

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

  /* drag and drop information */
  GdkDragContext *current_dest_drag;

  /* Mapping to/from virtual atoms */
  GHashTable *atom_from_virtual;
  GHashTable *atom_to_virtual;

  /* Session Management leader window see ICCCM */
  char *program_class;
  Window leader_window;
  GdkWindow *leader_gdk_window;
  gboolean leader_window_title_set;

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

  /* X ID hashtable */
  GHashTable *xid_ht;

  /* translation queue */
  GQueue *translate_queue;

  /* streams reading selections */
  GSList *streams;

  /* input GdkWindow list */
  GList *input_windows;

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

  GPtrArray *monitors;
  int primary_monitor;

  /* Startup notification */
  gchar *startup_notification_id;

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

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

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

  GSList *error_traps;

  gint wm_moveresize_button;

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

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

  guint server_time_is_monotonic_time : 1;

  guint have_glx : 1;

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

  gboolean              (* xevent)                              (GdkX11Display          *display,
                                                                 const XEvent           *event);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_display_get_max_request_size</NAME>
<RETURNS>gsize            </RETURNS>
GdkDisplay             *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_request_selection_notification</NAME>
<RETURNS>gboolean         </RETURNS>
GdkDisplay             *display, const char             *selection
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_event_source_new</NAME>
<RETURNS>GSource  * </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_event_source_add_translator</NAME>
<RETURNS>void       </RETURNS>
GdkEventSource  *source, GdkEventTranslator *translator
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_event_source_select_events</NAME>
<RETURNS>void       </RETURNS>
GdkEventSource *source, Window          window, GdkEventMask    event_mask, unsigned int    extra_x_mask
</FUNCTION>
<FUNCTION>
<NAME>gdk_event_source_xevent</NAME>
<RETURNS>gboolean   </RETURNS>
GdkX11Display  *x11_display, const XEvent   *xevent
</FUNCTION>
<STRUCT>
<NAME>GdkEventSource</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_EVENT_TRANSLATOR</NAME>
#define GDK_TYPE_EVENT_TRANSLATOR         (_gdk_x11_event_translator_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_EVENT_TRANSLATOR</NAME>
#define GDK_EVENT_TRANSLATOR(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_EVENT_TRANSLATOR, GdkEventTranslator))
</MACRO>
<MACRO>
<NAME>GDK_IS_EVENT_TRANSLATOR</NAME>
#define GDK_IS_EVENT_TRANSLATOR(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_EVENT_TRANSLATOR))
</MACRO>
<MACRO>
<NAME>GDK_EVENT_TRANSLATOR_GET_IFACE</NAME>
#define GDK_EVENT_TRANSLATOR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE  ((o), GDK_TYPE_EVENT_TRANSLATOR, GdkEventTranslatorIface))
</MACRO>
<STRUCT>
<NAME>GdkEventTranslatorIface</NAME>
struct _GdkEventTranslatorIface
{
  GTypeInterface iface;

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

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

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

  guint is_attached : 1;
  guint is_direct : 1;
  guint do_frame_sync : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContextClass</NAME>
struct _GdkX11GLContextClass
{
  GdkGLContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_screen_init_gl</NAME>
<RETURNS>gboolean         </RETURNS>
GdkX11Screen      *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_create_gl_context</NAME>
<RETURNS>GdkGLContext  *  </RETURNS>
GdkWindow         *window, gboolean           attached, GdkGLContext      *share, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_make_gl_context_current</NAME>
<RETURNS>gboolean         </RETURNS>
GdkDisplay        *display, GdkGLContext      *context
</FUNCTION>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
struct _GdkX11Monitor
{
  GdkMonitor parent;

  XID output;
  guint add     : 1;
  guint remove  : 1;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11MonitorClass</NAME>
struct _GdkX11MonitorClass {
  GdkMonitorClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_display_setup_window_visual</NAME>
<RETURNS>void           </RETURNS>
GdkDisplay     *display, gint            depth, Visual         *visual, Colormap        colormap, gboolean        rgba
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_window_depth</NAME>
<RETURNS>int            </RETURNS>
GdkX11Display  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_window_visual</NAME>
<RETURNS>Visual  *      </RETURNS>
GdkX11Display  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_window_colormap</NAME>
<RETURNS>Colormap       </RETURNS>
GdkX11Display  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_last_axis_value</NAME>
<RETURNS>gdouble   </RETURNS>
GdkX11DeviceXI2 *device, gint             n_axis
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_device_xi2_store_axes</NAME>
<RETURNS>void      </RETURNS>
GdkX11DeviceXI2 *device, gdouble         *axes, gint             n_axes
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_toplevel_windows</NAME>
<RETURNS>GList  *    </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_cache_get</NAME>
<RETURNS>GdkWindowCache  *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_cache_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, GdkEvent     *event, gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>gdk_window_cache_shape_filter</NAME>
<RETURNS>GdkFilterReturn</RETURNS>
const XEvent *xevent, GdkEvent     *event, gpointer      data
</FUNCTION>
<MACRO>
<NAME>GDK_SCREEN_DISPLAY</NAME>
#define GDK_SCREEN_DISPLAY(screen)    (GDK_X11_SCREEN (screen)->display)
</MACRO>
<MACRO>
<NAME>GDK_SCREEN_XROOTWIN</NAME>
#define GDK_SCREEN_XROOTWIN(screen)   (GDK_X11_SCREEN (screen)->xroot_window)
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_XROOTWIN</NAME>
#define GDK_DISPLAY_XROOTWIN(display) (GDK_SCREEN_XROOTWIN (GDK_X11_DISPLAY (display)->screen))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_SCREEN</NAME>
#define GDK_WINDOW_SCREEN(win)        (GDK_X11_DISPLAY (gdk_window_get_display (win))->screen)
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_DISPLAY</NAME>
#define GDK_WINDOW_DISPLAY(win)       (gdk_window_get_display (win))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_XROOTWIN</NAME>
#define GDK_WINDOW_XROOTWIN(win)      (GDK_X11_SCREEN (GDK_WINDOW_SCREEN (win))->xroot_window)
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IS_X11</NAME>
#define GDK_WINDOW_IS_X11(win)        (GDK_IS_WINDOW_IMPL_X11 ((win)->impl))
</MACRO>
<MACRO>
<NAME>GDK_DISPLAY_XDISPLAY</NAME>
#define GDK_DISPLAY_XDISPLAY(display) (GDK_X11_DISPLAY(display)->xdisplay)
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_XDISPLAY</NAME>
#define GDK_WINDOW_XDISPLAY(win)      (GDK_X11_SCREEN (GDK_WINDOW_SCREEN (win))->xdisplay)
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_XID</NAME>
#define GDK_WINDOW_XID(win)           (GDK_WINDOW_IMPL_X11(GDK_WINDOW (win)->impl)->xid)
</MACRO>
<MACRO>
<NAME>GDK_SCREEN_XDISPLAY</NAME>
#define GDK_SCREEN_XDISPLAY(screen)   (GDK_X11_SCREEN (screen)->xdisplay)
</MACRO>
<STRUCT>
<NAME>GdkWindowCache</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11Screen</NAME>
struct _GdkX11Screen
{
  GObject parent_instance;

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

  gint window_scale;
  gboolean fixed_window_scale;

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

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

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

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

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

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

  void (* window_manager_changed) (GdkX11Screen *x11_screen);
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_screen_get_work_area</NAME>
<RETURNS>void  </RETURNS>
GdkX11Screen *screen, GdkRectangle *area
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_setting</NAME>
<RETURNS>gboolean  </RETURNS>
GdkX11Screen *screen, const char   *name, GValue       *value
</FUNCTION>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_SELECTION_INPUT_STREAM</NAME>
#define GDK_TYPE_X11_SELECTION_INPUT_STREAM         (gdk_x11_selection_input_stream_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_INPUT_STREAM</NAME>
#define GDK_X11_SELECTION_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_SELECTION_INPUT_STREAM, GdkX11SelectionInputStream))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_INPUT_STREAM_CLASS</NAME>
#define GDK_X11_SELECTION_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GDK_TYPE_X11_SELECTION_INPUT_STREAM, GdkX11SelectionInputStreamClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_INPUT_STREAM</NAME>
#define GDK_IS_X11_SELECTION_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_SELECTION_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_INPUT_STREAM_CLASS</NAME>
#define GDK_IS_X11_SELECTION_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GDK_TYPE_X11_SELECTION_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_INPUT_STREAM_GET_CLASS</NAME>
#define GDK_X11_SELECTION_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_SELECTION_INPUT_STREAM, GdkX11SelectionInputStreamClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11SelectionInputStream</NAME>
typedef struct GdkX11SelectionInputStream         GdkX11SelectionInputStream;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkX11SelectionInputStreamClass</NAME>
typedef struct GdkX11SelectionInputStreamClass    GdkX11SelectionInputStreamClass;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_selection_input_stream_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_input_stream_new_async</NAME>
<RETURNS>void            </RETURNS>
GdkDisplay                 *display, const char                 *selection, const char                 *target, guint32                     timestamp, int                         io_priority, GCancellable               *cancellable, GAsyncReadyCallback         callback, gpointer                    user_data
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_input_stream_new_finish</NAME>
<RETURNS>GInputStream  * </RETURNS>
GAsyncResult               *result, const char                **type, int                        *format, GError                    **error
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SELECTION_OUTPUT_STREAM</NAME>
#define GDK_TYPE_X11_SELECTION_OUTPUT_STREAM         (gdk_x11_selection_output_stream_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_OUTPUT_STREAM</NAME>
#define GDK_X11_SELECTION_OUTPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM, GdkX11SelectionOutputStream))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_OUTPUT_STREAM_CLASS</NAME>
#define GDK_X11_SELECTION_OUTPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM, GdkX11SelectionOutputStreamClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_OUTPUT_STREAM</NAME>
#define GDK_IS_X11_SELECTION_OUTPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SELECTION_OUTPUT_STREAM_CLASS</NAME>
#define GDK_IS_X11_SELECTION_OUTPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM))
</MACRO>
<MACRO>
<NAME>GDK_X11_SELECTION_OUTPUT_STREAM_GET_CLASS</NAME>
#define GDK_X11_SELECTION_OUTPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_SELECTION_OUTPUT_STREAM, GdkX11SelectionOutputStreamClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11SelectionOutputStream</NAME>
typedef struct GdkX11SelectionOutputStream         GdkX11SelectionOutputStream;
</TYPEDEF>
<TYPEDEF>
<NAME>GdkX11SelectionOutputStreamClass</NAME>
typedef struct GdkX11SelectionOutputStreamClass    GdkX11SelectionOutputStreamClass;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GdkX11SelectionOutputHandler</NAME>
<RETURNS>void </RETURNS>
GOutputStream *stream, const char *mime_type, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_output_stream_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_selection_output_streams_create</NAME>
<RETURNS>void             </RETURNS>
GdkDisplay             *display, GdkContentFormats      *formats, Window                  requestor, Atom                    selection, Atom                    target, Atom                    property, gulong                  timestamp, GdkX11SelectionOutputHandler handler, gpointer                user_data
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_TEXT_LIST_CONVERTER</NAME>
#define GDK_TYPE_X11_TEXT_LIST_CONVERTER         (gdk_x11_text_list_converter_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_TEXT_LIST_CONVERTER</NAME>
#define GDK_X11_TEXT_LIST_CONVERTER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_TEXT_LIST_CONVERTER, GdkX11TextListConverter))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_TEXT_LIST_CONVERTER</NAME>
#define GDK_IS_X11_TEXT_LIST_CONVERTER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_TEXT_LIST_CONVERTER))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_text_list_converter_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_text_list_converter_to_utf8_new</NAME>
<RETURNS>GConverter  *       </RETURNS>
GdkDisplay     *display, const char     *encoding, int             format
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_text_list_converter_from_utf8_new</NAME>
<RETURNS>GConverter  *       </RETURNS>
GdkDisplay     *display, const char     *encoding, int             format
</FUNCTION>
<STRUCT>
<NAME>GdkX11TextListConverter</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_VISUAL</NAME>
#define GDK_TYPE_X11_VISUAL              (gdk_x11_visual_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_VISUAL</NAME>
#define GDK_X11_VISUAL(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_VISUAL, GdkX11Visual))
</MACRO>
<MACRO>
<NAME>GDK_X11_VISUAL_CLASS</NAME>
#define GDK_X11_VISUAL_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_VISUAL, GdkX11VisualClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VISUAL</NAME>
#define GDK_IS_X11_VISUAL(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_VISUAL))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VISUAL_CLASS</NAME>
#define GDK_IS_X11_VISUAL_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_VISUAL))
</MACRO>
<MACRO>
<NAME>GDK_X11_VISUAL_GET_CLASS</NAME>
#define GDK_X11_VISUAL_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_VISUAL, GdkX11VisualClass))
</MACRO>
<ENUM>
<NAME>GdkVisualType</NAME>
typedef enum
{
  GDK_VISUAL_STATIC_GRAY,
  GDK_VISUAL_GRAYSCALE,
  GDK_VISUAL_STATIC_COLOR,
  GDK_VISUAL_PSEUDO_COLOR,
  GDK_VISUAL_TRUE_COLOR,
  GDK_VISUAL_DIRECT_COLOR
} GdkVisualType;
</ENUM>
<STRUCT>
<NAME>GdkX11Visual</NAME>
struct _GdkX11Visual
{
  GObject parent_instance;

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

  guint32 red_mask;
  guint32 green_mask;
  guint32 blue_mask;

  Visual *xvisual;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_visual_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_visual_get_xvisual</NAME>
<RETURNS>Visual  * </RETURNS>
GdkX11Visual *visual
</FUNCTION>
<MACRO>
<NAME>GDK_VISUAL_XVISUAL</NAME>
#define GDK_VISUAL_XVISUAL(visual)    (gdk_x11_visual_get_xvisual (visual))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_screen_lookup_visual</NAME>
<RETURNS>GdkX11Visual * </RETURNS>
GdkX11Screen *screen, VisualID      xvisualid
</FUNCTION>
<STRUCT>
<NAME>GdkX11VisualClass</NAME>
</STRUCT>
<MACRO>
<NAME>VK_USE_PLATFORM_XLIB_KHR</NAME>
#define VK_USE_PLATFORM_XLIB_KHR
</MACRO>
<MACRO>
<NAME>GDK_TYPE_X11_VULKAN_CONTEXT</NAME>
#define GDK_TYPE_X11_VULKAN_CONTEXT		(gdk_x11_vulkan_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT</NAME>
#define GDK_X11_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContext))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VULKAN_CONTEXT</NAME>
#define GDK_IS_X11_VULKAN_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_X11_VULKAN_CONTEXT_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_VULKAN_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_VULKAN_CONTEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_VULKAN_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_VULKAN_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_VULKAN_CONTEXT_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_VULKAN_CONTEXT, GdkX11VulkanContextClass))
</MACRO>
<STRUCT>
<NAME>GdkX11VulkanContext</NAME>
struct _GdkX11VulkanContext
{
  GdkVulkanContext parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GdkX11VulkanContextClass</NAME>
struct _GdkX11VulkanContextClass
{
  GdkVulkanContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_vulkan_context_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_WINDOW_IMPL_X11</NAME>
#define GDK_TYPE_WINDOW_IMPL_X11              (gdk_window_impl_x11_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IMPL_X11</NAME>
#define GDK_WINDOW_IMPL_X11(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IMPL_X11_CLASS</NAME>
#define GDK_WINDOW_IMPL_X11_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_WINDOW_IMPL_X11</NAME>
#define GDK_IS_WINDOW_IMPL_X11(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WINDOW_IMPL_X11))
</MACRO>
<MACRO>
<NAME>GDK_IS_WINDOW_IMPL_X11_CLASS</NAME>
#define GDK_IS_WINDOW_IMPL_X11_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WINDOW_IMPL_X11))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_IMPL_X11_GET_CLASS</NAME>
#define GDK_WINDOW_IMPL_X11_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WINDOW_IMPL_X11, GdkWindowImplX11Class))
</MACRO>
<STRUCT>
<NAME>GdkWindowImplX11</NAME>
struct _GdkWindowImplX11
{
  GdkWindowImpl parent_instance;

  GdkWindow *wrapper;

  Window xid;

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

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

  gint window_scale;

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

  cairo_surface_t *cairo_surface;

#if defined (HAVE_XCOMPOSITE) && defined(HAVE_XDAMAGE) && defined (HAVE_XFIXES)
  Damage damage;
#endif
};
</STRUCT>
<STRUCT>
<NAME>GdkWindowImplX11Class</NAME>
struct _GdkWindowImplX11Class 
{
  GdkWindowImplClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GdkToplevelX11</NAME>
struct _GdkToplevelX11
{

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

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

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

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

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

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

  guint is_leader : 1;

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

  guint in_frame : 1;

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

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

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

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

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

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

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

  /* After a _NET_WM_FRAME_DRAWN message, this is the soonest that we think
   * frame after will be presented */
  gint64 throttled_presentation_time;
#endif
};
</STRUCT>
<FUNCTION>
<NAME>gdk_window_impl_x11_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkXPositionInfo</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_CORE</NAME>
#define GDK_TYPE_X11_DEVICE_CORE         (gdk_x11_device_core_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_CORE</NAME>
#define GDK_X11_DEVICE_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_CORE, GdkX11DeviceCore))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_CORE_CLASS</NAME>
#define GDK_X11_DEVICE_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_CORE, GdkX11DeviceCoreClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_CORE</NAME>
#define GDK_IS_X11_DEVICE_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_CORE))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_CORE_CLASS</NAME>
#define GDK_IS_X11_DEVICE_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_CORE))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_CORE_GET_CLASS</NAME>
#define GDK_X11_DEVICE_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_CORE, GdkX11DeviceCoreClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_core_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceCore</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceCoreClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_XI2</NAME>
#define GDK_TYPE_X11_DEVICE_XI2         (gdk_x11_device_xi2_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2</NAME>
#define GDK_X11_DEVICE_XI2(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2</NAME>
#define GDK_IS_X11_DEVICE_XI2(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_XI2_CLASS</NAME>
#define GDK_IS_X11_DEVICE_XI2_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_XI2))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_XI2_GET_CLASS</NAME>
#define GDK_X11_DEVICE_XI2_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_XI2, GdkX11DeviceXI2Class))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_xi2_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceXI2</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceXI2Class</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_device_get_id</NAME>
<RETURNS>gint   </RETURNS>
GdkDevice *device
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_MANAGER_CORE</NAME>
#define GDK_TYPE_X11_DEVICE_MANAGER_CORE         (gdk_x11_device_manager_core_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_CORE</NAME>
#define GDK_X11_DEVICE_MANAGER_CORE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_MANAGER_CORE, GdkX11DeviceManagerCore))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_CORE_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_CORE_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_MANAGER_CORE, GdkX11DeviceManagerCoreClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_CORE</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_CORE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_MANAGER_CORE))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_CORE_CLASS</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_CORE_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_MANAGER_CORE))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_CORE_GET_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_CORE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_MANAGER_CORE, GdkX11DeviceManagerCoreClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_manager_core_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceManagerCore</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerCoreClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DEVICE_MANAGER_XI</NAME>
#define GDK_TYPE_X11_DEVICE_MANAGER_XI         (gdk_x11_device_manager_xi_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI</NAME>
#define GDK_X11_DEVICE_MANAGER_XI(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI, GdkX11DeviceManagerXI))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI, GdkX11DeviceManagerXIClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DEVICE_MANAGER_XI_CLASS</NAME>
#define GDK_IS_X11_DEVICE_MANAGER_XI_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE ((c), GDK_TYPE_X11_DEVICE_MANAGER_XI))
</MACRO>
<MACRO>
<NAME>GDK_X11_DEVICE_MANAGER_XI_GET_CLASS</NAME>
#define GDK_X11_DEVICE_MANAGER_XI_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GDK_TYPE_X11_DEVICE_MANAGER_XI, GdkX11DeviceManagerXIClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_device_manager_xi_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DeviceManagerXI</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DeviceManagerXIClass</NAME>
</STRUCT>
<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>
GdkX11DeviceManagerCore *device_manager, gint                     device_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_disable_multidevice</NAME>
<RETURNS>void          </RETURNS>
void
</FUNCTION>
<TYPEDEF>
<NAME>GdkX11Display</NAME>
typedef GdkDisplay GdkX11Display;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_DISPLAY</NAME>
#define GDK_TYPE_X11_DISPLAY              (gdk_x11_display_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY</NAME>
#define GDK_X11_DISPLAY(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DISPLAY, GdkX11Display))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_CLASS</NAME>
#define GDK_X11_DISPLAY_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY</NAME>
#define GDK_IS_X11_DISPLAY(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DISPLAY_CLASS</NAME>
#define GDK_IS_X11_DISPLAY_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DISPLAY))
</MACRO>
<MACRO>
<NAME>GDK_X11_DISPLAY_GET_CLASS</NAME>
#define GDK_X11_DISPLAY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DISPLAY, GdkX11DisplayClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_open</NAME>
<RETURNS>GdkDisplay  *  </RETURNS>
const char  *display_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xdisplay</NAME>
<RETURNS>Display  *     </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xscreen</NAME>
<RETURNS>Screen  *      </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xrootwindow</NAME>
<RETURNS>Window         </RETURNS>
GdkDisplay  *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_xcursor</NAME>
<RETURNS>Cursor         </RETURNS>
GdkDisplay  *display, GdkCursor   *cursor
</FUNCTION>
<MACRO>
<NAME>GDK_DISPLAY_XDISPLAY</NAME>
#define GDK_DISPLAY_XDISPLAY(display) (gdk_x11_display_get_xdisplay (display))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_display_get_user_time</NAME>
<RETURNS>guint32        </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_startup_notification_id</NAME>
<RETURNS>const gchar  * </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_startup_notification_id</NAME>
<RETURNS>void           </RETURNS>
GdkDisplay  *display, const gchar *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_program_class</NAME>
<RETURNS>void           </RETURNS>
GdkDisplay  *display, const char  *program_class
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_set_cursor_theme</NAME>
<RETURNS>void           </RETURNS>
GdkDisplay  *display, const gchar *theme, const gint   size
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_broadcast_startup_message</NAME>
<RETURNS>void  </RETURNS>
GdkDisplay *display, const char *message_type, ...
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_lookup_xdisplay</NAME>
<RETURNS>GdkDisplay    *</RETURNS>
Display *xdisplay
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_screen</NAME>
<RETURNS>GdkX11Screen  *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_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_window_scale</NAME>
<RETURNS>void         </RETURNS>
GdkDisplay *display, gint scale
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_push</NAME>
<RETURNS>void                            </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop</NAME>
<RETURNS>gint  </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_error_trap_pop_ignored</NAME>
<RETURNS>void                            </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_register_standard_event_type</NAME>
<RETURNS>void         </RETURNS>
GdkDisplay *display, gint        event_base, gint        n_events
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_set_sm_client_id</NAME>
<RETURNS>void         </RETURNS>
const gchar *sm_client_id
</FUNCTION>
<STRUCT>
<NAME>GdkX11Display</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DisplayClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_DRAG_CONTEXT</NAME>
#define GDK_TYPE_X11_DRAG_CONTEXT              (gdk_x11_drag_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_CONTEXT</NAME>
#define GDK_X11_DRAG_CONTEXT(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DRAG_CONTEXT, GdkX11DragContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_CONTEXT_CLASS</NAME>
#define GDK_X11_DRAG_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DRAG_CONTEXT, GdkX11DragContextClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG_CONTEXT</NAME>
#define GDK_IS_X11_DRAG_CONTEXT(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DRAG_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_DRAG_CONTEXT_CLASS</NAME>
#define GDK_IS_X11_DRAG_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DRAG_CONTEXT))
</MACRO>
<MACRO>
<NAME>GDK_X11_DRAG_CONTEXT_GET_CLASS</NAME>
#define GDK_X11_DRAG_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DRAG_CONTEXT, GdkX11DragContextClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11DragContext</NAME>
typedef GdkDragContext GdkX11DragContext;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_drag_context_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GdkX11DragContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11DragContextClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_GL_CONTEXT</NAME>
#define GDK_TYPE_X11_GL_CONTEXT		(gdk_x11_gl_context_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_GL_CONTEXT</NAME>
#define GDK_X11_GL_CONTEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GDK_TYPE_X11_GL_CONTEXT, GdkX11GLContext))
</MACRO>
<MACRO>
<NAME>GDK_X11_IS_GL_CONTEXT</NAME>
#define GDK_X11_IS_GL_CONTEXT(obj)	(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GDK_TYPE_X11_GL_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_gl_context_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_get_glx_version</NAME>
<RETURNS>gboolean         </RETURNS>
GdkDisplay *display, gint       *major, gint       *minor
</FUNCTION>
<STRUCT>
<NAME>GdkX11GLContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11GLContextClass</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GdkX11Keymap</NAME>
typedef GdkKeymap GdkX11Keymap;
</TYPEDEF>
<MACRO>
<NAME>GDK_TYPE_X11_KEYMAP</NAME>
#define GDK_TYPE_X11_KEYMAP              (gdk_x11_keymap_get_type())
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP</NAME>
#define GDK_X11_KEYMAP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_KEYMAP, GdkX11Keymap))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_CLASS</NAME>
#define GDK_X11_KEYMAP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP</NAME>
#define GDK_IS_X11_KEYMAP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_KEYMAP_CLASS</NAME>
#define GDK_IS_X11_KEYMAP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_KEYMAP))
</MACRO>
<MACRO>
<NAME>GDK_X11_KEYMAP_GET_CLASS</NAME>
#define GDK_X11_KEYMAP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_KEYMAP, GdkX11KeymapClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_keymap_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_keymap_get_group_for_state</NAME>
<RETURNS>gint  </RETURNS>
GdkKeymap *keymap, guint      state
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_keymap_key_is_modifier</NAME>
<RETURNS>gboolean  </RETURNS>
GdkKeymap *keymap, guint      keycode
</FUNCTION>
<STRUCT>
<NAME>GdkX11Keymap</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11KeymapClass</NAME>
</STRUCT>
<MACRO>
<NAME>GDK_TYPE_X11_MONITOR</NAME>
#define GDK_TYPE_X11_MONITOR           (gdk_x11_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_MONITOR</NAME>
#define GDK_X11_MONITOR(object)        (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_MONITOR, GdkX11Monitor))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_MONITOR</NAME>
#define GDK_IS_X11_MONITOR(object)     (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_MONITOR))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_monitor_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_monitor_get_output</NAME>
<RETURNS>XID                </RETURNS>
GdkMonitor *monitor
</FUNCTION>
<STRUCT>
<NAME>GdkX11Monitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11MonitorClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_atom_to_xatom_for_display</NAME>
<RETURNS>Atom                   </RETURNS>
GdkDisplay  *display, GdkAtom      atom
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_xatom_to_atom_for_display</NAME>
<RETURNS>GdkAtom                </RETURNS>
GdkDisplay  *display, Atom         xatom
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_get_xatom_by_name_for_display</NAME>
<RETURNS>Atom                   </RETURNS>
GdkDisplay  *display, const gchar *atom_name
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_get_xatom_name_for_display</NAME>
<RETURNS>const gchar  *         </RETURNS>
GdkDisplay  *display, Atom         xatom
</FUNCTION>
<MACRO>
<NAME>GDK_TYPE_X11_SCREEN</NAME>
#define GDK_TYPE_X11_SCREEN              (gdk_x11_screen_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN</NAME>
#define GDK_X11_SCREEN(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_SCREEN, GdkX11Screen))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_CLASS</NAME>
#define GDK_X11_SCREEN_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN</NAME>
#define GDK_IS_X11_SCREEN(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_SCREEN_CLASS</NAME>
#define GDK_IS_X11_SCREEN_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_SCREEN))
</MACRO>
<MACRO>
<NAME>GDK_X11_SCREEN_GET_CLASS</NAME>
#define GDK_X11_SCREEN_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_SCREEN, GdkX11ScreenClass))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_screen_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_xscreen</NAME>
<RETURNS>Screen  * </RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_screen_number</NAME>
<RETURNS>int       </RETURNS>
GdkX11Screen   *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_window_manager_name</NAME>
<RETURNS>const char * </RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_supports_net_wm_hint</NAME>
<RETURNS>gboolean  </RETURNS>
GdkX11Screen *screen, GdkAtom       property
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_monitor_output</NAME>
<RETURNS>XID       </RETURNS>
GdkX11Screen *screen, gint          monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_number_of_desktops</NAME>
<RETURNS>guint32   </RETURNS>
GdkX11Screen *screen
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_screen_get_current_desktop</NAME>
<RETURNS>guint32   </RETURNS>
GdkX11Screen *screen
</FUNCTION>
<STRUCT>
<NAME>GdkX11Screen</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11ScreenClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_x11_display_text_property_to_text_list</NAME>
<RETURNS>gint      </RETURNS>
GdkDisplay   *display, GdkAtom       encoding, gint          format, const guchar *text, gint          length, gchar      ***list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_text_list</NAME>
<RETURNS>void      </RETURNS>
gchar       **list
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_string_to_compound_text</NAME>
<RETURNS>gint      </RETURNS>
GdkDisplay   *display, const gchar  *str, GdkAtom      *encoding, gint         *format, guchar      **ctext, gint         *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_display_utf8_to_compound_text</NAME>
<RETURNS>gboolean  </RETURNS>
GdkDisplay   *display, const gchar  *str, GdkAtom      *encoding, gint         *format, guchar      **ctext, gint         *length
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_free_compound_text</NAME>
<RETURNS>void      </RETURNS>
guchar       *ctext
</FUNCTION>
<MACRO>
<NAME>GDK_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_TYPE_X11_WINDOW</NAME>
#define GDK_TYPE_X11_WINDOW              (gdk_x11_window_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_X11_WINDOW</NAME>
#define GDK_X11_WINDOW(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_WINDOW, GdkX11Window))
</MACRO>
<MACRO>
<NAME>GDK_X11_WINDOW_CLASS</NAME>
#define GDK_X11_WINDOW_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_WINDOW, GdkX11WindowClass))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_WINDOW</NAME>
#define GDK_IS_X11_WINDOW(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_WINDOW))
</MACRO>
<MACRO>
<NAME>GDK_IS_X11_WINDOW_CLASS</NAME>
#define GDK_IS_X11_WINDOW_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_WINDOW))
</MACRO>
<MACRO>
<NAME>GDK_X11_WINDOW_GET_CLASS</NAME>
#define GDK_X11_WINDOW_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_WINDOW, GdkX11WindowClass))
</MACRO>
<TYPEDEF>
<NAME>GdkX11Window</NAME>
typedef GdkWindow GdkX11Window;
</TYPEDEF>
<FUNCTION>
<NAME>gdk_x11_window_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_get_xid</NAME>
<RETURNS>Window    </RETURNS>
GdkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_set_user_time</NAME>
<RETURNS>void      </RETURNS>
GdkWindow   *window, guint32      timestamp
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_set_utf8_property</NAME>
<RETURNS>void      </RETURNS>
GdkWindow *window, const gchar *name, const gchar *value
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_set_theme_variant</NAME>
<RETURNS>void      </RETURNS>
GdkWindow   *window, const char  *variant
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_set_frame_extents</NAME>
<DEPRECATED/>
<RETURNS>void      </RETURNS>
GdkWindow *window, int        left, int        right, int        top, int        bottom
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_move_to_current_desktop</NAME>
<RETURNS>void      </RETURNS>
GdkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_get_desktop</NAME>
<RETURNS>guint32   </RETURNS>
GdkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_move_to_desktop</NAME>
<RETURNS>void      </RETURNS>
GdkWindow   *window, guint32      desktop
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_set_frame_sync_enabled</NAME>
<RETURNS>void      </RETURNS>
GdkWindow *window, gboolean   frame_sync_enabled
</FUNCTION>
<MACRO>
<NAME>GDK_WINDOW_XDISPLAY</NAME>
#define GDK_WINDOW_XDISPLAY(win)      (GDK_DISPLAY_XDISPLAY (gdk_window_get_display (win)))
</MACRO>
<MACRO>
<NAME>GDK_WINDOW_XID</NAME>
#define GDK_WINDOW_XID(win)           (gdk_x11_window_get_xid (win))
</MACRO>
<FUNCTION>
<NAME>gdk_x11_get_server_time</NAME>
<RETURNS>guint32        </RETURNS>
GdkWindow       *window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_foreign_new_for_display</NAME>
<RETURNS>GdkWindow   *</RETURNS>
GdkDisplay *display, Window      window
</FUNCTION>
<FUNCTION>
<NAME>gdk_x11_window_lookup_for_display</NAME>
<RETURNS>GdkWindow   *</RETURNS>
GdkDisplay *display, Window      window
</FUNCTION>
<STRUCT>
<NAME>GdkX11Window</NAME>
</STRUCT>
<STRUCT>
<NAME>GdkX11WindowClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gdk_xsettings_root_window_filter</NAME>
<RETURNS>GdkFilterReturn  </RETURNS>
const XEvent *xevent, GdkEvent     *event, gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>gdk_xsettings_manager_window_filter</NAME>
<RETURNS>GdkFilterReturn  </RETURNS>
const XEvent *xevent, GdkEvent     *event, gpointer      data
</FUNCTION>
<MACRO>
<NAME>GDK_WINDOWING_X11</NAME>
#define GDK_WINDOWING_X11
</MACRO>
<MACRO>
<NAME>GDK_WINDOWING_BROADWAY</NAME>
#define GDK_WINDOWING_BROADWAY
</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_INPUT_MODE</NAME>
#define GDK_TYPE_INPUT_MODE (gdk_input_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TYPE</NAME>
#define GDK_TYPE_DEVICE_TYPE (gdk_device_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_PAD_FEATURE</NAME>
#define GDK_TYPE_DEVICE_PAD_FEATURE (gdk_device_pad_feature_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DEVICE_TOOL_TYPE</NAME>
#define GDK_TYPE_DEVICE_TOOL_TYPE (gdk_device_tool_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_DRAG_ACTION</NAME>
#define GDK_TYPE_DRAG_ACTION (gdk_drag_action_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_FILTER_RETURN</NAME>
#define GDK_TYPE_FILTER_RETURN (gdk_filter_return_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_TYPE</NAME>
#define GDK_TYPE_EVENT_TYPE (gdk_event_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_TOUCHPAD_GESTURE_PHASE</NAME>
#define GDK_TYPE_TOUCHPAD_GESTURE_PHASE (gdk_touchpad_gesture_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SCROLL_DIRECTION</NAME>
#define GDK_TYPE_SCROLL_DIRECTION (gdk_scroll_direction_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_NOTIFY_TYPE</NAME>
#define GDK_TYPE_NOTIFY_TYPE (gdk_notify_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_CROSSING_MODE</NAME>
#define GDK_TYPE_CROSSING_MODE (gdk_crossing_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_FRAME_CLOCK_PHASE</NAME>
#define GDK_TYPE_FRAME_CLOCK_PHASE (gdk_frame_clock_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_SUBPIXEL_LAYOUT</NAME>
#define GDK_TYPE_SUBPIXEL_LAYOUT (gdk_subpixel_layout_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_BYTE_ORDER</NAME>
#define GDK_TYPE_BYTE_ORDER (gdk_byte_order_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MODIFIER_TYPE</NAME>
#define GDK_TYPE_MODIFIER_TYPE (gdk_modifier_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_MODIFIER_INTENT</NAME>
#define GDK_TYPE_MODIFIER_INTENT (gdk_modifier_intent_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_STATUS</NAME>
#define GDK_TYPE_STATUS (gdk_status_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAB_STATUS</NAME>
#define GDK_TYPE_GRAB_STATUS (gdk_grab_status_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAB_OWNERSHIP</NAME>
#define GDK_TYPE_GRAB_OWNERSHIP (gdk_grab_ownership_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_EVENT_MASK</NAME>
#define GDK_TYPE_EVENT_MASK (gdk_event_mask_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GL_ERROR</NAME>
#define GDK_TYPE_GL_ERROR (gdk_gl_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_VULKAN_ERROR</NAME>
#define GDK_TYPE_VULKAN_ERROR (gdk_vulkan_error_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WINDOW_TYPE_HINT</NAME>
#define GDK_TYPE_WINDOW_TYPE_HINT (gdk_window_type_hint_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_USE</NAME>
#define GDK_TYPE_AXIS_USE (gdk_axis_use_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_AXIS_FLAGS</NAME>
#define GDK_TYPE_AXIS_FLAGS (gdk_axis_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WINDOW_TYPE</NAME>
#define GDK_TYPE_WINDOW_TYPE (gdk_window_type_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WINDOW_HINTS</NAME>
#define GDK_TYPE_WINDOW_HINTS (gdk_window_hints_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WM_DECORATION</NAME>
#define GDK_TYPE_WM_DECORATION (gdk_wm_decoration_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_WM_FUNCTION</NAME>
#define GDK_TYPE_WM_FUNCTION (gdk_wm_function_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_TYPE_GRAVITY</NAME>
#define GDK_TYPE_GRAVITY (gdk_gravity_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_WINDOW_EDGE</NAME>
#define GDK_TYPE_WINDOW_EDGE (gdk_window_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_WINDOW_STATE</NAME>
#define GDK_TYPE_WINDOW_STATE (gdk_window_state_get_type ())
</MACRO>
<MACRO>
<NAME>GDK_MAJOR_VERSION</NAME>
#define GDK_MAJOR_VERSION (3)
</MACRO>
<MACRO>
<NAME>GDK_MINOR_VERSION</NAME>
#define GDK_MINOR_VERSION (93)
</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_3_0</NAME>
#define GDK_VERSION_3_0         (G_ENCODE_VERSION (3, 0))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_2</NAME>
#define GDK_VERSION_3_2         (G_ENCODE_VERSION (3, 2))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_4</NAME>
#define GDK_VERSION_3_4         (G_ENCODE_VERSION (3, 4))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_6</NAME>
#define GDK_VERSION_3_6         (G_ENCODE_VERSION (3, 6))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_8</NAME>
#define GDK_VERSION_3_8         (G_ENCODE_VERSION (3, 8))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_10</NAME>
#define GDK_VERSION_3_10        (G_ENCODE_VERSION (3, 10))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_12</NAME>
#define GDK_VERSION_3_12        (G_ENCODE_VERSION (3, 12))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_14</NAME>
#define GDK_VERSION_3_14        (G_ENCODE_VERSION (3, 14))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_16</NAME>
#define GDK_VERSION_3_16        (G_ENCODE_VERSION (3, 16))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_18</NAME>
#define GDK_VERSION_3_18        (G_ENCODE_VERSION (3, 18))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_20</NAME>
#define GDK_VERSION_3_20        (G_ENCODE_VERSION (3, 20))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_22</NAME>
#define GDK_VERSION_3_22        (G_ENCODE_VERSION (3, 22))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_90</NAME>
#define GDK_VERSION_3_90        (G_ENCODE_VERSION (3, 90))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_92</NAME>
#define GDK_VERSION_3_92        (G_ENCODE_VERSION (3, 92))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_3_94</NAME>
#define GDK_VERSION_3_94        (G_ENCODE_VERSION (3, 94))
</MACRO>
<MACRO>
<NAME>GDK_VERSION_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_DEPRECATED_IN_3_0</NAME>
# define GDK_DEPRECATED_IN_3_0                GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_0_FOR</NAME>
# define GDK_DEPRECATED_IN_3_0_FOR(f)         GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_0</NAME>
# define GDK_AVAILABLE_IN_3_0                 GDK_UNAVAILABLE(3, 0)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_2</NAME>
# define GDK_DEPRECATED_IN_3_2                GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_2_FOR</NAME>
# define GDK_DEPRECATED_IN_3_2_FOR(f)         GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_2</NAME>
# define GDK_AVAILABLE_IN_3_2                 GDK_UNAVAILABLE(3, 2)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_4</NAME>
# define GDK_DEPRECATED_IN_3_4                GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_4_FOR</NAME>
# define GDK_DEPRECATED_IN_3_4_FOR(f)         GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_4</NAME>
# define GDK_AVAILABLE_IN_3_4                 GDK_UNAVAILABLE(3, 4)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_6</NAME>
# define GDK_DEPRECATED_IN_3_6                GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_6_FOR</NAME>
# define GDK_DEPRECATED_IN_3_6_FOR(f)         GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_6</NAME>
# define GDK_AVAILABLE_IN_3_6                 GDK_UNAVAILABLE(3, 6)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_8</NAME>
# define GDK_DEPRECATED_IN_3_8                GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_8_FOR</NAME>
# define GDK_DEPRECATED_IN_3_8_FOR(f)         GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_8</NAME>
# define GDK_AVAILABLE_IN_3_8                 GDK_UNAVAILABLE(3, 8)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_10</NAME>
# define GDK_DEPRECATED_IN_3_10               GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_10_FOR</NAME>
# define GDK_DEPRECATED_IN_3_10_FOR(f)        GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_10</NAME>
# define GDK_AVAILABLE_IN_3_10                GDK_UNAVAILABLE(3, 10)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_12</NAME>
# define GDK_DEPRECATED_IN_3_12               GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_12_FOR</NAME>
# define GDK_DEPRECATED_IN_3_12_FOR(f)        GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_12</NAME>
# define GDK_AVAILABLE_IN_3_12                GDK_UNAVAILABLE(3, 12)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_14</NAME>
# define GDK_DEPRECATED_IN_3_14               GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_14_FOR</NAME>
# define GDK_DEPRECATED_IN_3_14_FOR(f)        GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_14</NAME>
# define GDK_AVAILABLE_IN_3_14                GDK_UNAVAILABLE(3, 14)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_16</NAME>
# define GDK_DEPRECATED_IN_3_16               GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_16_FOR</NAME>
# define GDK_DEPRECATED_IN_3_16_FOR(f)        GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_16</NAME>
# define GDK_AVAILABLE_IN_3_16                GDK_UNAVAILABLE(3, 16)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_18</NAME>
# define GDK_DEPRECATED_IN_3_18               GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_18_FOR</NAME>
# define GDK_DEPRECATED_IN_3_18_FOR(f)        GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_18</NAME>
# define GDK_AVAILABLE_IN_3_18                GDK_UNAVAILABLE(3, 18)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_20</NAME>
# define GDK_DEPRECATED_IN_3_20               GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_20_FOR</NAME>
# define GDK_DEPRECATED_IN_3_20_FOR(f)        GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_20</NAME>
# define GDK_AVAILABLE_IN_3_20                GDK_UNAVAILABLE(3, 20)
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_22</NAME>
# define GDK_DEPRECATED_IN_3_22               GDK_DEPRECATED
</MACRO>
<MACRO>
<NAME>GDK_DEPRECATED_IN_3_22_FOR</NAME>
# define GDK_DEPRECATED_IN_3_22_FOR(f)        GDK_DEPRECATED_FOR(f)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_22</NAME>
# define GDK_AVAILABLE_IN_3_22                GDK_UNAVAILABLE(3, 22)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_90</NAME>
# define GDK_AVAILABLE_IN_3_90                GDK_UNAVAILABLE(3, 90)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_92</NAME>
# define GDK_AVAILABLE_IN_3_92                GDK_UNAVAILABLE(3, 92)
</MACRO>
<MACRO>
<NAME>GDK_AVAILABLE_IN_3_94</NAME>
# define GDK_AVAILABLE_IN_3_94                GDK_UNAVAILABLE(3, 94)
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY 2
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_CREATE_SOURCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_GET_DEVICE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_MANAGER_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_create_source</NAME>
<RETURNS>struct gtk_primary_selection_source  *</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_get_device</NAME>
<RETURNS>struct gtk_primary_selection_device  *</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager, struct wl_seat *seat
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_manager_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device_manager *gtk_primary_selection_device_manager
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_device_listener</NAME>
struct gtk_primary_selection_device_listener {
	/**
	 * introduce a new wp_primary_selection_offer
	 *
	 * Introduces a new wp_primary_selection_offer object that may be
	 * used to receive the current primary selection. Immediately
	 * following this event, the new wp_primary_selection_offer object
	 * will send wp_primary_selection_offer.offer events to describe
	 * the offered mime types.
	 */
	void (*data_offer)(void *data,
			   struct gtk_primary_selection_device *gtk_primary_selection_device,
			   struct gtk_primary_selection_offer *offer);
	/**
	 * advertise a new primary selection
	 *
	 * The wp_primary_selection_device.selection event is sent to
	 * notify the client of a new primary selection. This event is sent
	 * after the wp_primary_selection.data_offer event introducing this
	 * object, and after the offer has announced its mimetypes through
	 * wp_primary_selection_offer.offer.
	 *
	 * The data_offer is valid until a new offer or NULL is received or
	 * until the client loses keyboard focus. The client must destroy
	 * the previous selection data_offer, if any, upon receiving this
	 * event.
	 */
	void (*selection)(void *data,
			  struct gtk_primary_selection_device *gtk_primary_selection_device,
			  struct gtk_primary_selection_offer *id);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_primary_selection_device_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device, const struct gtk_primary_selection_device_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_DESTROY 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_DATA_OFFER_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_DATA_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_SELECTION_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_SELECTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_SET_SELECTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_DEVICE_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_DEVICE_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_device_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_set_selection</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device, struct gtk_primary_selection_source *source, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_device_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_device *gtk_primary_selection_device
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_offer_listener</NAME>
struct gtk_primary_selection_offer_listener {
	/**
	 * advertise offered mime type
	 *
	 * Sent immediately after creating announcing the
	 * wp_primary_selection_offer through
	 * wp_primary_selection_device.data_offer. One event is sent per
	 * offered mime type.
	 */
	void (*offer)(void *data,
		      struct gtk_primary_selection_offer *gtk_primary_selection_offer,
		      const char *mime_type);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_primary_selection_offer_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer, const struct gtk_primary_selection_offer_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_RECEIVE</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_RECEIVE 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_DESTROY 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_OFFER_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_RECEIVE_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_RECEIVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_OFFER_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_OFFER_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_offer_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_receive</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer, const char *mime_type, int32_t fd
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_offer_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_offer *gtk_primary_selection_offer
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_source_listener</NAME>
struct gtk_primary_selection_source_listener {
	/**
	 * send the primary selection contents
	 *
	 * Request for the current primary selection contents from the
	 * client. Send the specified mime type over the passed file
	 * descriptor, then close it.
	 */
	void (*send)(void *data,
		     struct gtk_primary_selection_source *gtk_primary_selection_source,
		     const char *mime_type,
		     int32_t fd);
	/**
	 * request for primary selection contents was canceled
	 *
	 * This primary selection source is no longer valid. The client
	 * should clean up and destroy this primary selection source.
	 */
	void (*cancelled)(void *data,
			  struct gtk_primary_selection_source *gtk_primary_selection_source);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_primary_selection_source_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source, const struct gtk_primary_selection_source_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_OFFER</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_OFFER 0
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_DESTROY</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_DESTROY 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_SEND_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_SEND_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_CANCELLED_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_CANCELLED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_OFFER_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_OFFER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_PRIMARY_SELECTION_SOURCE_DESTROY_SINCE_VERSION</NAME>
#define GTK_PRIMARY_SELECTION_SOURCE_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_primary_selection_source_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_offer</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source, const char *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_primary_selection_source_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_primary_selection_source *gtk_primary_selection_source
</FUNCTION>
<STRUCT>
<NAME>gtk_primary_selection_device</NAME>
struct gtk_primary_selection_device;
</STRUCT>
<STRUCT>
<NAME>gtk_primary_selection_device_manager</NAME>
struct gtk_primary_selection_device_manager;
</STRUCT>
<STRUCT>
<NAME>gtk_primary_selection_offer</NAME>
struct gtk_primary_selection_offer;
</STRUCT>
<STRUCT>
<NAME>gtk_primary_selection_source</NAME>
struct gtk_primary_selection_source;
</STRUCT>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<MACRO>
<NAME>GTK_SHELL1_CAPABILITY_ENUM</NAME>
#define GTK_SHELL1_CAPABILITY_ENUM
</MACRO>
<ENUM>
<NAME>gtk_shell1_capability</NAME>
enum gtk_shell1_capability {
	GTK_SHELL1_CAPABILITY_GLOBAL_APP_MENU = 1,
	GTK_SHELL1_CAPABILITY_GLOBAL_MENU_BAR = 2,
	GTK_SHELL1_CAPABILITY_DESKTOP_ICONS = 3,
};
</ENUM>
<STRUCT>
<NAME>gtk_shell1_listener</NAME>
struct gtk_shell1_listener {
	/**
	 */
	void (*capabilities)(void *data,
			     struct gtk_shell1 *gtk_shell1,
			     uint32_t capabilities);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_shell1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_shell1 *gtk_shell1, const struct gtk_shell1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_SHELL1_GET_GTK_SURFACE</NAME>
#define GTK_SHELL1_GET_GTK_SURFACE 0
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SET_STARTUP_ID</NAME>
#define GTK_SHELL1_SET_STARTUP_ID 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SYSTEM_BELL</NAME>
#define GTK_SHELL1_SYSTEM_BELL 2
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_CAPABILITIES_SINCE_VERSION</NAME>
#define GTK_SHELL1_CAPABILITIES_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_GET_GTK_SURFACE_SINCE_VERSION</NAME>
#define GTK_SHELL1_GET_GTK_SURFACE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SET_STARTUP_ID_SINCE_VERSION</NAME>
#define GTK_SHELL1_SET_STARTUP_ID_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SHELL1_SYSTEM_BELL_SINCE_VERSION</NAME>
#define GTK_SHELL1_SYSTEM_BELL_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_shell1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct gtk_shell1 *gtk_shell1
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_shell1 *gtk_shell1
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_get_gtk_surface</NAME>
<RETURNS>struct gtk_surface1  *</RETURNS>
struct gtk_shell1 *gtk_shell1, struct wl_surface *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_set_startup_id</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1, const char *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_shell1_system_bell</NAME>
<RETURNS>void</RETURNS>
struct gtk_shell1 *gtk_shell1, struct gtk_surface1 *surface
</FUNCTION>
<MACRO>
<NAME>GTK_SURFACE1_STATE_ENUM</NAME>
#define GTK_SURFACE1_STATE_ENUM
</MACRO>
<ENUM>
<NAME>gtk_surface1_state</NAME>
enum gtk_surface1_state {
	GTK_SURFACE1_STATE_TILED = 1,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_TOP = 2,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_RIGHT = 3,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_BOTTOM = 4,
	/**
	 * @since 2
	 */
	GTK_SURFACE1_STATE_TILED_LEFT = 5,
};
</ENUM>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_TOP_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_TOP_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_RIGHT_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_RIGHT_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_BOTTOM_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_BOTTOM_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_STATE_TILED_LEFT_SINCE_VERSION</NAME>
#define GTK_SURFACE1_STATE_TILED_LEFT_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_EDGE_CONSTRAINT_ENUM</NAME>
#define GTK_SURFACE1_EDGE_CONSTRAINT_ENUM
</MACRO>
<ENUM>
<NAME>gtk_surface1_edge_constraint</NAME>
enum gtk_surface1_edge_constraint {
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_TOP = 1,
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_RIGHT = 2,
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_BOTTOM = 3,
	GTK_SURFACE1_EDGE_CONSTRAINT_RESIZABLE_LEFT = 4,
};
</ENUM>
<STRUCT>
<NAME>gtk_surface1_listener</NAME>
struct gtk_surface1_listener {
	/**
	 */
	void (*configure)(void *data,
			  struct gtk_surface1 *gtk_surface1,
			  struct wl_array *states);
	/**
	 * @since 2
	 */
	void (*configure_edges)(void *data,
				struct gtk_surface1 *gtk_surface1,
				struct wl_array *constraints);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_surface1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct gtk_surface1 *gtk_surface1, const struct gtk_surface1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>GTK_SURFACE1_SET_DBUS_PROPERTIES</NAME>
#define GTK_SURFACE1_SET_DBUS_PROPERTIES 0
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_SET_MODAL</NAME>
#define GTK_SURFACE1_SET_MODAL 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_UNSET_MODAL</NAME>
#define GTK_SURFACE1_UNSET_MODAL 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_PRESENT</NAME>
#define GTK_SURFACE1_PRESENT 3
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_CONFIGURE_SINCE_VERSION</NAME>
#define GTK_SURFACE1_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_CONFIGURE_EDGES_SINCE_VERSION</NAME>
#define GTK_SURFACE1_CONFIGURE_EDGES_SINCE_VERSION 2
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_SET_DBUS_PROPERTIES_SINCE_VERSION</NAME>
#define GTK_SURFACE1_SET_DBUS_PROPERTIES_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_SET_MODAL_SINCE_VERSION</NAME>
#define GTK_SURFACE1_SET_MODAL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_UNSET_MODAL_SINCE_VERSION</NAME>
#define GTK_SURFACE1_UNSET_MODAL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>GTK_SURFACE1_PRESENT_SINCE_VERSION</NAME>
#define GTK_SURFACE1_PRESENT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>gtk_surface1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_destroy</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_set_dbus_properties</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1, const char *application_id, const char *app_menu_path, const char *menubar_path, const char *window_object_path, const char *application_object_path, const char *unique_bus_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_set_modal</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_unset_modal</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1
</FUNCTION>
<FUNCTION>
<NAME>gtk_surface1_present</NAME>
<RETURNS>void</RETURNS>
struct gtk_surface1 *gtk_surface1, uint32_t time
</FUNCTION>
<STRUCT>
<NAME>gtk_shell1</NAME>
struct gtk_shell1;
</STRUCT>
<STRUCT>
<NAME>gtk_surface1</NAME>
struct gtk_surface1;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_ERROR_ENUM</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_error</NAME>
enum zwp_keyboard_shortcuts_inhibit_manager_v1_error {
	/**
	 * the shortcuts are already inhibited for this surface
	 */
	ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_ERROR_ALREADY_INHIBITED = 0,
};
</ENUM>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBIT_MANAGER_V1_INHIBIT_SHORTCUTS_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1_inhibit_shortcuts</NAME>
<RETURNS>struct zwp_keyboard_shortcuts_inhibitor_v1  *</RETURNS>
struct zwp_keyboard_shortcuts_inhibit_manager_v1 *zwp_keyboard_shortcuts_inhibit_manager_v1, struct wl_surface *surface, struct wl_seat *seat
</FUNCTION>
<STRUCT>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_listener</NAME>
struct zwp_keyboard_shortcuts_inhibitor_v1_listener {
	/**
	 * shortcuts are inhibited
	 *
	 * This event indicates that the shortcut inhibitor is active.
	 *
	 * The compositor sends this event every time compositor shortcuts
	 * are inhibited on behalf of the surface. When active, the client
	 * may receive input events normally reserved by the compositor
	 * (see zwp_keyboard_shortcuts_inhibitor_v1).
	 *
	 * This occurs typically when the initial request
	 * "inhibit_shortcuts" first becomes active or when the user
	 * instructs the compositor to re-enable and existing shortcuts
	 * inhibitor using any mechanism offered by the compositor.
	 */
	void (*active)(void *data,
		       struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1);
	/**
	 * shortcuts are restored
	 *
	 * This event indicates that the shortcuts inhibitor is inactive,
	 * normal shortcuts processing is restored by the compositor.
	 */
	void (*inactive)(void *data,
			 struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1, const struct zwp_keyboard_shortcuts_inhibitor_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_ACTIVE_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_ACTIVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_INACTIVE_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_INACTIVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_KEYBOARD_SHORTCUTS_INHIBITOR_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_keyboard_shortcuts_inhibitor_v1 *zwp_keyboard_shortcuts_inhibitor_v1
</FUNCTION>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_keyboard_shortcuts_inhibit_manager_v1</NAME>
struct zwp_keyboard_shortcuts_inhibit_manager_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_keyboard_shortcuts_inhibitor_v1</NAME>
struct zwp_keyboard_shortcuts_inhibitor_v1;
</STRUCT>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE 0
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_SWIPE_GESTURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURES_V1_GET_PINCH_GESTURE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_swipe_gesture</NAME>
<RETURNS>struct zwp_pointer_gesture_swipe_v1  *</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1, struct wl_pointer *pointer
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gestures_v1_get_pinch_gesture</NAME>
<RETURNS>struct zwp_pointer_gesture_pinch_v1  *</RETURNS>
struct zwp_pointer_gestures_v1 *zwp_pointer_gestures_v1, struct wl_pointer *pointer
</FUNCTION>
<STRUCT>
<NAME>zwp_pointer_gesture_swipe_v1_listener</NAME>
struct zwp_pointer_gesture_swipe_v1_listener {
	/**
	 * multi-finger swipe begin
	 *
	 * This event is sent when a multi-finger swipe gesture is
	 * detected on the device.
	 * @param time timestamp with millisecond granularity
	 * @param fingers number of fingers
	 */
	void (*begin)(void *data,
		      struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1,
		      uint32_t serial,
		      uint32_t time,
		      struct wl_surface *surface,
		      uint32_t fingers);
	/**
	 * multi-finger swipe motion
	 *
	 * This event is sent when a multi-finger swipe gesture changes
	 * the position of the logical center.
	 *
	 * The dx and dy coordinates are relative coordinates of the
	 * logical center of the gesture compared to the previous event.
	 * @param time timestamp with millisecond granularity
	 * @param dx delta x coordinate in surface coordinate space
	 * @param dy delta y coordinate in surface coordinate space
	 */
	void (*update)(void *data,
		       struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1,
		       uint32_t time,
		       wl_fixed_t dx,
		       wl_fixed_t dy);
	/**
	 * multi-finger swipe end
	 *
	 * This event is sent when a multi-finger swipe gesture ceases to
	 * be valid. This may happen when one or more fingers are lifted or
	 * the gesture is cancelled.
	 *
	 * When a gesture is cancelled, the client should undo state
	 * changes caused by this gesture. What causes a gesture to be
	 * cancelled is implementation-dependent.
	 * @param time timestamp with millisecond granularity
	 * @param cancelled 1 if the gesture was cancelled, 0 otherwise
	 */
	void (*end)(void *data,
		    struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1,
		    uint32_t serial,
		    uint32_t time,
		    int32_t cancelled);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1, const struct zwp_pointer_gesture_swipe_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_BEGIN_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_BEGIN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_UPDATE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_UPDATE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_END_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_END_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_SWIPE_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_swipe_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_swipe_v1 *zwp_pointer_gesture_swipe_v1
</FUNCTION>
<STRUCT>
<NAME>zwp_pointer_gesture_pinch_v1_listener</NAME>
struct zwp_pointer_gesture_pinch_v1_listener {
	/**
	 * multi-finger pinch begin
	 *
	 * This event is sent when a multi-finger pinch gesture is
	 * detected on the device.
	 * @param time timestamp with millisecond granularity
	 * @param fingers number of fingers
	 */
	void (*begin)(void *data,
		      struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1,
		      uint32_t serial,
		      uint32_t time,
		      struct wl_surface *surface,
		      uint32_t fingers);
	/**
	 * multi-finger pinch motion
	 *
	 * This event is sent when a multi-finger pinch gesture changes
	 * the position of the logical center, the rotation or the relative
	 * scale.
	 *
	 * The dx and dy coordinates are relative coordinates in the
	 * surface coordinate space of the logical center of the gesture.
	 *
	 * The scale factor is an absolute scale compared to the
	 * pointer_gesture_pinch.begin event, e.g. a scale of 2 means the
	 * fingers are now twice as far apart as on
	 * pointer_gesture_pinch.begin.
	 *
	 * The rotation is the relative angle in degrees clockwise compared
	 * to the previous pointer_gesture_pinch.begin or
	 * pointer_gesture_pinch.update event.
	 * @param time timestamp with millisecond granularity
	 * @param dx delta x coordinate in surface coordinate space
	 * @param dy delta y coordinate in surface coordinate space
	 * @param scale scale relative to the initial finger position
	 * @param rotation angle in degrees cw relative to the previous event
	 */
	void (*update)(void *data,
		       struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1,
		       uint32_t time,
		       wl_fixed_t dx,
		       wl_fixed_t dy,
		       wl_fixed_t scale,
		       wl_fixed_t rotation);
	/**
	 * multi-finger pinch end
	 *
	 * This event is sent when a multi-finger pinch gesture ceases to
	 * be valid. This may happen when one or more fingers are lifted or
	 * the gesture is cancelled.
	 *
	 * When a gesture is cancelled, the client should undo state
	 * changes caused by this gesture. What causes a gesture to be
	 * cancelled is implementation-dependent.
	 * @param time timestamp with millisecond granularity
	 * @param cancelled 1 if the gesture was cancelled, 0 otherwise
	 */
	void (*end)(void *data,
		    struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1,
		    uint32_t serial,
		    uint32_t time,
		    int32_t cancelled);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1, const struct zwp_pointer_gesture_pinch_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_DESTROY</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_BEGIN_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_BEGIN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_UPDATE_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_UPDATE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_END_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_END_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_POINTER_GESTURE_PINCH_V1_DESTROY_SINCE_VERSION</NAME>
#define ZWP_POINTER_GESTURE_PINCH_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1
</FUNCTION>
<FUNCTION>
<NAME>zwp_pointer_gesture_pinch_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_pointer_gesture_pinch_v1 *zwp_pointer_gesture_pinch_v1
</FUNCTION>
<STRUCT>
<NAME>wl_pointer</NAME>
struct wl_pointer;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_pointer_gesture_pinch_v1</NAME>
struct zwp_pointer_gesture_pinch_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_pointer_gesture_swipe_v1</NAME>
struct zwp_pointer_gesture_swipe_v1;
</STRUCT>
<STRUCT>
<NAME>zwp_pointer_gestures_v1</NAME>
struct zwp_pointer_gestures_v1;
</STRUCT>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_ENUM</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_ENUM
</MACRO>
<ENUM>
<NAME>org_kde_kwin_server_decoration_manager_mode</NAME>
enum org_kde_kwin_server_decoration_manager_mode {
	/**
	 * Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_NONE = 0,
	/**
	 * Client-side decoration: The decoration is part of the surface and the client.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_CLIENT = 1,
	/**
	 * Server-side decoration: The server embeds the surface into a decoration frame.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_MODE_SERVER = 2,
};
</ENUM>
<STRUCT>
<NAME>org_kde_kwin_server_decoration_manager_listener</NAME>
struct org_kde_kwin_server_decoration_manager_listener {
	/**
	 * The default mode used on the server
	 *
	 * This event is emitted directly after binding the interface. It
	 * contains the default mode for the decoration. When a new server
	 * decoration object is created this new object will be in the
	 * default mode until the first request_mode is requested.
	 *
	 * The server may change the default mode at any time.
	 * @param mode The default decoration mode applied to newly created server decorations.
	 */
	void (*default_mode)(void *data,
			     struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager,
			     uint32_t mode);
};
</STRUCT>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_add_listener</NAME>
<RETURNS>int</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager, const struct org_kde_kwin_server_decoration_manager_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE 0
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_DEFAULT_MODE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_DEFAULT_MODE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MANAGER_CREATE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_destroy</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_manager_create</NAME>
<RETURNS>struct org_kde_kwin_server_decoration  *</RETURNS>
struct org_kde_kwin_server_decoration_manager *org_kde_kwin_server_decoration_manager, struct wl_surface *surface
</FUNCTION>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MODE_ENUM</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MODE_ENUM
</MACRO>
<ENUM>
<NAME>org_kde_kwin_server_decoration_mode</NAME>
enum org_kde_kwin_server_decoration_mode {
	/**
	 * Undecorated: The surface is not decorated at all, neither server nor client-side. An example is a popup surface which should not be decorated.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MODE_NONE = 0,
	/**
	 * Client-side decoration: The decoration is part of the surface and the client.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MODE_CLIENT = 1,
	/**
	 * Server-side decoration: The server embeds the surface into a decoration frame.
	 */
	ORG_KDE_KWIN_SERVER_DECORATION_MODE_SERVER = 2,
};
</ENUM>
<STRUCT>
<NAME>org_kde_kwin_server_decoration_listener</NAME>
struct org_kde_kwin_server_decoration_listener {
	/**
	 * The new decoration mode applied by the server
	 *
	 * This event is emitted directly after the decoration is created
	 * and represents the base decoration policy by the server. E.g. a
	 * server which wants all surfaces to be client-side decorated will
	 * send Client, a server which wants server-side decoration will
	 * send Server.
	 *
	 * The client can request a different mode through the decoration
	 * request. The server will acknowledge this by another event with
	 * the same mode. So even if a server prefers server-side
	 * decoration it's possible to force a client-side decoration.
	 *
	 * The server may emit this event at any time. In this case the
	 * client can again request a different mode. It's the
	 * responsibility of the server to prevent a feedback loop.
	 * @param mode The decoration mode applied to the surface by the server.
	 */
	void (*mode)(void *data,
		     struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration,
		     uint32_t mode);
};
</STRUCT>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_add_listener</NAME>
<RETURNS>int</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration, const struct org_kde_kwin_server_decoration_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_RELEASE</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_RELEASE 0
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_MODE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_MODE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_RELEASE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_RELEASE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE_SINCE_VERSION</NAME>
#define ORG_KDE_KWIN_SERVER_DECORATION_REQUEST_MODE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_destroy</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_release</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration
</FUNCTION>
<FUNCTION>
<NAME>org_kde_kwin_server_decoration_request_mode</NAME>
<RETURNS>void</RETURNS>
struct org_kde_kwin_server_decoration *org_kde_kwin_server_decoration, uint32_t mode
</FUNCTION>
<STRUCT>
<NAME>org_kde_kwin_server_decoration</NAME>
struct org_kde_kwin_server_decoration;
</STRUCT>
<STRUCT>
<NAME>org_kde_kwin_server_decoration_manager</NAME>
struct org_kde_kwin_server_decoration_manager;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT</NAME>
#define ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_DESTROY</NAME>
#define ZWP_TABLET_MANAGER_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT_SINCE_VERSION</NAME>
#define ZWP_TABLET_MANAGER_V2_GET_TABLET_SEAT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_MANAGER_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_MANAGER_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_get_tablet_seat</NAME>
<RETURNS>struct zwp_tablet_seat_v2  *</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2, struct wl_seat *seat
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_manager_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_manager_v2 *zwp_tablet_manager_v2
</FUNCTION>
<STRUCT>
<NAME>zwp_tablet_seat_v2_listener</NAME>
struct zwp_tablet_seat_v2_listener {
	/**
	 * new device notification
	 *
	 * This event is sent whenever a new tablet becomes available on
	 * this seat. This event only provides the object id of the tablet,
	 * any static information about the tablet (device name, vid/pid,
	 * etc.) is sent through the wp_tablet interface.
	 * @param id the newly added graphics tablet
	 */
	void (*tablet_added)(void *data,
			     struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2,
			     struct zwp_tablet_v2 *id);
	/**
	 * a new tool has been used with a tablet
	 *
	 * This event is sent whenever a tool that has not previously
	 * been used with a tablet comes into use. This event only provides
	 * the object id of the tool; any static information about the tool
	 * (capabilities, type, etc.) is sent through the wp_tablet_tool
	 * interface.
	 * @param id the newly added tablet tool
	 */
	void (*tool_added)(void *data,
			   struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2,
			   struct zwp_tablet_tool_v2 *id);
	/**
	 * new pad notification
	 *
	 * This event is sent whenever a new pad is known to the system.
	 * Typically, pads are physically attached to tablets and a
	 * pad_added event is sent immediately after the
	 * wp_tablet_seat.tablet_added. However, some standalone pad
	 * devices logically attach to tablets at runtime, and the client
	 * must wait for wp_tablet_pad.enter to know the tablet a pad is
	 * attached to.
	 *
	 * This event only provides the object id of the pad. All further
	 * features (buttons, strips, rings) are sent through the
	 * wp_tablet_pad interface.
	 * @param id the newly added pad
	 */
	void (*pad_added)(void *data,
			  struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2,
			  struct zwp_tablet_pad_v2 *id);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2, const struct zwp_tablet_seat_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_DESTROY</NAME>
#define ZWP_TABLET_SEAT_V2_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_TABLET_ADDED_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_TABLET_ADDED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_TOOL_ADDED_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_TOOL_ADDED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_PAD_ADDED_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_PAD_ADDED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_SEAT_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_SEAT_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_seat_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_seat_v2 *zwp_tablet_seat_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_TYPE_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_TYPE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_type</NAME>
enum zwp_tablet_tool_v2_type {
	/**
	 * Pen
	 */
	ZWP_TABLET_TOOL_V2_TYPE_PEN = 0x140,
	/**
	 * Eraser
	 */
	ZWP_TABLET_TOOL_V2_TYPE_ERASER = 0x141,
	/**
	 * Brush
	 */
	ZWP_TABLET_TOOL_V2_TYPE_BRUSH = 0x142,
	/**
	 * Pencil
	 */
	ZWP_TABLET_TOOL_V2_TYPE_PENCIL = 0x143,
	/**
	 * Airbrush
	 */
	ZWP_TABLET_TOOL_V2_TYPE_AIRBRUSH = 0x144,
	/**
	 * Finger
	 */
	ZWP_TABLET_TOOL_V2_TYPE_FINGER = 0x145,
	/**
	 * Mouse
	 */
	ZWP_TABLET_TOOL_V2_TYPE_MOUSE = 0x146,
	/**
	 * Lens
	 */
	ZWP_TABLET_TOOL_V2_TYPE_LENS = 0x147,
};
</ENUM>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_CAPABILITY_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_CAPABILITY_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_capability</NAME>
enum zwp_tablet_tool_v2_capability {
	/**
	 * Tilt axes
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_TILT = 1,
	/**
	 * Pressure axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_PRESSURE = 2,
	/**
	 * Distance axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_DISTANCE = 3,
	/**
	 * Z-rotation axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_ROTATION = 4,
	/**
	 * Slider axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_SLIDER = 5,
	/**
	 * Wheel axis
	 */
	ZWP_TABLET_TOOL_V2_CAPABILITY_WHEEL = 6,
};
</ENUM>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_BUTTON_STATE_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_BUTTON_STATE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_button_state</NAME>
enum zwp_tablet_tool_v2_button_state {
	/**
	 * button is not pressed
	 */
	ZWP_TABLET_TOOL_V2_BUTTON_STATE_RELEASED = 0,
	/**
	 * button is pressed
	 */
	ZWP_TABLET_TOOL_V2_BUTTON_STATE_PRESSED = 1,
};
</ENUM>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_ERROR_ENUM</NAME>
#define ZWP_TABLET_TOOL_V2_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_tool_v2_error</NAME>
enum zwp_tablet_tool_v2_error {
	/**
	 * given wl_surface has another role
	 */
	ZWP_TABLET_TOOL_V2_ERROR_ROLE = 0,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_tool_v2_listener</NAME>
struct zwp_tablet_tool_v2_listener {
	/**
	 * tool type
	 *
	 * The tool type is the high-level type of the tool and usually
	 * decides the interaction expected from this tool.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param tool_type the physical tool type
	 */
	void (*type)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		     uint32_t tool_type);
	/**
	 * unique hardware serial number of the tool
	 *
	 * If the physical tool can be identified by a unique 64-bit
	 * serial number, this event notifies the client of this serial
	 * number.
	 *
	 * If multiple tablets are available in the same seat and the tool
	 * is uniquely identifiable by the serial number, that tool may
	 * move between tablets.
	 *
	 * Otherwise, if the tool has no serial number and this event is
	 * missing, the tool is tied to the tablet it first comes into
	 * proximity with. Even if the physical tool is used on multiple
	 * tablets, separate wp_tablet_tool objects will be created, one
	 * per tablet.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param hardware_serial_hi the unique serial number of the tool, most significant bits
	 * @param hardware_serial_lo the unique serial number of the tool, least significant bits
	 */
	void (*hardware_serial)(void *data,
				struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
				uint32_t hardware_serial_hi,
				uint32_t hardware_serial_lo);
	/**
	 * hardware id notification in Wacom's format
	 *
	 * This event notifies the client of a hardware id available on
	 * this tool.
	 *
	 * The hardware id is a device-specific 64-bit id that provides
	 * extra information about the tool in use, beyond the wl_tool.type
	 * enumeration. The format of the id is specific to tablets made by
	 * Wacom Inc. For example, the hardware id of a Wacom Grip Pen (a
	 * stylus) is 0x802.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param hardware_id_hi the hardware id, most significant bits
	 * @param hardware_id_lo the hardware id, least significant bits
	 */
	void (*hardware_id_wacom)(void *data,
				  struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
				  uint32_t hardware_id_hi,
				  uint32_t hardware_id_lo);
	/**
	 * tool capability notification
	 *
	 * This event notifies the client of any capabilities of this
	 * tool, beyond the main set of x/y axes and tip up/down detection.
	 *
	 * One event is sent for each extra capability available on this
	 * tool.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_tool.done event.
	 * @param capability the capability
	 */
	void (*capability)(void *data,
			   struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			   uint32_t capability);
	/**
	 * tool description events sequence complete
	 *
	 * This event signals the end of the initial burst of descriptive
	 * events. A client may consider the static description of the tool
	 * to be complete and finalize initialization of the tool.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * tool removed
	 *
	 * This event is sent when the tool is removed from the system
	 * and will send no further events. Should the physical tool come
	 * back into proximity later, a new wp_tablet_tool object will be
	 * created.
	 *
	 * It is compositor-dependent when a tool is removed. A compositor
	 * may remove a tool on proximity out, tablet removal or any other
	 * reason. A compositor may also keep a tool alive until shutdown.
	 *
	 * If the tool is currently in proximity, a proximity_out event
	 * will be sent before the removed event. See
	 * wp_tablet_tool.proximity_out for the handling of any buttons
	 * logically down.
	 *
	 * When this event is received, the client must
	 * wp_tablet_tool.destroy the object.
	 */
	void (*removed)(void *data,
			struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * proximity in event
	 *
	 * Notification that this tool is focused on a certain surface.
	 *
	 * This event can be received when the tool has moved from one
	 * surface to another, or when the tool has come back into
	 * proximity above the surface.
	 *
	 * If any button is logically down when the tool comes into
	 * proximity, the respective button event is sent after the
	 * proximity_in event but within the same frame as the proximity_in
	 * event.
	 * @param tablet The tablet the tool is in proximity of
	 * @param surface The current surface the tablet tool is over
	 */
	void (*proximity_in)(void *data,
			     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			     uint32_t serial,
			     struct zwp_tablet_v2 *tablet,
			     struct wl_surface *surface);
	/**
	 * proximity out event
	 *
	 * Notification that this tool has either left proximity, or is
	 * no longer focused on a certain surface.
	 *
	 * When the tablet tool leaves proximity of the tablet, button
	 * release events are sent for each button that was held down at
	 * the time of leaving proximity. These events are sent before the
	 * proximity_out event but within the same wp_tablet.frame.
	 *
	 * If the tool stays within proximity of the tablet, but the focus
	 * changes from one surface to another, a button release event may
	 * not be sent until the button is actually released or the tool
	 * leaves the proximity of the tablet.
	 */
	void (*proximity_out)(void *data,
			      struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * tablet tool is making contact
	 *
	 * Sent whenever the tablet tool comes in contact with the
	 * surface of the tablet.
	 *
	 * If the tool is already in contact with the tablet when entering
	 * the input region, the client owning said region will receive a
	 * wp_tablet.proximity_in event, followed by a wp_tablet.down event
	 * and a wp_tablet.frame event.
	 *
	 * Note that this event describes logical contact, not physical
	 * contact. On some devices, a compositor may not consider a tool
	 * in logical contact until a minimum physical pressure threshold
	 * is exceeded.
	 */
	void (*down)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		     uint32_t serial);
	/**
	 * tablet tool is no longer making contact
	 *
	 * Sent whenever the tablet tool stops making contact with the
	 * surface of the tablet, or when the tablet tool moves out of the
	 * input region and the compositor grab (if any) is dismissed.
	 *
	 * If the tablet tool moves out of the input region while in
	 * contact with the surface of the tablet and the compositor does
	 * not have an ongoing grab on the surface, the client owning said
	 * region will receive a wp_tablet.up event, followed by a
	 * wp_tablet.proximity_out event and a wp_tablet.frame event. If
	 * the compositor has an ongoing grab on this device, this event
	 * sequence is sent whenever the grab is dismissed in the future.
	 *
	 * Note that this event describes logical contact, not physical
	 * contact. On some devices, a compositor may not consider a tool
	 * out of logical contact until physical pressure falls below a
	 * specific threshold.
	 */
	void (*up)(void *data,
		   struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2);
	/**
	 * motion event
	 *
	 * Sent whenever a tablet tool moves.
	 * @param x surface-local x coordinate
	 * @param y surface-local y coordinate
	 */
	void (*motion)(void *data,
		       struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		       wl_fixed_t x,
		       wl_fixed_t y);
	/**
	 * pressure change event
	 *
	 * Sent whenever the pressure axis on a tool changes. The value
	 * of this event is normalized to a value between 0 and 65535.
	 *
	 * Note that pressure may be nonzero even when a tool is not in
	 * logical contact. See the down and up events for more details.
	 * @param pressure The current pressure value
	 */
	void (*pressure)(void *data,
			 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			 uint32_t pressure);
	/**
	 * distance change event
	 *
	 * Sent whenever the distance axis on a tool changes. The value
	 * of this event is normalized to a value between 0 and 65535.
	 *
	 * Note that distance may be nonzero even when a tool is not in
	 * logical contact. See the down and up events for more details.
	 * @param distance The current distance value
	 */
	void (*distance)(void *data,
			 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			 uint32_t distance);
	/**
	 * tilt change event
	 *
	 * Sent whenever one or both of the tilt axes on a tool change.
	 * Each tilt value is in degrees, relative to the z-axis of the
	 * tablet. The angle is positive when the top of a tool tilts along
	 * the positive x or y axis.
	 * @param tilt_x The current value of the X tilt axis
	 * @param tilt_y The current value of the Y tilt axis
	 */
	void (*tilt)(void *data,
		     struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		     wl_fixed_t tilt_x,
		     wl_fixed_t tilt_y);
	/**
	 * z-rotation change event
	 *
	 * Sent whenever the z-rotation axis on the tool changes. The
	 * rotation value is in degrees clockwise from the tool's logical
	 * neutral position.
	 * @param degrees The current rotation of the Z axis
	 */
	void (*rotation)(void *data,
			 struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
			 wl_fixed_t degrees);
	/**
	 * Slider position change event
	 *
	 * Sent whenever the slider position on the tool changes. The
	 * value is normalized between -65535 and 65535, with 0 as the
	 * logical neutral position of the slider.
	 *
	 * The slider is available on e.g. the Wacom Airbrush tool.
	 * @param position The current position of slider
	 */
	void (*slider)(void *data,
		       struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		       int32_t position);
	/**
	 * Wheel delta event
	 *
	 * Sent whenever the wheel on the tool emits an event. This event
	 * contains two values for the same axis change. The degrees value
	 * is in the same orientation as the wl_pointer.vertical_scroll
	 * axis. The clicks value is in discrete logical clicks of the
	 * mouse wheel. This value may be zero if the movement of the wheel
	 * was less than one logical click.
	 *
	 * Clients should choose either value and avoid mixing degrees and
	 * clicks. The compositor may accumulate values smaller than a
	 * logical click and emulate click events when a certain threshold
	 * is met. Thus, wl_tablet_tool.wheel events with non-zero clicks
	 * values may have different degrees values.
	 * @param degrees The wheel delta in degrees
	 * @param clicks The wheel delta in discrete clicks
	 */
	void (*wheel)(void *data,
		      struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		      wl_fixed_t degrees,
		      int32_t clicks);
	/**
	 * button event
	 *
	 * Sent whenever a button on the tool is pressed or released.
	 *
	 * If a button is held down when the tool moves in or out of
	 * proximity, button events are generated by the compositor. See
	 * wp_tablet_tool.proximity_in and wp_tablet_tool.proximity_out for
	 * details.
	 * @param button The button whose state has changed
	 * @param state Whether the button was pressed or released
	 */
	void (*button)(void *data,
		       struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		       uint32_t serial,
		       uint32_t button,
		       uint32_t state);
	/**
	 * frame event
	 *
	 * Marks the end of a series of axis and/or button updates from
	 * the tablet. The Wayland protocol requires axis updates to be
	 * sent sequentially, however all events within a frame should be
	 * considered one hardware event.
	 * @param time The time of the event with millisecond granularity
	 */
	void (*frame)(void *data,
		      struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2,
		      uint32_t time);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2, const struct zwp_tablet_tool_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_SET_CURSOR</NAME>
#define ZWP_TABLET_TOOL_V2_SET_CURSOR 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DESTROY</NAME>
#define ZWP_TABLET_TOOL_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_TYPE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_TYPE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_HARDWARE_SERIAL_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_HARDWARE_SERIAL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_HARDWARE_ID_WACOM_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_HARDWARE_ID_WACOM_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_CAPABILITY_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_CAPABILITY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_REMOVED_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_REMOVED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_PROXIMITY_IN_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_PROXIMITY_IN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_PROXIMITY_OUT_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_PROXIMITY_OUT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DOWN_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DOWN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_UP_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_UP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_MOTION_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_MOTION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_PRESSURE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_PRESSURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DISTANCE_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DISTANCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_TILT_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_TILT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_ROTATION_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_ROTATION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_SLIDER_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_SLIDER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_WHEEL_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_WHEEL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_BUTTON_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_BUTTON_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_FRAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_FRAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_SET_CURSOR_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_SET_CURSOR_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_TOOL_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_TOOL_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_set_cursor</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2, uint32_t serial, struct wl_surface *surface, int32_t hotspot_x, int32_t hotspot_y
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_tool_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_tool_v2 *zwp_tablet_tool_v2
</FUNCTION>
<STRUCT>
<NAME>zwp_tablet_v2_listener</NAME>
struct zwp_tablet_v2_listener {
	/**
	 * tablet device name
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet.done event.
	 * @param name the device name
	 */
	void (*name)(void *data,
		     struct zwp_tablet_v2 *zwp_tablet_v2,
		     const char *name);
	/**
	 * tablet device USB vendor/product id
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet.done event.
	 * @param vid USB vendor id
	 * @param pid USB product id
	 */
	void (*id)(void *data,
		   struct zwp_tablet_v2 *zwp_tablet_v2,
		   uint32_t vid,
		   uint32_t pid);
	/**
	 * path to the device
	 *
	 * A system-specific device path that indicates which device is
	 * behind this wp_tablet. This information may be used to gather
	 * additional information about the device, e.g. through libwacom.
	 *
	 * A device may have more than one device path. If so, multiple
	 * wp_tablet.path events are sent. A device may be emulated and not
	 * have a device path, and in that case this event will not be
	 * sent.
	 *
	 * The format of the path is unspecified, it may be a device node,
	 * a sysfs path, or some other identifier. It is up to the client
	 * to identify the string provided.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet.done event.
	 * @param path path to local device
	 */
	void (*path)(void *data,
		     struct zwp_tablet_v2 *zwp_tablet_v2,
		     const char *path);
	/**
	 * tablet description events sequence complete
	 *
	 * This event is sent immediately to signal the end of the
	 * initial burst of descriptive events. A client may consider the
	 * static description of the tablet to be complete and finalize
	 * initialization of the tablet.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_v2 *zwp_tablet_v2);
	/**
	 * tablet removed event
	 *
	 * Sent when the tablet has been removed from the system. When a
	 * tablet is removed, some tools may be removed.
	 *
	 * When this event is received, the client must wp_tablet.destroy
	 * the object.
	 */
	void (*removed)(void *data,
			struct zwp_tablet_v2 *zwp_tablet_v2);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2, const struct zwp_tablet_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_V2_DESTROY</NAME>
#define ZWP_TABLET_V2_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_NAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_NAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_ID_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_ID_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_PATH_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_PATH_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_REMOVED_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_REMOVED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_v2 *zwp_tablet_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SOURCE_ENUM</NAME>
#define ZWP_TABLET_PAD_RING_V2_SOURCE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_pad_ring_v2_source</NAME>
enum zwp_tablet_pad_ring_v2_source {
	/**
	 * finger
	 */
	ZWP_TABLET_PAD_RING_V2_SOURCE_FINGER = 1,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_pad_ring_v2_listener</NAME>
struct zwp_tablet_pad_ring_v2_listener {
	/**
	 * ring event source
	 *
	 * Source information for ring events.
	 *
	 * This event does not occur on its own. It is sent before a
	 * wp_tablet_pad_ring.frame event and carries the source
	 * information for all events within that frame.
	 *
	 * The source specifies how this event was generated. If the source
	 * is wp_tablet_pad_ring.source.finger, a wp_tablet_pad_ring.stop
	 * event will be sent when the user lifts the finger off the
	 * device.
	 *
	 * This event is optional. If the source is unknown for an
	 * interaction, no event is sent.
	 * @param source the event source
	 */
	void (*source)(void *data,
		       struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2,
		       uint32_t source);
	/**
	 * angle changed
	 *
	 * Sent whenever the angle on a ring changes.
	 *
	 * The angle is provided in degrees clockwise from the logical
	 * north of the ring in the pad's current rotation.
	 * @param degrees the current angle in degrees
	 */
	void (*angle)(void *data,
		      struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2,
		      wl_fixed_t degrees);
	/**
	 * interaction stopped
	 *
	 * Stop notification for ring events.
	 *
	 * For some wp_tablet_pad_ring.source types, a
	 * wp_tablet_pad_ring.stop event is sent to notify a client that
	 * the interaction with the ring has terminated. This enables the
	 * client to implement kinetic scrolling. See the
	 * wp_tablet_pad_ring.source documentation for information on when
	 * this event may be generated.
	 *
	 * Any wp_tablet_pad_ring.angle events with the same source after
	 * this event should be considered as the start of a new
	 * interaction.
	 */
	void (*stop)(void *data,
		     struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2);
	/**
	 * end of a ring event sequence
	 *
	 * Indicates the end of a set of ring events that logically
	 * belong together. A client is expected to accumulate the data in
	 * all events within the frame before proceeding.
	 *
	 * All wp_tablet_pad_ring events before a wp_tablet_pad_ring.frame
	 * event belong logically together. For example, on termination of
	 * a finger interaction on a ring the compositor will send a
	 * wp_tablet_pad_ring.source event, a wp_tablet_pad_ring.stop event
	 * and a wp_tablet_pad_ring.frame event.
	 *
	 * A wp_tablet_pad_ring.frame event is sent for every logical event
	 * group, even if the group only contains a single
	 * wp_tablet_pad_ring event. Specifically, a client may get a
	 * sequence: angle, frame, angle, frame, etc.
	 * @param time timestamp with millisecond granularity
	 */
	void (*frame)(void *data,
		      struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2,
		      uint32_t time);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2, const struct zwp_tablet_pad_ring_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK</NAME>
#define ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_RING_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SOURCE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_SOURCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_ANGLE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_ANGLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_STOP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_STOP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_FRAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_FRAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_SET_FEEDBACK_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_RING_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_RING_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_set_feedback</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2, const char *description, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_ring_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_ring_v2 *zwp_tablet_pad_ring_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SOURCE_ENUM</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SOURCE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_pad_strip_v2_source</NAME>
enum zwp_tablet_pad_strip_v2_source {
	/**
	 * finger
	 */
	ZWP_TABLET_PAD_STRIP_V2_SOURCE_FINGER = 1,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_pad_strip_v2_listener</NAME>
struct zwp_tablet_pad_strip_v2_listener {
	/**
	 * strip event source
	 *
	 * Source information for strip events.
	 *
	 * This event does not occur on its own. It is sent before a
	 * wp_tablet_pad_strip.frame event and carries the source
	 * information for all events within that frame.
	 *
	 * The source specifies how this event was generated. If the source
	 * is wp_tablet_pad_strip.source.finger, a wp_tablet_pad_strip.stop
	 * event will be sent when the user lifts their finger off the
	 * device.
	 *
	 * This event is optional. If the source is unknown for an
	 * interaction, no event is sent.
	 * @param source the event source
	 */
	void (*source)(void *data,
		       struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2,
		       uint32_t source);
	/**
	 * position changed
	 *
	 * Sent whenever the position on a strip changes.
	 *
	 * The position is normalized to a range of [0, 65535], the 0-value
	 * represents the top-most and/or left-most position of the strip
	 * in the pad's current rotation.
	 * @param position the current position
	 */
	void (*position)(void *data,
			 struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2,
			 uint32_t position);
	/**
	 * interaction stopped
	 *
	 * Stop notification for strip events.
	 *
	 * For some wp_tablet_pad_strip.source types, a
	 * wp_tablet_pad_strip.stop event is sent to notify a client that
	 * the interaction with the strip has terminated. This enables the
	 * client to implement kinetic scrolling. See the
	 * wp_tablet_pad_strip.source documentation for information on when
	 * this event may be generated.
	 *
	 * Any wp_tablet_pad_strip.position events with the same source
	 * after this event should be considered as the start of a new
	 * interaction.
	 */
	void (*stop)(void *data,
		     struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2);
	/**
	 * end of a strip event sequence
	 *
	 * Indicates the end of a set of events that represent one
	 * logical hardware strip event. A client is expected to accumulate
	 * the data in all events within the frame before proceeding.
	 *
	 * All wp_tablet_pad_strip events before a
	 * wp_tablet_pad_strip.frame event belong logically together. For
	 * example, on termination of a finger interaction on a strip the
	 * compositor will send a wp_tablet_pad_strip.source event, a
	 * wp_tablet_pad_strip.stop event and a wp_tablet_pad_strip.frame
	 * event.
	 *
	 * A wp_tablet_pad_strip.frame event is sent for every logical
	 * event group, even if the group only contains a single
	 * wp_tablet_pad_strip event. Specifically, a client may get a
	 * sequence: position, frame, position, frame, etc.
	 * @param time timestamp with millisecond granularity
	 */
	void (*frame)(void *data,
		      struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2,
		      uint32_t time);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2, const struct zwp_tablet_pad_strip_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SOURCE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SOURCE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_POSITION_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_POSITION_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_STOP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_STOP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_FRAME_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_FRAME_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_SET_FEEDBACK_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_STRIP_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_STRIP_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_set_feedback</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2, const char *description, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_strip_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_strip_v2 *zwp_tablet_pad_strip_v2
</FUNCTION>
<STRUCT>
<NAME>zwp_tablet_pad_group_v2_listener</NAME>
struct zwp_tablet_pad_group_v2_listener {
	/**
	 * buttons announced
	 *
	 * Sent on wp_tablet_pad_group initialization to announce the
	 * available buttons in the group. Button indices start at 0, a
	 * button may only be in one group at a time.
	 *
	 * This event is first sent in the initial burst of events before
	 * the wp_tablet_pad_group.done event.
	 *
	 * Some buttons are reserved by the compositor. These buttons may
	 * not be assigned to any wp_tablet_pad_group. Compositors may
	 * broadcast this event in the case of changes to the mapping of
	 * these reserved buttons. If the compositor happens to reserve all
	 * buttons in a group, this event will be sent with an empty array.
	 * @param buttons buttons in this group
	 */
	void (*buttons)(void *data,
			struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
			struct wl_array *buttons);
	/**
	 * ring announced
	 *
	 * Sent on wp_tablet_pad_group initialization to announce
	 * available rings. One event is sent for each ring available on
	 * this pad group.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad_group.done event.
	 */
	void (*ring)(void *data,
		     struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
		     struct zwp_tablet_pad_ring_v2 *ring);
	/**
	 * strip announced
	 *
	 * Sent on wp_tablet_pad initialization to announce available
	 * strips. One event is sent for each strip available on this pad
	 * group.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad_group.done event.
	 */
	void (*strip)(void *data,
		      struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
		      struct zwp_tablet_pad_strip_v2 *strip);
	/**
	 * mode-switch ability announced
	 *
	 * Sent on wp_tablet_pad_group initialization to announce that
	 * the pad group may switch between modes. A client may use a mode
	 * to store a specific configuration for buttons, rings and strips
	 * and use the wl_tablet_pad_group.mode_switch event to toggle
	 * between these configurations. Mode indices start at 0.
	 *
	 * Switching modes is compositor-dependent. See the
	 * wp_tablet_pad_group.mode_switch event for more details.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad_group.done event. This event is only sent when
	 * more than more than one mode is available.
	 * @param modes the number of modes
	 */
	void (*modes)(void *data,
		      struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
		      uint32_t modes);
	/**
	 * tablet group description events sequence complete
	 *
	 * This event is sent immediately to signal the end of the
	 * initial burst of descriptive events. A client may consider the
	 * static description of the tablet to be complete and finalize
	 * initialization of the tablet group.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2);
	/**
	 * mode switch event
	 *
	 * Notification that the mode was switched.
	 *
	 * A mode applies to all buttons, rings and strips in a group
	 * simultaneously, but a client is not required to assign different
	 * actions for each mode. For example, a client may have
	 * mode-specific button mappings but map the ring to vertical
	 * scrolling in all modes. Mode indices start at 0.
	 *
	 * Switching modes is compositor-dependent. The compositor may
	 * provide visual cues to the client about the mode, e.g. by
	 * toggling LEDs on the tablet device. Mode-switching may be
	 * software-controlled or controlled by one or more physical
	 * buttons. For example, on a Wacom Intuos Pro, the button inside
	 * the ring may be assigned to switch between modes.
	 *
	 * The compositor will also send this event after
	 * wp_tablet_pad.enter on each group in order to notify of the
	 * current mode. Groups that only feature one mode will use mode=0
	 * when emitting this event.
	 *
	 * If a button action in the new mode differs from the action in
	 * the previous mode, the client should immediately issue a
	 * wp_tablet_pad.set_feedback request for each changed button.
	 *
	 * If a ring or strip action in the new mode differs from the
	 * action in the previous mode, the client should immediately issue
	 * a wp_tablet_ring.set_feedback or wp_tablet_strip.set_feedback
	 * request for each changed ring or strip.
	 * @param time the time of the event with millisecond granularity
	 * @param mode the new mode of the pad
	 */
	void (*mode_switch)(void *data,
			    struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2,
			    uint32_t time,
			    uint32_t serial,
			    uint32_t mode);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2, const struct zwp_tablet_pad_group_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_BUTTONS_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_BUTTONS_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_RING_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_RING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_STRIP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_STRIP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_MODES_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_MODES_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_MODE_SWITCH_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_MODE_SWITCH_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_GROUP_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_GROUP_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_group_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_group_v2 *zwp_tablet_pad_group_v2
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_BUTTON_STATE_ENUM</NAME>
#define ZWP_TABLET_PAD_V2_BUTTON_STATE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_tablet_pad_v2_button_state</NAME>
enum zwp_tablet_pad_v2_button_state {
	/**
	 * the button is not pressed
	 */
	ZWP_TABLET_PAD_V2_BUTTON_STATE_RELEASED = 0,
	/**
	 * the button is pressed
	 */
	ZWP_TABLET_PAD_V2_BUTTON_STATE_PRESSED = 1,
};
</ENUM>
<STRUCT>
<NAME>zwp_tablet_pad_v2_listener</NAME>
struct zwp_tablet_pad_v2_listener {
	/**
	 * group announced
	 *
	 * Sent on wp_tablet_pad initialization to announce available
	 * groups. One event is sent for each pad group available.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad.done event. At least one group will be announced.
	 */
	void (*group)(void *data,
		      struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		      struct zwp_tablet_pad_group_v2 *pad_group);
	/**
	 * path to the device
	 *
	 * A system-specific device path that indicates which device is
	 * behind this wp_tablet_pad. This information may be used to
	 * gather additional information about the device, e.g. through
	 * libwacom.
	 *
	 * The format of the path is unspecified, it may be a device node,
	 * a sysfs path, or some other identifier. It is up to the client
	 * to identify the string provided.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad.done event.
	 * @param path path to local device
	 */
	void (*path)(void *data,
		     struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		     const char *path);
	/**
	 * buttons announced
	 *
	 * Sent on wp_tablet_pad initialization to announce the available
	 * buttons.
	 *
	 * This event is sent in the initial burst of events before the
	 * wp_tablet_pad.done event. This event is only sent when at least
	 * one button is available.
	 * @param buttons the number of buttons
	 */
	void (*buttons)(void *data,
			struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
			uint32_t buttons);
	/**
	 * pad description event sequence complete
	 *
	 * This event signals the end of the initial burst of descriptive
	 * events. A client may consider the static description of the pad
	 * to be complete and finalize initialization of the pad.
	 */
	void (*done)(void *data,
		     struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2);
	/**
	 * physical button state
	 *
	 * Sent whenever the physical state of a button changes.
	 * @param time the time of the event with millisecond granularity
	 * @param button the index of the button that changed state
	 */
	void (*button)(void *data,
		       struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		       uint32_t time,
		       uint32_t button,
		       uint32_t state);
	/**
	 * enter event
	 *
	 * Notification that this pad is focused on the specified
	 * surface.
	 * @param serial serial number of the enter event
	 * @param tablet the tablet the pad is attached to
	 * @param surface surface the pad is focused on
	 */
	void (*enter)(void *data,
		      struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		      uint32_t serial,
		      struct zwp_tablet_v2 *tablet,
		      struct wl_surface *surface);
	/**
	 * enter event
	 *
	 * Notification that this pad is no longer focused on the
	 * specified surface.
	 * @param serial serial number of the leave event
	 * @param surface surface the pad is no longer focused on
	 */
	void (*leave)(void *data,
		      struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
		      uint32_t serial,
		      struct wl_surface *surface);
	/**
	 * pad removed event
	 *
	 * Sent when the pad has been removed from the system. When a
	 * tablet is removed its pad(s) will be removed too.
	 *
	 * When this event is received, the client must destroy all rings,
	 * strips and groups that were offered by this pad, and issue
	 * wp_tablet_pad.destroy the pad itself.
	 */
	void (*removed)(void *data,
			struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2, const struct zwp_tablet_pad_v2_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_SET_FEEDBACK</NAME>
#define ZWP_TABLET_PAD_V2_SET_FEEDBACK 0
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_DESTROY</NAME>
#define ZWP_TABLET_PAD_V2_DESTROY 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_GROUP_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_GROUP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_PATH_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_PATH_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_BUTTONS_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_BUTTONS_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_DONE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_BUTTON_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_BUTTON_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_ENTER_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_ENTER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_LEAVE_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_LEAVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_REMOVED_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_REMOVED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_SET_FEEDBACK_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_SET_FEEDBACK_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TABLET_PAD_V2_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TABLET_PAD_V2_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_set_feedback</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2, uint32_t button, const char *description, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zwp_tablet_pad_v2_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2
</FUNCTION>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_manager_v2</NAME>
struct zwp_tablet_manager_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_group_v2</NAME>
struct zwp_tablet_pad_group_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_ring_v2</NAME>
struct zwp_tablet_pad_ring_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_strip_v2</NAME>
struct zwp_tablet_pad_strip_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_pad_v2</NAME>
struct zwp_tablet_pad_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_seat_v2</NAME>
struct zwp_tablet_seat_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_tool_v2</NAME>
struct zwp_tablet_tool_v2;
</STRUCT>
<STRUCT>
<NAME>zwp_tablet_v2</NAME>
struct zwp_tablet_v2;
</STRUCT>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_DESTROY</NAME>
#define ZXDG_EXPORTER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_EXPORT</NAME>
#define ZXDG_EXPORTER_V1_EXPORT 1
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_EXPORTER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTER_V1_EXPORT_SINCE_VERSION</NAME>
#define ZXDG_EXPORTER_V1_EXPORT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_exporter_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exporter_v1_export</NAME>
<RETURNS>struct zxdg_exported_v1  *</RETURNS>
struct zxdg_exporter_v1 *zxdg_exporter_v1, struct wl_surface *surface
</FUNCTION>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_DESTROY</NAME>
#define ZXDG_IMPORTER_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_IMPORT</NAME>
#define ZXDG_IMPORTER_V1_IMPORT 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_IMPORTER_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTER_V1_IMPORT_SINCE_VERSION</NAME>
#define ZXDG_IMPORTER_V1_IMPORT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_importer_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_importer_v1_import</NAME>
<RETURNS>struct zxdg_imported_v1  *</RETURNS>
struct zxdg_importer_v1 *zxdg_importer_v1, const char *handle
</FUNCTION>
<STRUCT>
<NAME>zxdg_exported_v1_listener</NAME>
struct zxdg_exported_v1_listener {
	/**
	 * the exported surface handle
	 *
	 * The handle event contains the unique handle of this exported
	 * surface reference. It may be shared with any client, which then
	 * can use it to import the surface by calling xdg_importer.import.
	 * A handle may be used to import the surface multiple times.
	 * @param handle the exported surface handle
	 */
	void (*handle)(void *data,
		       struct zxdg_exported_v1 *zxdg_exported_v1,
		       const char *handle);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_exported_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1, const struct zxdg_exported_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_EXPORTED_V1_DESTROY</NAME>
#define ZXDG_EXPORTED_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTED_V1_HANDLE_SINCE_VERSION</NAME>
#define ZXDG_EXPORTED_V1_HANDLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_EXPORTED_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_EXPORTED_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_exported_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exported_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exported_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_exported_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_exported_v1 *zxdg_exported_v1
</FUNCTION>
<STRUCT>
<NAME>zxdg_imported_v1_listener</NAME>
struct zxdg_imported_v1_listener {
	/**
	 * the imported surface handle has been destroyed
	 *
	 * The imported surface handle has been destroyed and any
	 * relationship set up has been invalidated. This may happen for
	 * various reasons, for example if the exported surface or the
	 * exported surface handle has been destroyed, if the handle used
	 * for importing was invalid.
	 */
	void (*destroyed)(void *data,
			  struct zxdg_imported_v1 *zxdg_imported_v1);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_imported_v1_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1, const struct zxdg_imported_v1_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_DESTROY</NAME>
#define ZXDG_IMPORTED_V1_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_SET_PARENT_OF</NAME>
#define ZXDG_IMPORTED_V1_SET_PARENT_OF 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_DESTROYED_SINCE_VERSION</NAME>
#define ZXDG_IMPORTED_V1_DESTROYED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_IMPORTED_V1_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_IMPORTED_V1_SET_PARENT_OF_SINCE_VERSION</NAME>
#define ZXDG_IMPORTED_V1_SET_PARENT_OF_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_imported_v1_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1
</FUNCTION>
<FUNCTION>
<NAME>zxdg_imported_v1_set_parent_of</NAME>
<RETURNS>void</RETURNS>
struct zxdg_imported_v1 *zxdg_imported_v1, struct wl_surface *surface
</FUNCTION>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zxdg_exported_v1</NAME>
struct zxdg_exported_v1;
</STRUCT>
<STRUCT>
<NAME>zxdg_exporter_v1</NAME>
struct zxdg_exporter_v1;
</STRUCT>
<STRUCT>
<NAME>zxdg_imported_v1</NAME>
struct zxdg_imported_v1;
</STRUCT>
<STRUCT>
<NAME>zxdg_importer_v1</NAME>
struct zxdg_importer_v1;
</STRUCT>
<MACRO>
<NAME>ZXDG_SHELL_V6_ERROR_ENUM</NAME>
#define ZXDG_SHELL_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_shell_v6_error</NAME>
enum zxdg_shell_v6_error {
	/**
	 * given wl_surface has another role
	 */
	ZXDG_SHELL_V6_ERROR_ROLE = 0,
	/**
	 * xdg_shell was destroyed before children
	 */
	ZXDG_SHELL_V6_ERROR_DEFUNCT_SURFACES = 1,
	/**
	 * the client tried to map or destroy a non-topmost popup
	 */
	ZXDG_SHELL_V6_ERROR_NOT_THE_TOPMOST_POPUP = 2,
	/**
	 * the client specified an invalid popup parent surface
	 */
	ZXDG_SHELL_V6_ERROR_INVALID_POPUP_PARENT = 3,
	/**
	 * the client provided an invalid surface state
	 */
	ZXDG_SHELL_V6_ERROR_INVALID_SURFACE_STATE = 4,
	/**
	 * the client provided an invalid positioner
	 */
	ZXDG_SHELL_V6_ERROR_INVALID_POSITIONER = 5,
};
</ENUM>
<STRUCT>
<NAME>zxdg_shell_v6_listener</NAME>
struct zxdg_shell_v6_listener {
	/**
	 * check if the client is alive
	 *
	 * The ping event asks the client if it's still alive. Pass the
	 * serial specified in the event back to the compositor by sending
	 * a "pong" request back with the specified serial. See
	 * xdg_shell.ping.
	 *
	 * Compositors can use this to determine if the client is still
	 * alive. It's unspecified what will happen if the client doesn't
	 * respond to the ping request, or in what timeframe. Clients
	 * should try to respond in a reasonable amount of time.
	 *
	 * A compositor is free to ping in any way it wants, but a client
	 * must always respond to any xdg_shell object it created.
	 * @param serial pass this to the pong request
	 */
	void (*ping)(void *data,
		     struct zxdg_shell_v6 *zxdg_shell_v6,
		     uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_shell_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, const struct zxdg_shell_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_SHELL_V6_DESTROY</NAME>
#define ZXDG_SHELL_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_CREATE_POSITIONER</NAME>
#define ZXDG_SHELL_V6_CREATE_POSITIONER 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_GET_XDG_SURFACE</NAME>
#define ZXDG_SHELL_V6_GET_XDG_SURFACE 2
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_PONG</NAME>
#define ZXDG_SHELL_V6_PONG 3
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_PING_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_PING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_CREATE_POSITIONER_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_CREATE_POSITIONER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_GET_XDG_SURFACE_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_GET_XDG_SURFACE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SHELL_V6_PONG_SINCE_VERSION</NAME>
#define ZXDG_SHELL_V6_PONG_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_shell_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_create_positioner</NAME>
<RETURNS>struct zxdg_positioner_v6  *</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_get_xdg_surface</NAME>
<RETURNS>struct zxdg_surface_v6  *</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, struct wl_surface *surface
</FUNCTION>
<FUNCTION>
<NAME>zxdg_shell_v6_pong</NAME>
<RETURNS>void</RETURNS>
struct zxdg_shell_v6 *zxdg_shell_v6, uint32_t serial
</FUNCTION>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_ERROR_ENUM</NAME>
#define ZXDG_POSITIONER_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_error</NAME>
enum zxdg_positioner_v6_error {
	/**
	 * invalid input provided
	 */
	ZXDG_POSITIONER_V6_ERROR_INVALID_INPUT = 0,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_ANCHOR_ENUM</NAME>
#define ZXDG_POSITIONER_V6_ANCHOR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_anchor</NAME>
enum zxdg_positioner_v6_anchor {
	/**
	 * the center of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_NONE = 0,
	/**
	 * the top edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_TOP = 1,
	/**
	 * the bottom edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_BOTTOM = 2,
	/**
	 * the left edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_LEFT = 4,
	/**
	 * the right edge of the anchor rectangle
	 */
	ZXDG_POSITIONER_V6_ANCHOR_RIGHT = 8,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_GRAVITY_ENUM</NAME>
#define ZXDG_POSITIONER_V6_GRAVITY_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_gravity</NAME>
enum zxdg_positioner_v6_gravity {
	/**
	 * center over the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_NONE = 0,
	/**
	 * position above the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_TOP = 1,
	/**
	 * position below the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_BOTTOM = 2,
	/**
	 * position to the left of the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_LEFT = 4,
	/**
	 * position to the right of the anchor edge
	 */
	ZXDG_POSITIONER_V6_GRAVITY_RIGHT = 8,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_ENUM</NAME>
#define ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_positioner_v6_constraint_adjustment</NAME>
enum zxdg_positioner_v6_constraint_adjustment {
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_NONE = 0,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_X = 1,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_SLIDE_Y = 2,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_X = 4,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_FLIP_Y = 8,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_X = 16,
	ZXDG_POSITIONER_V6_CONSTRAINT_ADJUSTMENT_RESIZE_Y = 32,
};
</ENUM>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_DESTROY</NAME>
#define ZXDG_POSITIONER_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_SIZE</NAME>
#define ZXDG_POSITIONER_V6_SET_SIZE 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR_RECT</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR_RECT 2
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR 3
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_GRAVITY</NAME>
#define ZXDG_POSITIONER_V6_SET_GRAVITY 4
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT</NAME>
#define ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT 5
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_OFFSET</NAME>
#define ZXDG_POSITIONER_V6_SET_OFFSET 6
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_SIZE_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR_RECT_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR_RECT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_ANCHOR_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_ANCHOR_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_GRAVITY_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_GRAVITY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_CONSTRAINT_ADJUSTMENT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POSITIONER_V6_SET_OFFSET_SINCE_VERSION</NAME>
#define ZXDG_POSITIONER_V6_SET_OFFSET_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_size</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_anchor_rect</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_anchor</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t anchor
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_gravity</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t gravity
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_constraint_adjustment</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, uint32_t constraint_adjustment
</FUNCTION>
<FUNCTION>
<NAME>zxdg_positioner_v6_set_offset</NAME>
<RETURNS>void</RETURNS>
struct zxdg_positioner_v6 *zxdg_positioner_v6, int32_t x, int32_t y
</FUNCTION>
<MACRO>
<NAME>ZXDG_SURFACE_V6_ERROR_ENUM</NAME>
#define ZXDG_SURFACE_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_surface_v6_error</NAME>
enum zxdg_surface_v6_error {
	ZXDG_SURFACE_V6_ERROR_NOT_CONSTRUCTED = 1,
	ZXDG_SURFACE_V6_ERROR_ALREADY_CONSTRUCTED = 2,
	ZXDG_SURFACE_V6_ERROR_UNCONFIGURED_BUFFER = 3,
};
</ENUM>
<STRUCT>
<NAME>zxdg_surface_v6_listener</NAME>
struct zxdg_surface_v6_listener {
	/**
	 * suggest a surface change
	 *
	 * The configure event marks the end of a configure sequence. A
	 * configure sequence is a set of one or more events configuring
	 * the state of the xdg_surface, including the final
	 * xdg_surface.configure event.
	 *
	 * Where applicable, xdg_surface surface roles will during a
	 * configure sequence extend this event as a latched state sent as
	 * events before the xdg_surface.configure event. Such events
	 * should be considered to make up a set of atomically applied
	 * configuration states, where the xdg_surface.configure commits
	 * the accumulated state.
	 *
	 * Clients should arrange their surface for the new states, and
	 * then send an ack_configure request with the serial sent in this
	 * configure event at some point before committing the new surface.
	 *
	 * If the client receives multiple configure events before it can
	 * respond to one, it is free to discard all but the last event it
	 * received.
	 * @param serial serial of the configure event
	 */
	void (*configure)(void *data,
			  struct zxdg_surface_v6 *zxdg_surface_v6,
			  uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_surface_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, const struct zxdg_surface_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_SURFACE_V6_DESTROY</NAME>
#define ZXDG_SURFACE_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_TOPLEVEL</NAME>
#define ZXDG_SURFACE_V6_GET_TOPLEVEL 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_POPUP</NAME>
#define ZXDG_SURFACE_V6_GET_POPUP 2
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY</NAME>
#define ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY 3
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_ACK_CONFIGURE</NAME>
#define ZXDG_SURFACE_V6_ACK_CONFIGURE 4
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_TOPLEVEL_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_GET_TOPLEVEL_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_GET_POPUP_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_GET_POPUP_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_SET_WINDOW_GEOMETRY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_SURFACE_V6_ACK_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_SURFACE_V6_ACK_CONFIGURE_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_surface_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_toplevel</NAME>
<RETURNS>struct zxdg_toplevel_v6  *</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_get_popup</NAME>
<RETURNS>struct zxdg_popup_v6  *</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, struct zxdg_surface_v6 *parent, struct zxdg_positioner_v6 *positioner
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_set_window_geometry</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_surface_v6_ack_configure</NAME>
<RETURNS>void</RETURNS>
struct zxdg_surface_v6 *zxdg_surface_v6, uint32_t serial
</FUNCTION>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_RESIZE_EDGE_ENUM</NAME>
#define ZXDG_TOPLEVEL_V6_RESIZE_EDGE_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_toplevel_v6_resize_edge</NAME>
enum zxdg_toplevel_v6_resize_edge {
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_NONE = 0,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP = 1,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM = 2,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_LEFT = 4,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_LEFT = 5,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_LEFT = 6,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_RIGHT = 8,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_RIGHT = 9,
	ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_RIGHT = 10,
};
</ENUM>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_STATE_ENUM</NAME>
#define ZXDG_TOPLEVEL_V6_STATE_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_toplevel_v6_state</NAME>
enum zxdg_toplevel_v6_state {
	/**
	 * the surface is maximized
	 */
	ZXDG_TOPLEVEL_V6_STATE_MAXIMIZED = 1,
	/**
	 * the surface is fullscreen
	 */
	ZXDG_TOPLEVEL_V6_STATE_FULLSCREEN = 2,
	/**
	 * the surface is being resized
	 */
	ZXDG_TOPLEVEL_V6_STATE_RESIZING = 3,
	/**
	 * the surface is now activated
	 */
	ZXDG_TOPLEVEL_V6_STATE_ACTIVATED = 4,
};
</ENUM>
<STRUCT>
<NAME>zxdg_toplevel_v6_listener</NAME>
struct zxdg_toplevel_v6_listener {
	/**
	 * suggest a surface change
	 *
	 * This configure event asks the client to resize its toplevel
	 * surface or to change its state. The configured state should not
	 * be applied immediately. See xdg_surface.configure for details.
	 *
	 * The width and height arguments specify a hint to the window
	 * about how its surface should be resized in window geometry
	 * coordinates. See set_window_geometry.
	 *
	 * If the width or height arguments are zero, it means the client
	 * should decide its own window dimension. This may happen when the
	 * compositor needs to configure the state of the surface but
	 * doesn't have any information about any previous or expected
	 * dimension.
	 *
	 * The states listed in the event specify how the width/height
	 * arguments should be interpreted, and possibly how it should be
	 * drawn.
	 *
	 * Clients must send an ack_configure in response to this event.
	 * See xdg_surface.configure and xdg_surface.ack_configure for
	 * details.
	 */
	void (*configure)(void *data,
			  struct zxdg_toplevel_v6 *zxdg_toplevel_v6,
			  int32_t width,
			  int32_t height,
			  struct wl_array *states);
	/**
	 * surface wants to be closed
	 *
	 * The close event is sent by the compositor when the user wants
	 * the surface to be closed. This should be equivalent to the user
	 * clicking the close button in client-side decorations, if your
	 * application has any.
	 *
	 * This is only a request that the user intends to close the
	 * window. The client may choose to ignore this request, or show a
	 * dialog to ask the user to save their data, etc.
	 */
	void (*close)(void *data,
		      struct zxdg_toplevel_v6 *zxdg_toplevel_v6);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_toplevel_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const struct zxdg_toplevel_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_DESTROY</NAME>
#define ZXDG_TOPLEVEL_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_PARENT</NAME>
#define ZXDG_TOPLEVEL_V6_SET_PARENT 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_TITLE</NAME>
#define ZXDG_TOPLEVEL_V6_SET_TITLE 2
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_APP_ID</NAME>
#define ZXDG_TOPLEVEL_V6_SET_APP_ID 3
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU</NAME>
#define ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU 4
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_MOVE</NAME>
#define ZXDG_TOPLEVEL_V6_MOVE 5
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_RESIZE</NAME>
#define ZXDG_TOPLEVEL_V6_RESIZE 6
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAX_SIZE</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAX_SIZE 7
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MIN_SIZE</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MIN_SIZE 8
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAXIMIZED</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAXIMIZED 9
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED 10
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_FULLSCREEN</NAME>
#define ZXDG_TOPLEVEL_V6_SET_FULLSCREEN 11
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN 12
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MINIMIZED</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MINIMIZED 13
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_CLOSE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_CLOSE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_PARENT_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_PARENT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_TITLE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_TITLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_APP_ID_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_APP_ID_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SHOW_WINDOW_MENU_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_MOVE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_MOVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_RESIZE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_RESIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAX_SIZE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAX_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MIN_SIZE_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MIN_SIZE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MAXIMIZED_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MAXIMIZED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_MAXIMIZED_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_FULLSCREEN_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_FULLSCREEN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_UNSET_FULLSCREEN_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_TOPLEVEL_V6_SET_MINIMIZED_SINCE_VERSION</NAME>
#define ZXDG_TOPLEVEL_V6_SET_MINIMIZED_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_parent</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct zxdg_toplevel_v6 *parent
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_title</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const char *title
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_app_id</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, const char *app_id
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_show_window_menu</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial, int32_t x, int32_t y
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_move</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_resize</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_seat *seat, uint32_t serial, uint32_t edges
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_max_size</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_min_size</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_maximized</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_unset_maximized</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_fullscreen</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6, struct wl_output *output
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_unset_fullscreen</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_toplevel_v6_set_minimized</NAME>
<RETURNS>void</RETURNS>
struct zxdg_toplevel_v6 *zxdg_toplevel_v6
</FUNCTION>
<MACRO>
<NAME>ZXDG_POPUP_V6_ERROR_ENUM</NAME>
#define ZXDG_POPUP_V6_ERROR_ENUM
</MACRO>
<ENUM>
<NAME>zxdg_popup_v6_error</NAME>
enum zxdg_popup_v6_error {
	/**
	 * tried to grab after being mapped
	 */
	ZXDG_POPUP_V6_ERROR_INVALID_GRAB = 0,
};
</ENUM>
<STRUCT>
<NAME>zxdg_popup_v6_listener</NAME>
struct zxdg_popup_v6_listener {
	/**
	 * configure the popup surface
	 *
	 * This event asks the popup surface to configure itself given
	 * the configuration. The configured state should not be applied
	 * immediately. See xdg_surface.configure for details.
	 *
	 * The x and y arguments represent the position the popup was
	 * placed at given the xdg_positioner rule, relative to the upper
	 * left corner of the window geometry of the parent surface.
	 * @param x x position relative to parent surface window geometry
	 * @param y y position relative to parent surface window geometry
	 * @param width window geometry width
	 * @param height window geometry height
	 */
	void (*configure)(void *data,
			  struct zxdg_popup_v6 *zxdg_popup_v6,
			  int32_t x,
			  int32_t y,
			  int32_t width,
			  int32_t height);
	/**
	 * popup interaction is done
	 *
	 * The popup_done event is sent out when a popup is dismissed by
	 * the compositor. The client should destroy the xdg_popup object
	 * at this point.
	 */
	void (*popup_done)(void *data,
			   struct zxdg_popup_v6 *zxdg_popup_v6);
};
</STRUCT>
<FUNCTION>
<NAME>zxdg_popup_v6_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6, const struct zxdg_popup_v6_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZXDG_POPUP_V6_DESTROY</NAME>
#define ZXDG_POPUP_V6_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_GRAB</NAME>
#define ZXDG_POPUP_V6_GRAB 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_CONFIGURE_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_CONFIGURE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_POPUP_DONE_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_POPUP_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_DESTROY_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZXDG_POPUP_V6_GRAB_SINCE_VERSION</NAME>
#define ZXDG_POPUP_V6_GRAB_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zxdg_popup_v6_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_destroy</NAME>
<RETURNS>void</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6
</FUNCTION>
<FUNCTION>
<NAME>zxdg_popup_v6_grab</NAME>
<RETURNS>void</RETURNS>
struct zxdg_popup_v6 *zxdg_popup_v6, struct wl_seat *seat, uint32_t serial
</FUNCTION>
<STRUCT>
<NAME>wl_output</NAME>
struct wl_output;
</STRUCT>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zxdg_popup_v6</NAME>
struct zxdg_popup_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_positioner_v6</NAME>
struct zxdg_positioner_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_shell_v6</NAME>
struct zxdg_shell_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_surface_v6</NAME>
struct zxdg_surface_v6;
</STRUCT>
<STRUCT>
<NAME>zxdg_toplevel_v6</NAME>
struct zxdg_toplevel_v6;
</STRUCT>
