<FUNCTION>
<NAME>g_settings_set_mapping</NAME>
<RETURNS>GVariant *</RETURNS>
const GValue       *value, const GVariantType *expected_type, gpointer            user_data
</FUNCTION>
<FUNCTION>
<NAME>g_settings_get_mapping</NAME>
<RETURNS>gboolean</RETURNS>
GValue             *value, GVariant           *variant, gpointer            user_data
</FUNCTION>
<FUNCTION>
<NAME>g_settings_mapping_is_compatible</NAME>
<RETURNS>gboolean</RETURNS>
GType               gvalue_type, const GVariantType *variant_type
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_PANGO_RENDERER</NAME>
#define GSK_TYPE_PANGO_RENDERER            (gsk_pango_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_PANGO_RENDERER</NAME>
#define GSK_PANGO_RENDERER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_PANGO_RENDERER, GskPangoRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_PANGO_RENDERER</NAME>
#define GSK_IS_PANGO_RENDERER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_PANGO_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_PANGO_RENDERER_CLASS</NAME>
#define GSK_PANGO_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_PANGO_RENDERER, GskPangoRendererClass))
</MACRO>
<MACRO>
<NAME>GSK_IS_PANGO_RENDERER_CLASS</NAME>
#define GSK_IS_PANGO_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_PANGO_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_PANGO_RENDERER_GET_CLASS</NAME>
#define GSK_PANGO_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_PANGO_RENDERER, GskPangoRendererClass))
</MACRO>
<ENUM>
<NAME>GskPangoRendererState</NAME>
typedef enum
{
  GSK_PANGO_RENDERER_NORMAL,
  GSK_PANGO_RENDERER_SELECTED,
  GSK_PANGO_RENDERER_CURSOR
} GskPangoRendererState;
</ENUM>
<USER_FUNCTION>
<NAME>GskPangoShapeHandler</NAME>
<RETURNS>gboolean</RETURNS>
PangoAttrShape         *attr, GdkSnapshot            *snapshot, double                  width, double                  height
</USER_FUNCTION>
<STRUCT>
<NAME>GskPangoRenderer</NAME>
struct _GskPangoRenderer
{
  PangoRenderer          parent_instance;

  GtkWidget             *widget;
  GtkSnapshot           *snapshot;
  GdkRGBA                fg_color;
  graphene_rect_t        bounds;

  /* Error underline color for this widget */
  GdkRGBA               *error_color;

  GskPangoRendererState  state;
  GskPangoShapeHandler shape_handler;

  /* house-keeping options */
  guint                  is_cached_renderer : 1;
};
</STRUCT>
<STRUCT>
<NAME>GskPangoRendererClass</NAME>
struct _GskPangoRendererClass
{
  PangoRendererClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_pango_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_pango_renderer_set_state</NAME>
<RETURNS>void</RETURNS>
GskPangoRenderer      *crenderer, GskPangoRendererState  state
</FUNCTION>
<FUNCTION>
<NAME>gsk_pango_renderer_set_shape_handler</NAME>
<RETURNS>void</RETURNS>
GskPangoRenderer      *crenderer, GskPangoShapeHandler handler
</FUNCTION>
<FUNCTION>
<NAME>gsk_pango_renderer_acquire</NAME>
<RETURNS>GskPangoRenderer *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_pango_renderer_release</NAME>
<RETURNS>void</RETURNS>
GskPangoRenderer      *crenderer
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ABOUT_DIALOG</NAME>
#define GTK_TYPE_ABOUT_DIALOG            (gtk_about_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ABOUT_DIALOG</NAME>
#define GTK_ABOUT_DIALOG(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_ABOUT_DIALOG, GtkAboutDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_ABOUT_DIALOG</NAME>
#define GTK_IS_ABOUT_DIALOG(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_ABOUT_DIALOG))
</MACRO>
<ENUM>
<NAME>GtkLicense</NAME>
typedef enum {
  GTK_LICENSE_UNKNOWN,
  GTK_LICENSE_CUSTOM,

  GTK_LICENSE_GPL_2_0,
  GTK_LICENSE_GPL_3_0,

  GTK_LICENSE_LGPL_2_1,
  GTK_LICENSE_LGPL_3_0,

  GTK_LICENSE_BSD,
  GTK_LICENSE_MIT_X11,

  GTK_LICENSE_ARTISTIC,

  GTK_LICENSE_GPL_2_0_ONLY,
  GTK_LICENSE_GPL_3_0_ONLY,
  GTK_LICENSE_LGPL_2_1_ONLY,
  GTK_LICENSE_LGPL_3_0_ONLY,

  GTK_LICENSE_AGPL_3_0,
  GTK_LICENSE_AGPL_3_0_ONLY,

  GTK_LICENSE_BSD_3,
  GTK_LICENSE_APACHE_2_0,
  GTK_LICENSE_MPL_2_0
} GtkLicense;
</ENUM>
<FUNCTION>
<NAME>gtk_about_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_show_about_dialog</NAME>
<RETURNS>void</RETURNS>
GtkWindow       *parent, const gchar     *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_program_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_program_name</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_version</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_version</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *version
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_copyright</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_copyright</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *copyright
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_comments</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_comments</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *comments
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_license</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_license</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *license
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_license_type</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, GtkLicense       license_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_license_type</NAME>
<RETURNS>GtkLicense</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_wrap_license</NAME>
<RETURNS>gboolean</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_wrap_license</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, gboolean         wrap_license
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_system_information</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_system_information</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *system_information
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_website</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_website</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *website
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_website_label</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_website_label</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *website_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_authors</NAME>
<RETURNS>const gchar * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_authors</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar    **authors
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_documenters</NAME>
<RETURNS>const gchar * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_documenters</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar    **documenters
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_artists</NAME>
<RETURNS>const gchar * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_artists</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar    **artists
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_translator_credits</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_translator_credits</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *translator_credits
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_logo</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_logo</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, GdkPaintable    *logo
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_logo_icon_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_logo_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_add_credit_section</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const gchar     *section_name, const gchar    **people
</FUNCTION>
<STRUCT>
<NAME>GtkAboutDialog</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_accelerator_valid</NAME>
<RETURNS>gboolean</RETURNS>
guint	        keyval, GdkModifierType  modifiers
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_parse</NAME>
<RETURNS>gboolean</RETURNS>
const gchar     *accelerator, guint	       *accelerator_key, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_parse_with_keycode</NAME>
<RETURNS>gboolean</RETURNS>
const gchar     *accelerator, GdkDisplay      *display, guint           *accelerator_key, guint          **accelerator_codes, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_name</NAME>
<RETURNS>gchar *</RETURNS>
guint	        accelerator_key, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_name_with_keycode</NAME>
<RETURNS>gchar *</RETURNS>
GdkDisplay      *display, guint            accelerator_key, guint            keycode, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_label</NAME>
<RETURNS>gchar *</RETURNS>
guint           accelerator_key, GdkModifierType accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_label_with_keycode</NAME>
<RETURNS>gchar *</RETURNS>
GdkDisplay      *display, guint            accelerator_key, guint            keycode, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_default_mod_mask</NAME>
<RETURNS>GdkModifierType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ACCEL_LABEL</NAME>
#define GTK_TYPE_ACCEL_LABEL		(gtk_accel_label_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_LABEL</NAME>
#define GTK_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabel))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCEL_LABEL</NAME>
#define GTK_IS_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCEL_LABEL))
</MACRO>
<FUNCTION>
<NAME>gtk_accel_label_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar   *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_accel_width</NAME>
<RETURNS>guint</RETURNS>
GtkAccelLabel *accel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_refetch</NAME>
<RETURNS>gboolean</RETURNS>
GtkAccelLabel *accel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_accel</NAME>
<RETURNS>void</RETURNS>
GtkAccelLabel   *accel_label, guint            accelerator_key, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_accel</NAME>
<RETURNS>void</RETURNS>
GtkAccelLabel   *accel_label, guint           *accelerator_key, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_label</NAME>
<RETURNS>void</RETURNS>
GtkAccelLabel   *accel_label, const char      *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_label</NAME>
<RETURNS>const char *</RETURNS>
GtkAccelLabel   *accel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_use_underline</NAME>
<RETURNS>void</RETURNS>
GtkAccelLabel   *accel_label, gboolean         setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_use_underline</NAME>
<RETURNS>gboolean</RETURNS>
GtkAccelLabel   *accel_label
</FUNCTION>
<STRUCT>
<NAME>GtkAccelLabel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_ACCEL_LABEL_GET_CLASS</NAME>
#define GTK_ACCEL_LABEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabelClass))
</MACRO>
<STRUCT>
<NAME>GtkAccelLabelClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE</NAME>
#define GTK_TYPE_ACCESSIBLE                  (gtk_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACCESSIBLE</NAME>
#define GTK_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessible))
</MACRO>
<MACRO>
<NAME>GTK_ACCESSIBLE_CLASS</NAME>
#define GTK_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCESSIBLE</NAME>
#define GTK_IS_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkAccessible</NAME>
struct _GtkAccessible
{
  AtkObject parent;

  /*< private >*/
  GtkAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkAccessibleClass</NAME>
struct _GtkAccessibleClass
{
  AtkObjectClass parent_class;

  void (*widget_set)               (GtkAccessible *accessible);
  void (*widget_unset)             (GtkAccessible *accessible);
  /* Padding for future expansion */
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_set_widget</NAME>
<RETURNS>void</RETURNS>
GtkAccessible *accessible, GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_get_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAccessible *accessible
</FUNCTION>
<STRUCT>
<NAME>GtkAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACTIONABLE</NAME>
#define GTK_TYPE_ACTIONABLE                                 (gtk_actionable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACTIONABLE</NAME>
#define GTK_ACTIONABLE(inst)                                (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
                                                             GTK_TYPE_ACTIONABLE, GtkActionable))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACTIONABLE</NAME>
#define GTK_IS_ACTIONABLE(inst)                             (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
                                                             GTK_TYPE_ACTIONABLE))
</MACRO>
<MACRO>
<NAME>GTK_ACTIONABLE_GET_IFACE</NAME>
#define GTK_ACTIONABLE_GET_IFACE(inst)                      (G_TYPE_INSTANCE_GET_INTERFACE ((inst),                  \
                                                             GTK_TYPE_ACTIONABLE, GtkActionableInterface))
</MACRO>
<STRUCT>
<NAME>GtkActionableInterface</NAME>
struct _GtkActionableInterface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

  const gchar * (* get_action_name)             (GtkActionable *actionable);
  void          (* set_action_name)             (GtkActionable *actionable,
                                                 const gchar   *action_name);
  GVariant *    (* get_action_target_value)     (GtkActionable *actionable);
  void          (* set_action_target_value)     (GtkActionable *actionable,
                                                 GVariant      *target_value);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_actionable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_get_action_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkActionable *actionable
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_action_name</NAME>
<RETURNS>void</RETURNS>
GtkActionable *actionable, const gchar   *action_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_get_action_target_value</NAME>
<RETURNS>GVariant *</RETURNS>
GtkActionable *actionable
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_action_target_value</NAME>
<RETURNS>void</RETURNS>
GtkActionable *actionable, GVariant      *target_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_action_target</NAME>
<RETURNS>void</RETURNS>
GtkActionable *actionable, const gchar   *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_detailed_action_name</NAME>
<RETURNS>void</RETURNS>
GtkActionable *actionable, const gchar   *detailed_action_name
</FUNCTION>
<STRUCT>
<NAME>GtkActionable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACTION_BAR</NAME>
#define GTK_TYPE_ACTION_BAR            (gtk_action_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACTION_BAR</NAME>
#define GTK_ACTION_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACTION_BAR, GtkActionBar))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACTION_BAR</NAME>
#define GTK_IS_ACTION_BAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACTION_BAR))
</MACRO>
<FUNCTION>
<NAME>gtk_action_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_get_center_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkActionBar *action_bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_set_center_widget</NAME>
<RETURNS>void</RETURNS>
GtkActionBar *action_bar, GtkWidget    *center_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_pack_start</NAME>
<RETURNS>void</RETURNS>
GtkActionBar *action_bar, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_pack_end</NAME>
<RETURNS>void</RETURNS>
GtkActionBar *action_bar, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_remove</NAME>
<RETURNS>void</RETURNS>
GtkActionBar *action_bar, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_set_revealed</NAME>
<RETURNS>void</RETURNS>
GtkActionBar *action_bar, gboolean      revealed
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_bar_get_revealed</NAME>
<RETURNS>gboolean</RETURNS>
GtkActionBar *action_bar
</FUNCTION>
<STRUCT>
<NAME>GtkActionBar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACTION_OBSERVABLE</NAME>
#define GTK_TYPE_ACTION_OBSERVABLE                          (gtk_action_observable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACTION_OBSERVABLE</NAME>
#define GTK_ACTION_OBSERVABLE(inst)                         (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
                                                             GTK_TYPE_ACTION_OBSERVABLE, GtkActionObservable))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACTION_OBSERVABLE</NAME>
#define GTK_IS_ACTION_OBSERVABLE(inst)                      (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
                                                             GTK_TYPE_ACTION_OBSERVABLE))
</MACRO>
<MACRO>
<NAME>GTK_ACTION_OBSERVABLE_GET_IFACE</NAME>
#define GTK_ACTION_OBSERVABLE_GET_IFACE(inst)               (G_TYPE_INSTANCE_GET_INTERFACE ((inst),                  \
                                                             GTK_TYPE_ACTION_OBSERVABLE,                             \
                                                             GtkActionObservableInterface))
</MACRO>
<STRUCT>
<NAME>GtkActionObservableInterface</NAME>
struct _GtkActionObservableInterface
{
  GTypeInterface g_iface;

  void (* register_observer)   (GtkActionObservable *observable,
                                const gchar         *action_name,
                                GtkActionObserver   *observer);
  void (* unregister_observer) (GtkActionObservable *observable,
                                const gchar         *action_name,
                                GtkActionObserver   *observer);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_action_observable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_observable_register_observer</NAME>
<RETURNS>void</RETURNS>
GtkActionObservable *observable, const gchar         *action_name, GtkActionObserver   *observer
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_observable_unregister_observer</NAME>
<RETURNS>void</RETURNS>
GtkActionObservable *observable, const gchar         *action_name, GtkActionObserver   *observer
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ACTION_OBSERVER</NAME>
#define GTK_TYPE_ACTION_OBSERVER                            (gtk_action_observer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACTION_OBSERVER</NAME>
#define GTK_ACTION_OBSERVER(inst)                           (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
                                                             GTK_TYPE_ACTION_OBSERVER, GtkActionObserver))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACTION_OBSERVER</NAME>
#define GTK_IS_ACTION_OBSERVER(inst)                        (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
                                                             GTK_TYPE_ACTION_OBSERVER))
</MACRO>
<MACRO>
<NAME>GTK_ACTION_OBSERVER_GET_IFACE</NAME>
#define GTK_ACTION_OBSERVER_GET_IFACE(inst)                 (G_TYPE_INSTANCE_GET_INTERFACE ((inst),                  \
                                                             GTK_TYPE_ACTION_OBSERVER, GtkActionObserverInterface))
</MACRO>
<STRUCT>
<NAME>GtkActionObserverInterface</NAME>
struct _GtkActionObserverInterface
{
  GTypeInterface g_iface;

  void (* action_added)           (GtkActionObserver    *observer,
                                   GtkActionObservable  *observable,
                                   const gchar          *action_name,
                                   const GVariantType   *parameter_type,
                                   gboolean              enabled,
                                   GVariant             *state);
  void (* action_enabled_changed) (GtkActionObserver    *observer,
                                   GtkActionObservable  *observable,
                                   const gchar          *action_name,
                                   gboolean              enabled);
  void (* action_state_changed)   (GtkActionObserver    *observer,
                                   GtkActionObservable  *observable,
                                   const gchar          *action_name,
                                   GVariant             *state);
  void (* action_removed)         (GtkActionObserver    *observer,
                                   GtkActionObservable  *observable,
                                   const gchar          *action_name);
  void (* primary_accel_changed)  (GtkActionObserver    *observer,
                                   GtkActionObservable  *observable,
                                   const gchar          *action_name,
                                   const gchar          *action_and_target);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_action_observer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_observer_action_added</NAME>
<RETURNS>void</RETURNS>
GtkActionObserver   *observer, GtkActionObservable *observable, const gchar         *action_name, const GVariantType  *parameter_type, gboolean             enabled, GVariant            *state
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_observer_action_enabled_changed</NAME>
<RETURNS>void</RETURNS>
GtkActionObserver   *observer, GtkActionObservable *observable, const gchar         *action_name, gboolean             enabled
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_observer_action_state_changed</NAME>
<RETURNS>void</RETURNS>
GtkActionObserver   *observer, GtkActionObservable *observable, const gchar         *action_name, GVariant            *state
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_observer_action_removed</NAME>
<RETURNS>void</RETURNS>
GtkActionObserver   *observer, GtkActionObservable *observable, const gchar         *action_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_action_observer_primary_accel_changed</NAME>
<RETURNS>void</RETURNS>
GtkActionObserver   *observer, GtkActionObservable *observable, const gchar         *action_name, const gchar         *action_and_target
</FUNCTION>
<STRUCT>
<NAME>GtkActionObservable</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkActionObserver</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ADJUSTMENT</NAME>
#define GTK_TYPE_ADJUSTMENT                  (gtk_adjustment_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ADJUSTMENT</NAME>
#define GTK_ADJUSTMENT(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ADJUSTMENT, GtkAdjustment))
</MACRO>
<MACRO>
<NAME>GTK_ADJUSTMENT_CLASS</NAME>
#define GTK_ADJUSTMENT_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ADJUSTMENT, GtkAdjustmentClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ADJUSTMENT</NAME>
#define GTK_IS_ADJUSTMENT(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ADJUSTMENT))
</MACRO>
<MACRO>
<NAME>GTK_IS_ADJUSTMENT_CLASS</NAME>
#define GTK_IS_ADJUSTMENT_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ADJUSTMENT))
</MACRO>
<MACRO>
<NAME>GTK_ADJUSTMENT_GET_CLASS</NAME>
#define GTK_ADJUSTMENT_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ADJUSTMENT, GtkAdjustmentClass))
</MACRO>
<STRUCT>
<NAME>GtkAdjustment</NAME>
struct _GtkAdjustment
{
  GInitiallyUnowned parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkAdjustmentClass</NAME>
struct _GtkAdjustmentClass
{
  GInitiallyUnownedClass parent_class;

  void (* changed)       (GtkAdjustment *adjustment);
  void (* value_changed) (GtkAdjustment *adjustment);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_adjustment_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_new</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
gdouble          value, gdouble          lower, gdouble          upper, gdouble          step_increment, gdouble          page_increment, gdouble          page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_clamp_page</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          lower, gdouble          upper
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_value</NAME>
<RETURNS>gdouble</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_value</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          value
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_lower</NAME>
<RETURNS>gdouble</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_lower</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          lower
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_upper</NAME>
<RETURNS>gdouble</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_upper</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          upper
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_step_increment</NAME>
<RETURNS>gdouble</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_step_increment</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          step_increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_page_increment</NAME>
<RETURNS>gdouble</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_page_increment</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          page_increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_page_size</NAME>
<RETURNS>gdouble</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_page_size</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_configure</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, gdouble          value, gdouble          lower, gdouble          upper, gdouble          step_increment, gdouble          page_increment, gdouble          page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_minimum_increment</NAME>
<RETURNS>gdouble</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_APP_CHOOSER</NAME>
#define GTK_TYPE_APP_CHOOSER    (gtk_app_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER</NAME>
#define GTK_APP_CHOOSER(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_APP_CHOOSER, GtkAppChooser))
</MACRO>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER</NAME>
#define GTK_IS_APP_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_APP_CHOOSER))
</MACRO>
<FUNCTION>
<NAME>gtk_app_chooser_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_get_app_info</NAME>
<RETURNS>GAppInfo *</RETURNS>
GtkAppChooser *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_get_content_type</NAME>
<RETURNS>gchar *</RETURNS>
GtkAppChooser *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_refresh</NAME>
<RETURNS>void</RETURNS>
GtkAppChooser *self
</FUNCTION>
<STRUCT>
<NAME>GtkAppChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_APP_CHOOSER_BUTTON</NAME>
#define GTK_TYPE_APP_CHOOSER_BUTTON            (gtk_app_chooser_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_BUTTON</NAME>
#define GTK_APP_CHOOSER_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_APP_CHOOSER_BUTTON, GtkAppChooserButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER_BUTTON</NAME>
#define GTK_IS_APP_CHOOSER_BUTTON(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_APP_CHOOSER_BUTTON))
</MACRO>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar         *content_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_append_separator</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_append_custom_item</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self, const gchar         *name, const gchar         *label, GIcon               *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_active_custom_item</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_show_dialog_item</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_show_dialog_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_heading</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self, const gchar         *heading
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_heading</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_show_default_item</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_show_default_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_modal</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_modal</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self, gboolean             modal
</FUNCTION>
<STRUCT>
<NAME>GtkAppChooserButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_APP_CHOOSER_DIALOG</NAME>
#define GTK_TYPE_APP_CHOOSER_DIALOG            (gtk_app_chooser_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_DIALOG</NAME>
#define GTK_APP_CHOOSER_DIALOG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_APP_CHOOSER_DIALOG, GtkAppChooserDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER_DIALOG</NAME>
#define GTK_IS_APP_CHOOSER_DIALOG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_APP_CHOOSER_DIALOG))
</MACRO>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow           *parent, GtkDialogFlags       flags, GFile               *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_new_for_content_type</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow           *parent, GtkDialogFlags       flags, const gchar         *content_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_get_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAppChooserDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_set_heading</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserDialog *self, const gchar         *heading
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_get_heading</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAppChooserDialog *self
</FUNCTION>
<STRUCT>
<NAME>GtkAppChooserDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_APP_CHOOSER_WIDGET</NAME>
#define GTK_TYPE_APP_CHOOSER_WIDGET            (gtk_app_chooser_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_WIDGET</NAME>
#define GTK_APP_CHOOSER_WIDGET(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_APP_CHOOSER_WIDGET, GtkAppChooserWidget))
</MACRO>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER_WIDGET</NAME>
#define GTK_IS_APP_CHOOSER_WIDGET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_APP_CHOOSER_WIDGET))
</MACRO>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar         *content_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_default</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_default</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_recommended</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_recommended</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_fallback</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_fallback</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_other</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_other</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_all</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_all</NAME>
<RETURNS>gboolean</RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_default_text</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserWidget *self, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_default_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<STRUCT>
<NAME>GtkAppChooserWidget</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_APPLICATION</NAME>
#define GTK_TYPE_APPLICATION            (gtk_application_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION</NAME>
#define GTK_APPLICATION(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_APPLICATION, GtkApplication))
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_CLASS</NAME>
#define GTK_APPLICATION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_APPLICATION, GtkApplicationClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_APPLICATION</NAME>
#define GTK_IS_APPLICATION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_APPLICATION))
</MACRO>
<MACRO>
<NAME>GTK_IS_APPLICATION_CLASS</NAME>
#define GTK_IS_APPLICATION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_APPLICATION))
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_GET_CLASS</NAME>
#define GTK_APPLICATION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_APPLICATION, GtkApplicationClass))
</MACRO>
<STRUCT>
<NAME>GtkApplication</NAME>
struct _GtkApplication
{
  GApplication parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkApplicationClass</NAME>
struct _GtkApplicationClass
{
  GApplicationClass parent_class;

  /*< public >*/

  void (*window_added)   (GtkApplication *application,
                          GtkWindow      *window);
  void (*window_removed) (GtkApplication *application,
                          GtkWindow      *window);

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_application_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_new</NAME>
<RETURNS>GtkApplication *</RETURNS>
const gchar       *application_id, GApplicationFlags  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_add_window</NAME>
<RETURNS>void</RETURNS>
GtkApplication    *application, GtkWindow         *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_remove_window</NAME>
<RETURNS>void</RETURNS>
GtkApplication    *application, GtkWindow         *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_windows</NAME>
<RETURNS>GList *</RETURNS>
GtkApplication    *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_app_menu</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkApplication    *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_set_app_menu</NAME>
<RETURNS>void</RETURNS>
GtkApplication    *application, GMenuModel        *app_menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_menubar</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkApplication    *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_set_menubar</NAME>
<RETURNS>void</RETURNS>
GtkApplication    *application, GMenuModel        *menubar
</FUNCTION>
<ENUM>
<NAME>GtkApplicationInhibitFlags</NAME>
typedef enum
{
  GTK_APPLICATION_INHIBIT_LOGOUT  = (1 << 0),
  GTK_APPLICATION_INHIBIT_SWITCH  = (1 << 1),
  GTK_APPLICATION_INHIBIT_SUSPEND = (1 << 2),
  GTK_APPLICATION_INHIBIT_IDLE    = (1 << 3)
} GtkApplicationInhibitFlags;
</ENUM>
<FUNCTION>
<NAME>gtk_application_inhibit</NAME>
<RETURNS>guint</RETURNS>
GtkApplication             *application, GtkWindow                  *window, GtkApplicationInhibitFlags  flags, const gchar                *reason
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_uninhibit</NAME>
<RETURNS>void</RETURNS>
GtkApplication             *application, guint                       cookie
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_window_by_id</NAME>
<RETURNS>GtkWindow *</RETURNS>
GtkApplication             *application, guint                       id
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_active_window</NAME>
<RETURNS>GtkWindow *</RETURNS>
GtkApplication             *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_list_action_descriptions</NAME>
<RETURNS>gchar **</RETURNS>
GtkApplication       *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_accels_for_action</NAME>
<RETURNS>gchar **</RETURNS>
GtkApplication       *application, const gchar          *detailed_action_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_actions_for_accel</NAME>
<RETURNS>gchar **</RETURNS>
GtkApplication       *application, const gchar          *accel
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_set_accels_for_action</NAME>
<RETURNS>void</RETURNS>
GtkApplication       *application, const gchar          *detailed_action_name, const gchar * const  *accels
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_prefers_app_menu</NAME>
<RETURNS>gboolean</RETURNS>
GtkApplication       *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_menu_by_id</NAME>
<RETURNS>GMenu *</RETURNS>
GtkApplication       *application, const gchar          *id
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_APPLICATION_WINDOW</NAME>
#define GTK_TYPE_APPLICATION_WINDOW            (gtk_application_window_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_WINDOW</NAME>
#define GTK_APPLICATION_WINDOW(inst)           (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
                                                GTK_TYPE_APPLICATION_WINDOW, GtkApplicationWindow))
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_WINDOW_CLASS</NAME>
#define GTK_APPLICATION_WINDOW_CLASS(class)    (G_TYPE_CHECK_CLASS_CAST ((class),   \
                                                GTK_TYPE_APPLICATION_WINDOW, GtkApplicationWindowClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_APPLICATION_WINDOW</NAME>
#define GTK_IS_APPLICATION_WINDOW(inst)        (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
                                                GTK_TYPE_APPLICATION_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_IS_APPLICATION_WINDOW_CLASS</NAME>
#define GTK_IS_APPLICATION_WINDOW_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class),   \
                                                GTK_TYPE_APPLICATION_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_WINDOW_GET_CLASS</NAME>
#define GTK_APPLICATION_WINDOW_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst),  \
                                                GTK_TYPE_APPLICATION_WINDOW, GtkApplicationWindowClass))
</MACRO>
<STRUCT>
<NAME>GtkApplicationWindow</NAME>
struct _GtkApplicationWindow
{
  GtkWindow parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkApplicationWindowClass</NAME>
struct _GtkApplicationWindowClass
{
  GtkWindowClass parent_class;

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_application_window_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_window_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkApplication      *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_window_set_show_menubar</NAME>
<RETURNS>void</RETURNS>
GtkApplicationWindow *window, gboolean              show_menubar
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_window_get_show_menubar</NAME>
<RETURNS>gboolean</RETURNS>
GtkApplicationWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_window_get_id</NAME>
<RETURNS>guint</RETURNS>
GtkApplicationWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_window_set_help_overlay</NAME>
<RETURNS>void</RETURNS>
GtkApplicationWindow *window, GtkShortcutsWindow   *help_overlay
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_window_get_help_overlay</NAME>
<RETURNS>GtkShortcutsWindow *</RETURNS>
GtkApplicationWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_array_init</NAME>
<RETURNS>void</RETURNS>
GtkArray   *self, void     **stack_space, guint      reserved_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_array_index</NAME>
<RETURNS>void *</RETURNS>
const GtkArray *self, guint           index
</FUNCTION>
<FUNCTION>
<NAME>gtk_array_add</NAME>
<RETURNS>void</RETURNS>
GtkArray *self, void     *element
</FUNCTION>
<FUNCTION>
<NAME>gtk_array_insert</NAME>
<RETURNS>void</RETURNS>
GtkArray *self, guint     index, void     *element
</FUNCTION>
<FUNCTION>
<NAME>gtk_array_free</NAME>
<RETURNS>void</RETURNS>
GtkArray       *self, GDestroyNotify  element_free_func
</FUNCTION>
<FUNCTION>
<NAME>gtk_array_get_data</NAME>
<RETURNS>void **</RETURNS>
GtkArray *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ASPECT_FRAME</NAME>
#define GTK_TYPE_ASPECT_FRAME            (gtk_aspect_frame_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ASPECT_FRAME</NAME>
#define GTK_ASPECT_FRAME(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ASPECT_FRAME, GtkAspectFrame))
</MACRO>
<MACRO>
<NAME>GTK_IS_ASPECT_FRAME</NAME>
#define GTK_IS_ASPECT_FRAME(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ASPECT_FRAME))
</MACRO>
<FUNCTION>
<NAME>gtk_aspect_frame_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
float            xalign, float            yalign, float            ratio, gboolean         obey_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_set_xalign</NAME>
<RETURNS>void</RETURNS>
GtkAspectFrame *self, float           xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_get_xalign</NAME>
<RETURNS>float</RETURNS>
GtkAspectFrame *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_set_yalign</NAME>
<RETURNS>void</RETURNS>
GtkAspectFrame *self, float           yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_get_yalign</NAME>
<RETURNS>float</RETURNS>
GtkAspectFrame *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_set_ratio</NAME>
<RETURNS>void</RETURNS>
GtkAspectFrame *self, float           ratio
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_get_ratio</NAME>
<RETURNS>float</RETURNS>
GtkAspectFrame *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_set_obey_child</NAME>
<RETURNS>void</RETURNS>
GtkAspectFrame *self, gboolean        obey_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_get_obey_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkAspectFrame *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_set_child</NAME>
<RETURNS>void</RETURNS>
GtkAspectFrame *self, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAspectFrame *self
</FUNCTION>
<STRUCT>
<NAME>GtkAspectFrame</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ASSISTANT</NAME>
#define GTK_TYPE_ASSISTANT         (gtk_assistant_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ASSISTANT</NAME>
#define GTK_ASSISTANT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_ASSISTANT, GtkAssistant))
</MACRO>
<MACRO>
<NAME>GTK_IS_ASSISTANT</NAME>
#define GTK_IS_ASSISTANT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_ASSISTANT))
</MACRO>
<ENUM>
<NAME>GtkAssistantPageType</NAME>
typedef enum
{
  GTK_ASSISTANT_PAGE_CONTENT,
  GTK_ASSISTANT_PAGE_INTRO,
  GTK_ASSISTANT_PAGE_CONFIRM,
  GTK_ASSISTANT_PAGE_SUMMARY,
  GTK_ASSISTANT_PAGE_PROGRESS,
  GTK_ASSISTANT_PAGE_CUSTOM
} GtkAssistantPageType;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_ASSISTANT_PAGE</NAME>
#define GTK_TYPE_ASSISTANT_PAGE (gtk_assistant_page_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ASSISTANT_PAGE</NAME>
#define GTK_ASSISTANT_PAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ASSISTANT_PAGE, GtkAssistantPage))
</MACRO>
<MACRO>
<NAME>GTK_IS_ASSISTANT_PAGE</NAME>
#define GTK_IS_ASSISTANT_PAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ASSISTANT_PAGE))
</MACRO>
<USER_FUNCTION>
<NAME>GtkAssistantPageFunc</NAME>
<RETURNS>gint</RETURNS>
gint current_page, gpointer data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_page_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_next_page</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_previous_page</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_current_page</NAME>
<RETURNS>gint</RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_current_page</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, gint                  page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_n_pages</NAME>
<RETURNS>gint</RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_nth_page</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAssistant         *assistant, gint                  page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_prepend_page</NAME>
<RETURNS>gint</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_append_page</NAME>
<RETURNS>gint</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_insert_page</NAME>
<RETURNS>gint</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, gint                  position
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_remove_page</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, gint                  page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_forward_page_func</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, GtkAssistantPageFunc  page_func, gpointer              data, GDestroyNotify        destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_page_type</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, GtkAssistantPageType  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page_type</NAME>
<RETURNS>GtkAssistantPageType</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_page_title</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, const gchar          *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page_title</NAME>
<RETURNS>const gchar *</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_page_complete</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, gboolean              complete
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page_complete</NAME>
<RETURNS>gboolean</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_add_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, GtkWidget            *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_remove_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, GtkWidget            *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_update_buttons_state</NAME>
<RETURNS>void</RETURNS>
GtkAssistant *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_commit</NAME>
<RETURNS>void</RETURNS>
GtkAssistant *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page</NAME>
<RETURNS>GtkAssistantPage *</RETURNS>
GtkAssistant     *assistant, GtkWidget        *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_page_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAssistantPage *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_pages</NAME>
<RETURNS>GListModel *</RETURNS>
GtkAssistant *assistant
</FUNCTION>
<STRUCT>
<NAME>GtkAssistant</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkAssistantPage</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BIN_LAYOUT</NAME>
#define GTK_TYPE_BIN_LAYOUT (gtk_bin_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_bin_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkBinLayout</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkBookmarksChangedFunc</NAME>
<RETURNS>void</RETURNS>
gpointer data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BORDER</NAME>
#define GTK_TYPE_BORDER (gtk_border_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkBorder</NAME>
struct _GtkBorder
{
  gint16 left;
  gint16 right;
  gint16 top;
  gint16 bottom;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_border_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_border_new</NAME>
<RETURNS>GtkBorder *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_border_copy</NAME>
<RETURNS>GtkBorder *</RETURNS>
const GtkBorder *border_
</FUNCTION>
<FUNCTION>
<NAME>gtk_border_free</NAME>
<RETURNS>void</RETURNS>
GtkBorder       *border_
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BOX</NAME>
#define GTK_TYPE_BOX            (gtk_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BOX</NAME>
#define GTK_BOX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BOX, GtkBox))
</MACRO>
<MACRO>
<NAME>GTK_BOX_CLASS</NAME>
#define GTK_BOX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BOX, GtkBoxClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOX</NAME>
#define GTK_IS_BOX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BOX))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOX_CLASS</NAME>
#define GTK_IS_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BOX))
</MACRO>
<MACRO>
<NAME>GTK_BOX_GET_CLASS</NAME>
#define GTK_BOX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BOX, GtkBoxClass))
</MACRO>
<STRUCT>
<NAME>GtkBox</NAME>
struct _GtkBox
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkBoxClass</NAME>
struct _GtkBoxClass
{
  GtkWidgetClass parent_class;

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_box_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkOrientation  orientation, gint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_set_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkBox         *box, gboolean        homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_get_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkBox         *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_set_spacing</NAME>
<RETURNS>void</RETURNS>
GtkBox         *box, gint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_get_spacing</NAME>
<RETURNS>gint</RETURNS>
GtkBox         *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_set_baseline_position</NAME>
<RETURNS>void</RETURNS>
GtkBox             *box, GtkBaselinePosition position
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_get_baseline_position</NAME>
<RETURNS>GtkBaselinePosition</RETURNS>
GtkBox         *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_append</NAME>
<RETURNS>void</RETURNS>
GtkBox         *box, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_prepend</NAME>
<RETURNS>void</RETURNS>
GtkBox         *box, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_remove</NAME>
<RETURNS>void</RETURNS>
GtkBox         *box, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_insert_child_after</NAME>
<RETURNS>void</RETURNS>
GtkBox         *box, GtkWidget      *child, GtkWidget      *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_reorder_child_after</NAME>
<RETURNS>void</RETURNS>
GtkBox         *box, GtkWidget      *child, GtkWidget      *sibling
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BOX_LAYOUT</NAME>
#define GTK_TYPE_BOX_LAYOUT (gtk_box_layout_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_box_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_layout_set_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkBoxLayout        *box_layout, gboolean             homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_layout_get_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkBoxLayout        *box_layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_layout_set_spacing</NAME>
<RETURNS>void</RETURNS>
GtkBoxLayout        *box_layout, guint                spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_layout_get_spacing</NAME>
<RETURNS>guint</RETURNS>
GtkBoxLayout        *box_layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_layout_set_baseline_position</NAME>
<RETURNS>void</RETURNS>
GtkBoxLayout        *box_layout, GtkBaselinePosition  position
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_layout_get_baseline_position</NAME>
<RETURNS>GtkBaselinePosition</RETURNS>
GtkBoxLayout        *box_layout
</FUNCTION>
<STRUCT>
<NAME>GtkBoxLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BUILDABLE</NAME>
#define GTK_TYPE_BUILDABLE            (gtk_buildable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BUILDABLE</NAME>
#define GTK_BUILDABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUILDABLE, GtkBuildable))
</MACRO>
<MACRO>
<NAME>GTK_BUILDABLE_CLASS</NAME>
#define GTK_BUILDABLE_CLASS(obj)      (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_BUILDABLE, GtkBuildableIface))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUILDABLE</NAME>
#define GTK_IS_BUILDABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUILDABLE))
</MACRO>
<MACRO>
<NAME>GTK_BUILDABLE_GET_IFACE</NAME>
#define GTK_BUILDABLE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_BUILDABLE, GtkBuildableIface))
</MACRO>
<STRUCT>
<NAME>GtkBuildableParser</NAME>
struct _GtkBuildableParser
{
  /* Called for open tags <foo bar="baz"> */
  void (*start_element)  (GtkBuildableParseContext *context,
                          const gchar              *element_name,
                          const gchar             **attribute_names,
                          const gchar             **attribute_values,
                          gpointer                  user_data,
                          GError                  **error);

  /* Called for close tags </foo> */
  void (*end_element)    (GtkBuildableParseContext *context,
                          const gchar              *element_name,
                          gpointer                  user_data,
                          GError                  **error);

  /* Called for character data */
  /* text is not nul-terminated */
  void (*text)           (GtkBuildableParseContext *context,
                          const gchar              *text,
                          gsize                     text_len,
                          gpointer                  user_data,
                          GError                  **error);

  /* Called on error, including one set by other
   * methods in the vtable. The GError should not be freed.
   */
  void (*error)          (GtkBuildableParseContext *context,
                          GError                   *error,
                          gpointer                 user_data);

  gpointer padding[4];
};
</STRUCT>
<STRUCT>
<NAME>GtkBuildableIface</NAME>
struct _GtkBuildableIface
{
  GTypeInterface g_iface;

  /* virtual table */
  void          (* set_name)               (GtkBuildable       *buildable,
                                            const gchar        *name);
  const gchar * (* get_name)               (GtkBuildable       *buildable);
  void          (* add_child)              (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const gchar        *type);
  void          (* set_buildable_property) (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            const gchar        *name,
                                            const GValue       *value);
  GObject *     (* construct_child)        (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            const gchar        *name);
  gboolean      (* custom_tag_start)       (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const gchar        *tagname,
                                            GtkBuildableParser *parser,
                                            gpointer           *data);
  void          (* custom_tag_end)         (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const gchar        *tagname,
                                            gpointer            data);
  void          (* custom_finished)        (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const gchar        *tagname,
                                            gpointer            data);
  void          (* parser_finished)        (GtkBuildable       *buildable,
                                            GtkBuilder         *builder);

  GObject *     (* get_internal_child)     (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            const gchar        *childname);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_buildable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_set_name</NAME>
<RETURNS>void</RETURNS>
GtkBuildable        *buildable, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkBuildable        *buildable
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_add_child</NAME>
<RETURNS>void</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *type
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_set_buildable_property</NAME>
<RETURNS>void</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, const gchar         *name, const GValue        *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_construct_child</NAME>
<RETURNS>GObject *</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_custom_tag_start</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *tagname, GtkBuildableParser  *parser, gpointer            *data
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_custom_tag_end</NAME>
<RETURNS>void</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *tagname, gpointer             data
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_custom_finished</NAME>
<RETURNS>void</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *tagname, gpointer             data
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_parser_finished</NAME>
<RETURNS>void</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_get_internal_child</NAME>
<RETURNS>GObject *</RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, const gchar         *childname
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_parse_context_push</NAME>
<RETURNS>void</RETURNS>
GtkBuildableParseContext *context, const GtkBuildableParser *parser, gpointer                  user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_parse_context_pop</NAME>
<RETURNS>gpointer</RETURNS>
GtkBuildableParseContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_parse_context_get_element</NAME>
<RETURNS>const char *</RETURNS>
GtkBuildableParseContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_parse_context_get_element_stack</NAME>
<RETURNS>GPtrArray *</RETURNS>
GtkBuildableParseContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_parse_context_get_position</NAME>
<RETURNS>void</RETURNS>
GtkBuildableParseContext *context, gint                     *line_number, gint                     *char_number
</FUNCTION>
<STRUCT>
<NAME>GtkBuildable</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuildableParseContext</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BUILDER</NAME>
#define GTK_TYPE_BUILDER                 (gtk_builder_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BUILDER</NAME>
#define GTK_BUILDER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUILDER, GtkBuilder))
</MACRO>
<MACRO>
<NAME>GTK_BUILDER_CLASS</NAME>
#define GTK_BUILDER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUILDER, GtkBuilderClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUILDER</NAME>
#define GTK_IS_BUILDER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUILDER))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUILDER_CLASS</NAME>
#define GTK_IS_BUILDER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BUILDER))
</MACRO>
<MACRO>
<NAME>GTK_BUILDER_GET_CLASS</NAME>
#define GTK_BUILDER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BUILDER, GtkBuilderClass))
</MACRO>
<MACRO>
<NAME>GTK_BUILDER_ERROR</NAME>
#define GTK_BUILDER_ERROR                (gtk_builder_error_quark ())
</MACRO>
<ENUM>
<NAME>GtkBuilderError</NAME>
typedef enum
{
  GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION,
  GTK_BUILDER_ERROR_UNHANDLED_TAG,
  GTK_BUILDER_ERROR_MISSING_ATTRIBUTE,
  GTK_BUILDER_ERROR_INVALID_ATTRIBUTE,
  GTK_BUILDER_ERROR_INVALID_TAG,
  GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE,
  GTK_BUILDER_ERROR_INVALID_VALUE,
  GTK_BUILDER_ERROR_VERSION_MISMATCH,
  GTK_BUILDER_ERROR_DUPLICATE_ID,
  GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED,
  GTK_BUILDER_ERROR_TEMPLATE_MISMATCH,
  GTK_BUILDER_ERROR_INVALID_PROPERTY,
  GTK_BUILDER_ERROR_INVALID_SIGNAL,
  GTK_BUILDER_ERROR_INVALID_ID,
  GTK_BUILDER_ERROR_INVALID_FUNCTION
} GtkBuilderError;
</ENUM>
<FUNCTION>
<NAME>gtk_builder_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new</NAME>
<RETURNS>GtkBuilder *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const gchar   *filename, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_resource</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const gchar   *resource_path, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_string</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const gchar   *buffer, gssize         length, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const gchar   *filename, const char   **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_resource</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const gchar   *resource_path, const char   **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_string</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const gchar   *buffer, gssize         length, const char   **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_object</NAME>
<RETURNS>GObject *</RETURNS>
GtkBuilder    *builder, const gchar   *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_objects</NAME>
<RETURNS>GSList *</RETURNS>
GtkBuilder    *builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_expose_object</NAME>
<RETURNS>void</RETURNS>
GtkBuilder    *builder, const gchar   *name, GObject       *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_current_object</NAME>
<RETURNS>GObject *</RETURNS>
GtkBuilder    *builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_set_current_object</NAME>
<RETURNS>void</RETURNS>
GtkBuilder    *builder, GObject       *current_object
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_set_translation_domain</NAME>
<RETURNS>void</RETURNS>
GtkBuilder   	*builder, const gchar  	*domain
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_translation_domain</NAME>
<RETURNS>const gchar *</RETURNS>
GtkBuilder   	*builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_scope</NAME>
<RETURNS>GtkBuilderScope *</RETURNS>
GtkBuilder    *builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_set_scope</NAME>
<RETURNS>void</RETURNS>
GtkBuilder    *builder, GtkBuilderScope *scope
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_type_from_name</NAME>
<RETURNS>GType</RETURNS>
GtkBuilder   	*builder, const char   	*type_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_value_from_string</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, GParamSpec   	*pspec, const gchar  	*string, GValue       	*value, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_value_from_string_type</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, GType        	 type, const gchar  	*string, GValue       	*value, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_file</NAME>
<RETURNS>GtkBuilder *</RETURNS>
const gchar   *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_resource</NAME>
<RETURNS>GtkBuilder *</RETURNS>
const gchar   *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_string</NAME>
<RETURNS>GtkBuilder *</RETURNS>
const gchar   *string, gssize         length
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_create_closure</NAME>
<RETURNS>GClosure *</RETURNS>
GtkBuilder    *builder, const char    *function_name, GtkBuilderClosureFlags flags, GObject       *object, GError       **error
</FUNCTION>
<MACRO>
<NAME>GTK_BUILDER_WARN_INVALID_CHILD_TYPE</NAME>
#define GTK_BUILDER_WARN_INVALID_CHILD_TYPE(object, type) \
  g_warning ("'%s' is not a valid child type of '%s'", type, g_type_name (G_OBJECT_TYPE (object)))
</MACRO>
<FUNCTION>
<NAME>gtk_builder_extend_with_template</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, GtkWidget     *widget, GType          template_type, const gchar   *buffer, gssize         length, GError       **error
</FUNCTION>
<STRUCT>
<NAME>GtkBuilderClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BUILDER_SCOPE</NAME>
#define GTK_TYPE_BUILDER_SCOPE               (gtk_builder_scope_get_type ())
</MACRO>
<ENUM>
<NAME>GtkBuilderClosureFlags</NAME>
typedef enum {
  GTK_BUILDER_CLOSURE_SWAPPED = (1 << 0)
} GtkBuilderClosureFlags;
</ENUM>
<STRUCT>
<NAME>GtkBuilderScopeInterface</NAME>
struct _GtkBuilderScopeInterface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/
  GType                 (* get_type_from_name)                  (GtkBuilderScope        *self,
                                                                 GtkBuilder             *builder,
                                                                 const char             *type_name);
  GType                 (* get_type_from_function)              (GtkBuilderScope        *self,
                                                                 GtkBuilder             *builder,
                                                                 const char             *function_name);

  GClosure *            (* create_closure)                      (GtkBuilderScope        *self,
                                                                 GtkBuilder             *builder,
                                                                 const char             *function_name,
                                                                 GtkBuilderClosureFlags  flags,
                                                                 GObject                *object,
                                                                 GError                **error);
};
</STRUCT>
<STRUCT>
<NAME>GtkBuilderCScopeClass</NAME>
struct _GtkBuilderCScopeClass
{
  GObjectClass parent_class;
};
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BUILDER_CSCOPE</NAME>
#define GTK_TYPE_BUILDER_CSCOPE               (gtk_builder_cscope_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_builder_cscope_new</NAME>
<RETURNS>GtkBuilderScope *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_cscope_add_callback_symbol</NAME>
<RETURNS>void</RETURNS>
GtkBuilderCScope       *self, const gchar            *callback_name, GCallback               callback_symbol
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_cscope_add_callback_symbols</NAME>
<RETURNS>void</RETURNS>
GtkBuilderCScope       *self, const gchar            *first_callback_name, GCallback               first_callback_symbol, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_cscope_lookup_callback_symbol</NAME>
<RETURNS>GCallback</RETURNS>
GtkBuilderCScope      *self, const gchar           *callback_name
</FUNCTION>
<STRUCT>
<NAME>GtkBuilderCScope</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilderCScopeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilderScope</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_builder_scope_get_type_from_name</NAME>
<RETURNS>GType</RETURNS>
GtkBuilderScope        *self, GtkBuilder             *builder, const char             *type_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_scope_get_type_from_function</NAME>
<RETURNS>GType</RETURNS>
GtkBuilderScope        *self, GtkBuilder             *builder, const char             *function_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_scope_create_closure</NAME>
<RETURNS>GClosure *</RETURNS>
GtkBuilderScope        *self, GtkBuilder             *builder, const char             *function_name, GtkBuilderClosureFlags  flags, GObject                *object, GError                **error
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BUILTIN_ICON</NAME>
#define GTK_TYPE_BUILTIN_ICON (gtk_builtin_icon_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_builtin_icon_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char     *css_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builtin_icon_set_css_name</NAME>
<RETURNS>void</RETURNS>
GtkBuiltinIcon *self, const char     *css_name
</FUNCTION>
<STRUCT>
<NAME>GtkBuiltinIcon</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BUTTON</NAME>
#define GTK_TYPE_BUTTON                 (gtk_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BUTTON</NAME>
#define GTK_BUTTON(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUTTON, GtkButton))
</MACRO>
<MACRO>
<NAME>GTK_BUTTON_CLASS</NAME>
#define GTK_BUTTON_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON, GtkButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUTTON</NAME>
#define GTK_IS_BUTTON(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUTTON_CLASS</NAME>
#define GTK_IS_BUTTON_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_BUTTON_GET_CLASS</NAME>
#define GTK_BUTTON_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BUTTON, GtkButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkButton</NAME>
struct _GtkButton
{
  /*< private >*/
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkButtonClass</NAME>
struct _GtkButtonClass
{
  GtkWidgetClass        parent_class;

  /*< public >*/

  void (* clicked)  (GtkButton *button);
  void (* activate) (GtkButton *button);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_with_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_from_icon_name</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar    *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_has_frame</NAME>
<RETURNS>void</RETURNS>
GtkButton      *button, gboolean        has_frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_has_frame</NAME>
<RETURNS>gboolean</RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_label</NAME>
<RETURNS>void</RETURNS>
GtkButton      *button, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_label</NAME>
<RETURNS>const gchar *</RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_use_underline</NAME>
<RETURNS>void</RETURNS>
GtkButton      *button, gboolean        use_underline
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_use_underline</NAME>
<RETURNS>gboolean</RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkButton      *button, const char     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_icon_name</NAME>
<RETURNS>const char *</RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_child</NAME>
<RETURNS>void</RETURNS>
GtkButton      *button, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkButton      *button
</FUNCTION>
<STRUCT>
<NAME>GtkButtonPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CALENDAR</NAME>
#define GTK_TYPE_CALENDAR                  (gtk_calendar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CALENDAR</NAME>
#define GTK_CALENDAR(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CALENDAR, GtkCalendar))
</MACRO>
<MACRO>
<NAME>GTK_IS_CALENDAR</NAME>
#define GTK_IS_CALENDAR(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CALENDAR))
</MACRO>
<FUNCTION>
<NAME>gtk_calendar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_select_day</NAME>
<RETURNS>void</RETURNS>
GtkCalendar *self, GDateTime   *date
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_mark_day</NAME>
<RETURNS>void</RETURNS>
GtkCalendar *calendar, guint	      day
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_unmark_day</NAME>
<RETURNS>void</RETURNS>
GtkCalendar *calendar, guint	      day
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_clear_marks</NAME>
<RETURNS>void</RETURNS>
GtkCalendar *calendar
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_set_show_week_numbers</NAME>
<RETURNS>void</RETURNS>
GtkCalendar *self, gboolean     value
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_show_week_numbers</NAME>
<RETURNS>gboolean</RETURNS>
GtkCalendar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_set_show_heading</NAME>
<RETURNS>void</RETURNS>
GtkCalendar *self, gboolean     value
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_show_heading</NAME>
<RETURNS>gboolean</RETURNS>
GtkCalendar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_set_show_day_names</NAME>
<RETURNS>void</RETURNS>
GtkCalendar *self, gboolean     value
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_show_day_names</NAME>
<RETURNS>gboolean</RETURNS>
GtkCalendar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_date</NAME>
<RETURNS>GDateTime *</RETURNS>
GtkCalendar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_day_is_marked</NAME>
<RETURNS>gboolean</RETURNS>
GtkCalendar    *calendar, guint           day
</FUNCTION>
<STRUCT>
<NAME>GtkCalendar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_AREA</NAME>
#define GTK_TYPE_CELL_AREA                (gtk_cell_area_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA</NAME>
#define GTK_CELL_AREA(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA, GtkCellArea))
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_CLASS</NAME>
#define GTK_CELL_AREA_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA, GtkCellAreaClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_AREA</NAME>
#define GTK_IS_CELL_AREA(obj)     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_AREA_CLASS</NAME>
#define GTK_IS_CELL_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_AREA))
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_GET_CLASS</NAME>
#define GTK_CELL_AREA_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_AREA, GtkCellAreaClass))
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID</NAME>
#define GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID(object, property_id, pspec) \
  G_OBJECT_WARN_INVALID_PSPEC ((object), "cell property id", (property_id), (pspec))
</MACRO>
<USER_FUNCTION>
<NAME>GtkCellCallback</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer  *renderer, gpointer          data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkCellAllocCallback</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer    *renderer, const GdkRectangle *cell_area, const GdkRectangle *cell_background, gpointer            data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkCellArea</NAME>
struct _GtkCellArea
{
  /*< private >*/
  GInitiallyUnowned parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellAreaClass</NAME>
struct _GtkCellAreaClass
{
  /*< private >*/
  GInitiallyUnownedClass parent_class;

  /*< public >*/

  /* Basic methods */
  void               (* add)                             (GtkCellArea             *area,
                                                          GtkCellRenderer         *renderer);
  void               (* remove)                          (GtkCellArea             *area,
                                                          GtkCellRenderer         *renderer);
  void               (* foreach)                         (GtkCellArea             *area,
                                                          GtkCellCallback          callback,
                                                          gpointer                 callback_data);
  void               (* foreach_alloc)                   (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          const GdkRectangle      *cell_area,
                                                          const GdkRectangle      *background_area,
                                                          GtkCellAllocCallback     callback,
                                                          gpointer                 callback_data);
  gint               (* event)                           (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          GdkEvent                *event,
                                                          const GdkRectangle      *cell_area,
                                                          GtkCellRendererState     flags);
  void               (* snapshot)                        (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          GtkSnapshot             *snapshot,
                                                          const GdkRectangle      *background_area,
                                                          const GdkRectangle      *cell_area,
                                                          GtkCellRendererState     flags,
                                                          gboolean                 paint_focus);
  void               (* apply_attributes)                (GtkCellArea             *area,
                                                          GtkTreeModel            *tree_model,
                                                          GtkTreeIter             *iter,
                                                          gboolean                 is_expander,
                                                          gboolean                 is_expanded);

  /* Geometry */
  GtkCellAreaContext *(* create_context)                 (GtkCellArea             *area);
  GtkCellAreaContext *(* copy_context)                   (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context);
  GtkSizeRequestMode (* get_request_mode)                (GtkCellArea             *area);
  void               (* get_preferred_width)             (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          gint                    *minimum_width,
                                                          gint                    *natural_width);
  void               (* get_preferred_height_for_width)  (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          gint                     width,
                                                          gint                    *minimum_height,
                                                          gint                    *natural_height);
  void               (* get_preferred_height)            (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          gint                    *minimum_height,
                                                          gint                    *natural_height);
  void               (* get_preferred_width_for_height)  (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          gint                     height,
                                                          gint                    *minimum_width,
                                                          gint                    *natural_width);

  /* Cell Properties */
  void               (* set_cell_property)               (GtkCellArea             *area,
                                                          GtkCellRenderer         *renderer,
                                                          guint                    property_id,
                                                          const GValue            *value,
                                                          GParamSpec              *pspec);
  void               (* get_cell_property)               (GtkCellArea             *area,
                                                          GtkCellRenderer         *renderer,
                                                          guint                    property_id,
                                                          GValue                  *value,
                                                          GParamSpec              *pspec);

  /* Focus */
  gboolean           (* focus)                           (GtkCellArea             *area,
                                                          GtkDirectionType         direction);
  gboolean           (* is_activatable)                  (GtkCellArea             *area);
  gboolean           (* activate)                        (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          const GdkRectangle      *cell_area,
                                                          GtkCellRendererState     flags,
                                                          gboolean                 edit_only);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_area_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_add</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_remove</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_has_renderer</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_foreach</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellCallback       callback, gpointer              callback_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_foreach_alloc</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, const GdkRectangle   *cell_area, const GdkRectangle   *background_area, GtkCellAllocCallback  callback, gpointer              callback_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_event</NAME>
<RETURNS>gint</RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, GdkEvent             *event, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_snapshot</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, GtkSnapshot          *snapshot, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags, gboolean              paint_focus
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_cell_allocation</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, GtkCellRenderer      *renderer, const GdkRectangle   *cell_area, GdkRectangle         *allocation
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_cell_at_position</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, const GdkRectangle   *cell_area, gint                  x, gint                  y, GdkRectangle         *alloc_area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_create_context</NAME>
<RETURNS>GtkCellAreaContext *</RETURNS>
GtkCellArea        *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_copy_context</NAME>
<RETURNS>GtkCellAreaContext *</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_request_mode</NAME>
<RETURNS>GtkSizeRequestMode</RETURNS>
GtkCellArea        *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_width</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_height_for_width</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint                width, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_width_for_height</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint                height, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_current_path_string</NAME>
<RETURNS>const gchar *</RETURNS>
GtkCellArea        *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_apply_attributes</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkTreeModel       *tree_model, GtkTreeIter        *iter, gboolean            is_expander, gboolean            is_expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_connect</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *attribute, gint                column
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_disconnect</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *attribute
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_get_column</NAME>
<RETURNS>gint</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *attribute
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_class_install_cell_property</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaClass   *aclass, guint               property_id, GParamSpec         *pspec
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_class_find_cell_property</NAME>
<RETURNS>GParamSpec *</RETURNS>
GtkCellAreaClass   *aclass, const gchar        *property_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_class_list_cell_properties</NAME>
<RETURNS>GParamSpec **</RETURNS>
GtkCellAreaClass   *aclass, guint                   *n_properties
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_add_with_properties</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar     *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set_valist</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_property_name, va_list             var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get_valist</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_property_name, va_list             var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set_property</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *property_name, const GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get_property</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *property_name, GValue             *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_is_activatable</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellArea         *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellArea         *area, GtkCellAreaContext  *context, GtkWidget           *widget, const GdkRectangle  *cell_area, GtkCellRendererState flags, gboolean             edit_only
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellArea         *area, GtkDirectionType     direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_set_focus_cell</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_focus_cell</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
GtkCellArea          *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_add_focus_sibling</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer, GtkCellRenderer      *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_remove_focus_sibling</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer, GtkCellRenderer      *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_is_focus_sibling</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer, GtkCellRenderer      *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_focus_siblings</NAME>
<RETURNS>const GList *</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_focus_from_sibling</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_edited_cell</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
GtkCellArea          *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_edit_widget</NAME>
<RETURNS>GtkCellEditable *</RETURNS>
GtkCellArea          *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_activate_cell</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellArea          *area, GtkWidget            *widget, GtkCellRenderer      *renderer, GdkEvent             *event, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_stop_editing</NAME>
<RETURNS>void</RETURNS>
GtkCellArea          *area, gboolean              canceled
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_inner_cell_area</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkWidget          *widget, const GdkRectangle *cell_area, GdkRectangle       *inner_area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_request_renderer</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, GtkOrientation      orientation, GtkWidget          *widget, gint                for_size, gint               *minimum_size, gint               *natural_size
</FUNCTION>
<STRUCT>
<NAME>GtkCellAreaContext</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_AREA_BOX</NAME>
#define GTK_TYPE_CELL_AREA_BOX            (gtk_cell_area_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_BOX</NAME>
#define GTK_CELL_AREA_BOX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBox))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_AREA_BOX</NAME>
#define GTK_IS_CELL_AREA_BOX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_BOX))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_area_box_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_new</NAME>
<RETURNS>GtkCellArea *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_pack_start</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaBox  *box, GtkCellRenderer *renderer, gboolean         expand, gboolean         align, gboolean         fixed
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_pack_end</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaBox  *box, GtkCellRenderer *renderer, gboolean         expand, gboolean         align, gboolean         fixed
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_get_spacing</NAME>
<RETURNS>gint</RETURNS>
GtkCellAreaBox  *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_set_spacing</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaBox  *box, gint             spacing
</FUNCTION>
<STRUCT>
<NAME>GtkCellAreaBox</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_AREA_CONTEXT</NAME>
#define GTK_TYPE_CELL_AREA_CONTEXT            (gtk_cell_area_context_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_CONTEXT</NAME>
#define GTK_CELL_AREA_CONTEXT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_AREA_CONTEXT, GtkCellAreaContext))
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_CONTEXT_CLASS</NAME>
#define GTK_CELL_AREA_CONTEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA_CONTEXT, GtkCellAreaContextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_AREA_CONTEXT</NAME>
#define GTK_IS_CELL_AREA_CONTEXT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_AREA_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_AREA_CONTEXT_CLASS</NAME>
#define GTK_IS_CELL_AREA_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_AREA_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_CONTEXT_GET_CLASS</NAME>
#define GTK_CELL_AREA_CONTEXT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_AREA_CONTEXT, GtkCellAreaContextClass))
</MACRO>
<STRUCT>
<NAME>GtkCellAreaContext</NAME>
struct _GtkCellAreaContext
{
  /*< private >*/
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellAreaContextClass</NAME>
struct _GtkCellAreaContextClass
{
  /*< private >*/
  GObjectClass parent_class;

  /*< public >*/
  void    (* allocate)                       (GtkCellAreaContext *context,
                                              gint                width,
                                              gint                height);
  void    (* reset)                          (GtkCellAreaContext *context);
  void    (* get_preferred_height_for_width) (GtkCellAreaContext *context,
                                              gint                width,
                                              gint               *minimum_height,
                                              gint               *natural_height);
  void    (* get_preferred_width_for_height) (GtkCellAreaContext *context,
                                              gint                height,
                                              gint               *minimum_width,
                                              gint               *natural_width);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_area_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_area</NAME>
<RETURNS>GtkCellArea *</RETURNS>
GtkCellAreaContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_allocate</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint                width, gint                height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_reset</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_preferred_width</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_preferred_height_for_width</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint                width, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_preferred_width_for_height</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint                height, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_allocation</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint               *width, gint               *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_push_preferred_width</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint                minimum_width, gint                natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_push_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, gint                minimum_height, gint                natural_height
</FUNCTION>
<STRUCT>
<NAME>GtkCellAreaContextPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_EDITABLE</NAME>
#define GTK_TYPE_CELL_EDITABLE            (gtk_cell_editable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_EDITABLE</NAME>
#define GTK_CELL_EDITABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_EDITABLE, GtkCellEditable))
</MACRO>
<MACRO>
<NAME>GTK_CELL_EDITABLE_CLASS</NAME>
#define GTK_CELL_EDITABLE_CLASS(obj)      (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_CELL_EDITABLE, GtkCellEditableIface))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_EDITABLE</NAME>
#define GTK_IS_CELL_EDITABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_EDITABLE))
</MACRO>
<MACRO>
<NAME>GTK_CELL_EDITABLE_GET_IFACE</NAME>
#define GTK_CELL_EDITABLE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_CELL_EDITABLE, GtkCellEditableIface))
</MACRO>
<STRUCT>
<NAME>GtkCellEditableIface</NAME>
struct _GtkCellEditableIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

  /* signals */
  void (* editing_done)  (GtkCellEditable *cell_editable);
  void (* remove_widget) (GtkCellEditable *cell_editable);

  /* virtual table */
  void (* start_editing) (GtkCellEditable *cell_editable,
			  GdkEvent        *event);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_editable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_editable_start_editing</NAME>
<RETURNS>void</RETURNS>
GtkCellEditable *cell_editable, GdkEvent        *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_editable_editing_done</NAME>
<RETURNS>void</RETURNS>
GtkCellEditable *cell_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_editable_remove_widget</NAME>
<RETURNS>void</RETURNS>
GtkCellEditable *cell_editable
</FUNCTION>
<STRUCT>
<NAME>GtkCellEditable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_LAYOUT</NAME>
#define GTK_TYPE_CELL_LAYOUT            (gtk_cell_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_LAYOUT</NAME>
#define GTK_CELL_LAYOUT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_LAYOUT, GtkCellLayout))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_LAYOUT</NAME>
#define GTK_IS_CELL_LAYOUT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_LAYOUT))
</MACRO>
<MACRO>
<NAME>GTK_CELL_LAYOUT_GET_IFACE</NAME>
#define GTK_CELL_LAYOUT_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_CELL_LAYOUT, GtkCellLayoutIface))
</MACRO>
<USER_FUNCTION>
<NAME>GtkCellLayoutDataFunc</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout   *cell_layout, GtkCellRenderer *cell, GtkTreeModel    *tree_model, GtkTreeIter     *iter, gpointer         data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkCellLayoutIface</NAME>
struct _GtkCellLayoutIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

  /* Virtual Table */
  void (* pack_start)         (GtkCellLayout         *cell_layout,
                               GtkCellRenderer       *cell,
                               gboolean               expand);
  void (* pack_end)           (GtkCellLayout         *cell_layout,
                               GtkCellRenderer       *cell,
                               gboolean               expand);
  void (* clear)              (GtkCellLayout         *cell_layout);
  void (* add_attribute)      (GtkCellLayout         *cell_layout,
                               GtkCellRenderer       *cell,
                               const gchar           *attribute,
                               gint                   column);
  void (* set_cell_data_func) (GtkCellLayout         *cell_layout,
                               GtkCellRenderer       *cell,
                               GtkCellLayoutDataFunc  func,
                               gpointer               func_data,
                               GDestroyNotify         destroy);
  void (* clear_attributes)   (GtkCellLayout         *cell_layout,
                               GtkCellRenderer       *cell);
  void (* reorder)            (GtkCellLayout         *cell_layout,
                               GtkCellRenderer       *cell,
                               gint                   position);
  GList* (* get_cells)        (GtkCellLayout         *cell_layout);

  GtkCellArea *(* get_area)   (GtkCellLayout         *cell_layout);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_layout_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_pack_start</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout, GtkCellRenderer       *cell, gboolean               expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_pack_end</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout, GtkCellRenderer       *cell, gboolean               expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_get_cells</NAME>
<RETURNS>GList *</RETURNS>
GtkCellLayout         *cell_layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_clear</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_set_attributes</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout, GtkCellRenderer       *cell, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_add_attribute</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout, GtkCellRenderer       *cell, const gchar           *attribute, gint                   column
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_set_cell_data_func</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout, GtkCellRenderer       *cell, GtkCellLayoutDataFunc  func, gpointer               func_data, GDestroyNotify         destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_clear_attributes</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout, GtkCellRenderer       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_reorder</NAME>
<RETURNS>void</RETURNS>
GtkCellLayout         *cell_layout, GtkCellRenderer       *cell, gint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_layout_get_area</NAME>
<RETURNS>GtkCellArea *</RETURNS>
GtkCellLayout         *cell_layout
</FUNCTION>
<STRUCT>
<NAME>GtkCellLayout</NAME>
</STRUCT>
<ENUM>
<NAME>GtkCellRendererState</NAME>
typedef enum
{
  GTK_CELL_RENDERER_SELECTED    = 1 << 0,
  GTK_CELL_RENDERER_PRELIT      = 1 << 1,
  GTK_CELL_RENDERER_INSENSITIVE = 1 << 2,
  /* this flag means the cell is in the sort column/row */
  GTK_CELL_RENDERER_SORTED      = 1 << 3,
  GTK_CELL_RENDERER_FOCUSED     = 1 << 4,
  GTK_CELL_RENDERER_EXPANDABLE  = 1 << 5,
  GTK_CELL_RENDERER_EXPANDED    = 1 << 6
} GtkCellRendererState;
</ENUM>
<ENUM>
<NAME>GtkCellRendererMode</NAME>
typedef enum
{
  GTK_CELL_RENDERER_MODE_INERT,
  GTK_CELL_RENDERER_MODE_ACTIVATABLE,
  GTK_CELL_RENDERER_MODE_EDITABLE
} GtkCellRendererMode;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER</NAME>
#define GTK_TYPE_CELL_RENDERER		  (gtk_cell_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER</NAME>
#define GTK_CELL_RENDERER(obj)		  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRenderer))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_CLASS</NAME>
#define GTK_CELL_RENDERER_CLASS(klass)	  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER</NAME>
#define GTK_IS_CELL_RENDERER(obj)	  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER, GtkCellRendererClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRenderer</NAME>
struct _GtkCellRenderer
{
  GInitiallyUnowned parent_instance;

  /*< private >*/
  GtkCellRendererPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererClass</NAME>
struct _GtkCellRendererClass
{
  /*< private >*/
  GInitiallyUnownedClass parent_class;

  /*< public >*/

  /* vtable - not signals */
  GtkSizeRequestMode (* get_request_mode)                (GtkCellRenderer      *cell);
  void               (* get_preferred_width)             (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          gint                 *minimum_size,
                                                          gint                 *natural_size);
  void               (* get_preferred_height_for_width)  (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          gint                  width,
                                                          gint                 *minimum_height,
                                                          gint                 *natural_height);
  void               (* get_preferred_height)            (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          gint                 *minimum_size,
                                                          gint                 *natural_size);
  void               (* get_preferred_width_for_height)  (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          gint                  height,
                                                          gint                 *minimum_width,
                                                          gint                 *natural_width);
  void               (* get_aligned_area)                (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
							  GtkCellRendererState  flags,
                                                          const GdkRectangle   *cell_area,
                                                          GdkRectangle         *aligned_area);
  void               (* get_size)                        (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          const GdkRectangle   *cell_area,
                                                          gint                 *x_offset,
                                                          gint                 *y_offset,
                                                          gint                 *width,
                                                          gint                 *height);
  void               (* snapshot)                        (GtkCellRenderer      *cell,
                                                          GtkSnapshot          *snapshot,
                                                          GtkWidget            *widget,
                                                          const GdkRectangle   *background_area,
                                                          const GdkRectangle   *cell_area,
                                                          GtkCellRendererState  flags);
  gboolean           (* activate)                        (GtkCellRenderer      *cell,
                                                          GdkEvent             *event,
                                                          GtkWidget            *widget,
                                                          const gchar          *path,
                                                          const GdkRectangle   *background_area,
                                                          const GdkRectangle   *cell_area,
                                                          GtkCellRendererState  flags);
  GtkCellEditable *  (* start_editing)                   (GtkCellRenderer      *cell,
                                                          GdkEvent             *event,
                                                          GtkWidget            *widget,
                                                          const gchar          *path,
                                                          const GdkRectangle   *background_area,
                                                          const GdkRectangle   *cell_area,
                                                          GtkCellRendererState  flags);

  /* Signals */
  void (* editing_canceled) (GtkCellRenderer *cell);
  void (* editing_started)  (GtkCellRenderer *cell,
			     GtkCellEditable *editable,
			     const gchar     *path);

  /*< private >*/

  GtkCellRendererClassPrivate *priv;

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_request_mode</NAME>
<RETURNS>GtkSizeRequestMode</RETURNS>
GtkCellRenderer    *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_width</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint               *minimum_size, gint               *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_height_for_width</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint                width, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint               *minimum_size, gint               *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_width_for_height</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint                height, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_size</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, GtkRequisition     *minimum_size, GtkRequisition     *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_aligned_area</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, GtkCellRendererState flags, const GdkRectangle *cell_area, GdkRectangle       *aligned_area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_snapshot</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, GtkSnapshot          *snapshot, GtkWidget            *widget, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer      *cell, GdkEvent             *event, GtkWidget            *widget, const gchar          *path, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_start_editing</NAME>
<RETURNS>GtkCellEditable *</RETURNS>
GtkCellRenderer      *cell, GdkEvent             *event, GtkWidget            *widget, const gchar          *path, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_fixed_size</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gint                  width, gint                  height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_fixed_size</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gint                 *width, gint                 *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_alignment</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gfloat                xalign, gfloat                yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_alignment</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gfloat               *xalign, gfloat               *yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_padding</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gint                  xpad, gint                  ypad
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_padding</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gint                 *xpad, gint                 *ypad
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_visible</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gboolean              visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer      *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_sensitive</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gboolean              sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_sensitive</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer      *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_is_activatable</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer      *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_is_expander</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer     *cell, gboolean             is_expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_is_expander</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer     *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_is_expanded</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer     *cell, gboolean             is_expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_is_expanded</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRenderer     *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_stop_editing</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, gboolean              canceled
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_state</NAME>
<RETURNS>GtkStateFlags</RETURNS>
GtkCellRenderer      *cell, GtkWidget            *widget, GtkCellRendererState  cell_state
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_class_set_accessible_type</NAME>
<RETURNS>void</RETURNS>
GtkCellRendererClass *renderer_class, GType                 type
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererClassPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_ACCEL</NAME>
#define GTK_TYPE_CELL_RENDERER_ACCEL            (gtk_cell_renderer_accel_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_ACCEL</NAME>
#define GTK_CELL_RENDERER_ACCEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_ACCEL, GtkCellRendererAccel))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_ACCEL</NAME>
#define GTK_IS_CELL_RENDERER_ACCEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_ACCEL))
</MACRO>
<ENUM>
<NAME>GtkCellRendererAccelMode</NAME>
typedef enum
{
  GTK_CELL_RENDERER_ACCEL_MODE_GTK,
  GTK_CELL_RENDERER_ACCEL_MODE_OTHER
} GtkCellRendererAccelMode;
</ENUM>
<FUNCTION>
<NAME>gtk_cell_renderer_accel_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_accel_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererAccel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_COMBO</NAME>
#define GTK_TYPE_CELL_RENDERER_COMBO		(gtk_cell_renderer_combo_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_COMBO</NAME>
#define GTK_CELL_RENDERER_COMBO(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_COMBO, GtkCellRendererCombo))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_COMBO</NAME>
#define GTK_IS_CELL_RENDERER_COMBO(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_COMBO))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_renderer_combo_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_combo_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererCombo</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_PIXBUF</NAME>
#define GTK_TYPE_CELL_RENDERER_PIXBUF			(gtk_cell_renderer_pixbuf_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_PIXBUF</NAME>
#define GTK_CELL_RENDERER_PIXBUF(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF, GtkCellRendererPixbuf))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_PIXBUF</NAME>
#define GTK_IS_CELL_RENDERER_PIXBUF(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_renderer_pixbuf_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_pixbuf_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererPixbuf</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_PROGRESS</NAME>
#define GTK_TYPE_CELL_RENDERER_PROGRESS (gtk_cell_renderer_progress_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_PROGRESS</NAME>
#define GTK_CELL_RENDERER_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_PROGRESS, GtkCellRendererProgress))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_PROGRESS</NAME>
#define GTK_IS_CELL_RENDERER_PROGRESS(obj)	  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_PROGRESS))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_renderer_progress_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_progress_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererProgress</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_SPIN</NAME>
#define GTK_TYPE_CELL_RENDERER_SPIN		(gtk_cell_renderer_spin_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_SPIN</NAME>
#define GTK_CELL_RENDERER_SPIN(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_SPIN, GtkCellRendererSpin))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_SPIN</NAME>
#define GTK_IS_CELL_RENDERER_SPIN(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_SPIN))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_renderer_spin_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_spin_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererSpin</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_SPINNER</NAME>
#define GTK_TYPE_CELL_RENDERER_SPINNER            (gtk_cell_renderer_spinner_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_SPINNER</NAME>
#define GTK_CELL_RENDERER_SPINNER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_SPINNER, GtkCellRendererSpinner))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_SPINNER</NAME>
#define GTK_IS_CELL_RENDERER_SPINNER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_SPINNER))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_renderer_spinner_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_spinner_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererSpinner</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_TEXT</NAME>
#define GTK_TYPE_CELL_RENDERER_TEXT		(gtk_cell_renderer_text_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_TEXT</NAME>
#define GTK_CELL_RENDERER_TEXT(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_TEXT, GtkCellRendererText))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_TEXT_CLASS</NAME>
#define GTK_CELL_RENDERER_TEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_TEXT, GtkCellRendererTextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_TEXT</NAME>
#define GTK_IS_CELL_RENDERER_TEXT(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TEXT))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_TEXT_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_TEXT_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_TEXT))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_TEXT_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_TEXT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TEXT, GtkCellRendererTextClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererText</NAME>
struct _GtkCellRendererText
{
  GtkCellRenderer parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererTextClass</NAME>
struct _GtkCellRendererTextClass
{
  GtkCellRendererClass parent_class;

  void (* edited) (GtkCellRendererText *cell_renderer_text,
		   const gchar         *path,
		   const gchar         *new_text);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_text_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_text_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_text_set_fixed_height_from_font</NAME>
<RETURNS>void</RETURNS>
GtkCellRendererText *renderer, gint                 number_of_rows
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_TOGGLE</NAME>
#define GTK_TYPE_CELL_RENDERER_TOGGLE			(gtk_cell_renderer_toggle_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_TOGGLE</NAME>
#define GTK_CELL_RENDERER_TOGGLE(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE, GtkCellRendererToggle))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_TOGGLE</NAME>
#define GTK_IS_CELL_RENDERER_TOGGLE(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_get_radio</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRendererToggle *toggle
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_set_radio</NAME>
<RETURNS>void</RETURNS>
GtkCellRendererToggle *toggle, gboolean               radio
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_get_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRendererToggle *toggle
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_set_active</NAME>
<RETURNS>void</RETURNS>
GtkCellRendererToggle *toggle, gboolean               setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_get_activatable</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellRendererToggle *toggle
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_toggle_set_activatable</NAME>
<RETURNS>void</RETURNS>
GtkCellRendererToggle *toggle, gboolean               setting
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererToggle</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_VIEW</NAME>
#define GTK_TYPE_CELL_VIEW                (gtk_cell_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_VIEW</NAME>
#define GTK_CELL_VIEW(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_VIEW, GtkCellView))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_VIEW</NAME>
#define GTK_IS_CELL_VIEW(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_VIEW))
</MACRO>
<FUNCTION>
<NAME>gtk_cell_view_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_context</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_text</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_markup</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_texture</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_model</NAME>
<RETURNS>void</RETURNS>
GtkCellView     *cell_view, GtkTreeModel    *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_displayed_row</NAME>
<RETURNS>void</RETURNS>
GtkCellView     *cell_view, GtkTreePath     *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_displayed_row</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_draw_sensitive</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_draw_sensitive</NAME>
<RETURNS>void</RETURNS>
GtkCellView     *cell_view, gboolean         draw_sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_fit_model</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_fit_model</NAME>
<RETURNS>void</RETURNS>
GtkCellView     *cell_view, gboolean         fit_model
</FUNCTION>
<STRUCT>
<NAME>GtkCellView</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CENTER_BOX</NAME>
#define GTK_TYPE_CENTER_BOX                 (gtk_center_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CENTER_BOX</NAME>
#define GTK_CENTER_BOX(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CENTER_BOX, GtkCenterBox))
</MACRO>
<MACRO>
<NAME>GTK_CENTER_BOX_CLASS</NAME>
#define GTK_CENTER_BOX_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CENTER_BOX, GtkCenterBoxClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CENTER_BOX</NAME>
#define GTK_IS_CENTER_BOX(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CENTER_BOX))
</MACRO>
<MACRO>
<NAME>GTK_IS_CENTER_BOX_CLASS</NAME>
#define GTK_IS_CENTER_BOX_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CENTER_BOX))
</MACRO>
<MACRO>
<NAME>GTK_CENTER_BOX_GET_CLASS</NAME>
#define GTK_CENTER_BOX_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CENTER_BOX, GtkCenterBoxClass))
</MACRO>
<FUNCTION>
<NAME>gtk_center_box_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_set_start_widget</NAME>
<RETURNS>void</RETURNS>
GtkCenterBox *self, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_set_center_widget</NAME>
<RETURNS>void</RETURNS>
GtkCenterBox *self, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_set_end_widget</NAME>
<RETURNS>void</RETURNS>
GtkCenterBox *self, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_get_start_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCenterBox *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_get_center_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCenterBox *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_get_end_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCenterBox *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_set_baseline_position</NAME>
<RETURNS>void</RETURNS>
GtkCenterBox        *self, GtkBaselinePosition  position
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_box_get_baseline_position</NAME>
<RETURNS>GtkBaselinePosition</RETURNS>
GtkCenterBox        *self
</FUNCTION>
<STRUCT>
<NAME>GtkCenterBox</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCenterBoxClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CENTER_LAYOUT</NAME>
#define GTK_TYPE_CENTER_LAYOUT (gtk_center_layout_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_center_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_set_orientation</NAME>
<RETURNS>void</RETURNS>
GtkCenterLayout     *self, GtkOrientation       orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_get_orientation</NAME>
<RETURNS>GtkOrientation</RETURNS>
GtkCenterLayout     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_set_baseline_position</NAME>
<RETURNS>void</RETURNS>
GtkCenterLayout     *self, GtkBaselinePosition  baseline_position
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_get_baseline_position</NAME>
<RETURNS>GtkBaselinePosition</RETURNS>
GtkCenterLayout     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_set_start_widget</NAME>
<RETURNS>void</RETURNS>
GtkCenterLayout     *self, GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_get_start_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCenterLayout     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_set_center_widget</NAME>
<RETURNS>void</RETURNS>
GtkCenterLayout     *self, GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_get_center_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCenterLayout     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_set_end_widget</NAME>
<RETURNS>void</RETURNS>
GtkCenterLayout     *self, GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_center_layout_get_end_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCenterLayout     *self
</FUNCTION>
<STRUCT>
<NAME>GtkCenterLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CHECK_BUTTON</NAME>
#define GTK_TYPE_CHECK_BUTTON                  (gtk_check_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CHECK_BUTTON</NAME>
#define GTK_CHECK_BUTTON(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButton))
</MACRO>
<MACRO>
<NAME>GTK_CHECK_BUTTON_CLASS</NAME>
#define GTK_CHECK_BUTTON_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CHECK_BUTTON</NAME>
#define GTK_IS_CHECK_BUTTON(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_CHECK_BUTTON_CLASS</NAME>
#define GTK_IS_CHECK_BUTTON_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CHECK_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_CHECK_BUTTON_GET_CLASS</NAME>
#define GTK_CHECK_BUTTON_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkCheckButton</NAME>
struct _GtkCheckButton
{
  GtkToggleButton toggle_button;
};
</STRUCT>
<STRUCT>
<NAME>GtkCheckButtonClass</NAME>
struct _GtkCheckButtonClass
{
  GtkToggleButtonClass parent_class;

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_check_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_new_with_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_draw_indicator</NAME>
<RETURNS>void</RETURNS>
GtkCheckButton *check_button, gboolean        draw_indicator
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_get_draw_indicator</NAME>
<RETURNS>gboolean</RETURNS>
GtkCheckButton *check_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_inconsistent</NAME>
<RETURNS>void</RETURNS>
GtkCheckButton *check_button, gboolean        inconsistent
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_get_inconsistent</NAME>
<RETURNS>gboolean</RETURNS>
GtkCheckButton *check_button
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_COLOR_BUTTON</NAME>
#define GTK_TYPE_COLOR_BUTTON             (gtk_color_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_BUTTON</NAME>
#define GTK_COLOR_BUTTON(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_BUTTON, GtkColorButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_BUTTON</NAME>
#define GTK_IS_COLOR_BUTTON(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_BUTTON))
</MACRO>
<FUNCTION>
<NAME>gtk_color_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_new_with_rgba</NAME>
<RETURNS>GtkWidget *</RETURNS>
const GdkRGBA  *rgba
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_set_title</NAME>
<RETURNS>void</RETURNS>
GtkColorButton *button, const gchar    *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_get_title</NAME>
<RETURNS>const gchar *</RETURNS>
GtkColorButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_get_modal</NAME>
<RETURNS>gboolean</RETURNS>
GtkColorButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_set_modal</NAME>
<RETURNS>void</RETURNS>
GtkColorButton *button, gboolean        modal
</FUNCTION>
<STRUCT>
<NAME>GtkColorButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_CHOOSER</NAME>
#define GTK_TYPE_COLOR_CHOOSER                  (gtk_color_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER</NAME>
#define GTK_COLOR_CHOOSER(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_CHOOSER, GtkColorChooser))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_CHOOSER</NAME>
#define GTK_IS_COLOR_CHOOSER(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_CHOOSER))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_GET_IFACE</NAME>
#define GTK_COLOR_CHOOSER_GET_IFACE(inst)       (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_COLOR_CHOOSER, GtkColorChooserInterface))
</MACRO>
<STRUCT>
<NAME>GtkColorChooserInterface</NAME>
struct _GtkColorChooserInterface
{
  GTypeInterface base_interface;

  /* Methods */
  void (* get_rgba)    (GtkColorChooser *chooser,
                        GdkRGBA         *color);
  void (* set_rgba)    (GtkColorChooser *chooser,
                        const GdkRGBA   *color);

  void (* add_palette) (GtkColorChooser *chooser,
                        GtkOrientation   orientation,
                        gint             colors_per_line,
                        gint             n_colors,
                        GdkRGBA         *colors);

  /* Signals */
  void (* color_activated) (GtkColorChooser *chooser,
                            const GdkRGBA   *color);

  /* Padding */
  gpointer padding[12];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_color_chooser_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_get_rgba</NAME>
<RETURNS>void</RETURNS>
GtkColorChooser *chooser, GdkRGBA         *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_set_rgba</NAME>
<RETURNS>void</RETURNS>
GtkColorChooser *chooser, const GdkRGBA   *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_get_use_alpha</NAME>
<RETURNS>gboolean</RETURNS>
GtkColorChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_set_use_alpha</NAME>
<RETURNS>void</RETURNS>
GtkColorChooser *chooser, gboolean         use_alpha
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_add_palette</NAME>
<RETURNS>void</RETURNS>
GtkColorChooser *chooser, GtkOrientation   orientation, gint             colors_per_line, gint             n_colors, GdkRGBA         *colors
</FUNCTION>
<STRUCT>
<NAME>GtkColorChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_CHOOSER_DIALOG</NAME>
#define GTK_TYPE_COLOR_CHOOSER_DIALOG              (gtk_color_chooser_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_DIALOG</NAME>
#define GTK_COLOR_CHOOSER_DIALOG(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_CHOOSER_DIALOG, GtkColorChooserDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_CHOOSER_DIALOG</NAME>
#define GTK_IS_COLOR_CHOOSER_DIALOG(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_CHOOSER_DIALOG))
</MACRO>
<FUNCTION>
<NAME>gtk_color_chooser_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar *title, GtkWindow   *parent
</FUNCTION>
<STRUCT>
<NAME>GtkColorChooserDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_CHOOSER_WIDGET</NAME>
#define GTK_TYPE_COLOR_CHOOSER_WIDGET              (gtk_color_chooser_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_WIDGET</NAME>
#define GTK_COLOR_CHOOSER_WIDGET(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_CHOOSER_WIDGET, GtkColorChooserWidget))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_CHOOSER_WIDGET</NAME>
#define GTK_IS_COLOR_CHOOSER_WIDGET(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_CHOOSER_WIDGET))
</MACRO>
<FUNCTION>
<NAME>gtk_color_chooser_widget_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_widget_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkColorChooserWidget</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_PICKER_KWIN</NAME>
#define GTK_TYPE_COLOR_PICKER_KWIN gtk_color_picker_kwin_get_type ()
</MACRO>
<FUNCTION>
<NAME>gtk_color_picker_kwin_new</NAME>
<RETURNS>GtkColorPicker *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkColorPickerKwin</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_PICKER_PORTAL</NAME>
#define GTK_TYPE_COLOR_PICKER_PORTAL gtk_color_picker_portal_get_type ()
</MACRO>
<FUNCTION>
<NAME>gtk_color_picker_portal_new</NAME>
<RETURNS>GtkColorPicker *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkColorPickerPortal</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_PICKER</NAME>
#define GTK_TYPE_COLOR_PICKER             (gtk_color_picker_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_PICKER</NAME>
#define GTK_COLOR_PICKER(o)               (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_COLOR_PICKER, GtkColorPicker))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_PICKER</NAME>
#define GTK_IS_COLOR_PICKER(o)            (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_COLOR_PICKER))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_PICKER_GET_INTERFACE</NAME>
#define GTK_COLOR_PICKER_GET_INTERFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), GTK_TYPE_COLOR_PICKER, GtkColorPickerInterface))
</MACRO>
<STRUCT>
<NAME>GtkColorPickerInterface</NAME>
struct _GtkColorPickerInterface {
  GTypeInterface g_iface;

  void (* pick)             (GtkColorPicker      *picker,
                             GAsyncReadyCallback  callback,
                             gpointer             user_data);

  GdkRGBA * (* pick_finish) (GtkColorPicker      *picker,
                             GAsyncResult        *res,
                             GError             **error);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_color_picker_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_picker_new</NAME>
<RETURNS>GtkColorPicker *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_picker_pick</NAME>
<RETURNS>void</RETURNS>
GtkColorPicker       *picker, GAsyncReadyCallback   callback, gpointer              user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_picker_pick_finish</NAME>
<RETURNS>GdkRGBA *</RETURNS>
GtkColorPicker       *picker, GAsyncResult         *res, GError              **error
</FUNCTION>
<STRUCT>
<NAME>GtkColorPicker</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_PICKER_SHELL</NAME>
#define GTK_TYPE_COLOR_PICKER_SHELL gtk_color_picker_shell_get_type ()
</MACRO>
<FUNCTION>
<NAME>gtk_color_picker_shell_new</NAME>
<RETURNS>GtkColorPicker *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkColorPickerShell</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_hsv_to_rgb</NAME>
<RETURNS>void</RETURNS>
float  h, float  s, float  v, float *r, float *g, float *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_rgb_to_hsv</NAME>
<RETURNS>void</RETURNS>
float  r, float  g, float  b, float *h, float *s, float *v
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_COMBO_BOX</NAME>
#define GTK_TYPE_COMBO_BOX             (gtk_combo_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX</NAME>
#define GTK_COMBO_BOX(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMBO_BOX, GtkComboBox))
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX_CLASS</NAME>
#define GTK_COMBO_BOX_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_COMBO_BOX, GtkComboBoxClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_COMBO_BOX</NAME>
#define GTK_IS_COMBO_BOX(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMBO_BOX))
</MACRO>
<MACRO>
<NAME>GTK_IS_COMBO_BOX_CLASS</NAME>
#define GTK_IS_COMBO_BOX_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_COMBO_BOX))
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX_GET_CLASS</NAME>
#define GTK_COMBO_BOX_GET_CLASS(inst)  (G_TYPE_INSTANCE_GET_CLASS ((inst), GTK_TYPE_COMBO_BOX, GtkComboBoxClass))
</MACRO>
<STRUCT>
<NAME>GtkComboBox</NAME>
struct _GtkComboBox
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkComboBoxClass</NAME>
struct _GtkComboBoxClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  /* signals */
  void     (* changed)           (GtkComboBox *combo_box);
  gchar   *(* format_entry_text) (GtkComboBox *combo_box,
                                  const gchar *path);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_combo_box_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new_with_entry</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new_with_model</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeModel *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new_with_model_and_entry</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeModel *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_active</NAME>
<RETURNS>gint</RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active</NAME>
<RETURNS>void</RETURNS>
GtkComboBox     *combo_box, gint             index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_active_iter</NAME>
<RETURNS>gboolean</RETURNS>
GtkComboBox     *combo_box, GtkTreeIter     *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active_iter</NAME>
<RETURNS>void</RETURNS>
GtkComboBox     *combo_box, GtkTreeIter     *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_model</NAME>
<RETURNS>void</RETURNS>
GtkComboBox     *combo_box, GtkTreeModel    *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_row_separator_func</NAME>
<RETURNS>GtkTreeViewRowSeparatorFunc</RETURNS>
GtkComboBox                *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_row_separator_func</NAME>
<RETURNS>void</RETURNS>
GtkComboBox                *combo_box, GtkTreeViewRowSeparatorFunc func, gpointer                    data, GDestroyNotify              destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_button_sensitivity</NAME>
<RETURNS>void</RETURNS>
GtkComboBox        *combo_box, GtkSensitivityType  sensitivity
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_button_sensitivity</NAME>
<RETURNS>GtkSensitivityType</RETURNS>
GtkComboBox        *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_has_entry</NAME>
<RETURNS>gboolean</RETURNS>
GtkComboBox        *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_entry_text_column</NAME>
<RETURNS>void</RETURNS>
GtkComboBox        *combo_box, gint                text_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_entry_text_column</NAME>
<RETURNS>gint</RETURNS>
GtkComboBox        *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_popup_fixed_width</NAME>
<RETURNS>void</RETURNS>
GtkComboBox      *combo_box, gboolean          fixed
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_popup_fixed_width</NAME>
<RETURNS>gboolean</RETURNS>
GtkComboBox      *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_popup</NAME>
<RETURNS>void</RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_popup_for_device</NAME>
<RETURNS>void</RETURNS>
GtkComboBox     *combo_box, GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_popdown</NAME>
<RETURNS>void</RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_popup_accessible</NAME>
<RETURNS>AtkObject *</RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_id_column</NAME>
<RETURNS>gint</RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_id_column</NAME>
<RETURNS>void</RETURNS>
GtkComboBox *combo_box, gint         id_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_active_id</NAME>
<RETURNS>const gchar *</RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active_id</NAME>
<RETURNS>gboolean</RETURNS>
GtkComboBox *combo_box, const gchar *active_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_child</NAME>
<RETURNS>void</RETURNS>
GtkComboBox *combo_box, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_COMBO_BOX_TEXT</NAME>
#define GTK_TYPE_COMBO_BOX_TEXT                 (gtk_combo_box_text_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX_TEXT</NAME>
#define GTK_COMBO_BOX_TEXT(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMBO_BOX_TEXT, GtkComboBoxText))
</MACRO>
<MACRO>
<NAME>GTK_IS_COMBO_BOX_TEXT</NAME>
#define GTK_IS_COMBO_BOX_TEXT(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMBO_BOX_TEXT))
</MACRO>
<FUNCTION>
<NAME>gtk_combo_box_text_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_new_with_entry</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_append_text</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_insert_text</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, gint                 position, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_prepend_text</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_remove</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, gint                 position
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_remove_all</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_get_active_text</NAME>
<RETURNS>gchar *</RETURNS>
GtkComboBoxText     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_insert</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, gint                 position, const gchar         *id, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_append</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, const gchar         *id, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_prepend</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, const gchar         *id, const gchar         *text
</FUNCTION>
<STRUCT>
<NAME>GtkComboBoxText</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkComposeTable</NAME>
struct _GtkComposeTable
{
  guint16 *data;
  gint max_seq_len;
  gint n_seqs;
  guint32 id;
};
</STRUCT>
<STRUCT>
<NAME>GtkComposeTableCompact</NAME>
struct _GtkComposeTableCompact
{
  const guint16 *data;
  gint max_seq_len;
  gint n_index_size;
  gint n_index_stride;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_compose_table_new_with_file</NAME>
<RETURNS>GtkComposeTable *</RETURNS>
const gchar   *compose_file
</FUNCTION>
<FUNCTION>
<NAME>gtk_compose_table_list_add_array</NAME>
<RETURNS>GSList *</RETURNS>
GSList        *compose_tables, const guint16 *data, gint           max_seq_len, gint           n_seqs
</FUNCTION>
<FUNCTION>
<NAME>gtk_compose_table_list_add_file</NAME>
<RETURNS>GSList *</RETURNS>
GSList        *compose_tables, const gchar   *compose_file
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_TARGET</NAME>
#define GTK_TYPE_CONSTRAINT_TARGET (gtk_constraint_target_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT</NAME>
#define GTK_TYPE_CONSTRAINT (gtk_constraint_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_constraint_new</NAME>
<RETURNS>GtkConstraint *</RETURNS>
gpointer                target, GtkConstraintAttribute  target_attribute, GtkConstraintRelation   relation, gpointer                source, GtkConstraintAttribute  source_attribute, double                  multiplier, double                  constant, int                     strength
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_new_constant</NAME>
<RETURNS>GtkConstraint *</RETURNS>
gpointer                target, GtkConstraintAttribute  target_attribute, GtkConstraintRelation   relation, double                  constant, int                     strength
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_target</NAME>
<RETURNS>GtkConstraintTarget *</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_target_attribute</NAME>
<RETURNS>GtkConstraintAttribute</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_source</NAME>
<RETURNS>GtkConstraintTarget *</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_source_attribute</NAME>
<RETURNS>GtkConstraintAttribute</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_relation</NAME>
<RETURNS>GtkConstraintRelation</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_multiplier</NAME>
<RETURNS>double</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_constant</NAME>
<RETURNS>double</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_get_strength</NAME>
<RETURNS>int</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_is_required</NAME>
<RETURNS>gboolean</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_is_attached</NAME>
<RETURNS>gboolean</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_is_constant</NAME>
<RETURNS>gboolean</RETURNS>
GtkConstraint          *constraint
</FUNCTION>
<STRUCT>
<NAME>GtkConstraint</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkConstraintTarget</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkConstraintTargetInterface</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_GUIDE</NAME>
#define GTK_TYPE_CONSTRAINT_GUIDE (gtk_constraint_guide_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_constraint_guide_new</NAME>
<RETURNS>GtkConstraintGuide *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_set_min_size</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide *guide, int                 width, int                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_get_min_size</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide *guide, int                *width, int                *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_set_nat_size</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide *guide, int                 width, int                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_get_nat_size</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide *guide, int                *width, int                *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_set_max_size</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide *guide, int                 width, int                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_get_max_size</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide *guide, int                *width, int                *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_get_strength</NAME>
<RETURNS>GtkConstraintStrength</RETURNS>
GtkConstraintGuide *guide
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_set_strength</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide    *guide, GtkConstraintStrength  strength
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_set_name</NAME>
<RETURNS>void</RETURNS>
GtkConstraintGuide *guide, const char         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_guide_get_name</NAME>
<RETURNS>const char *</RETURNS>
GtkConstraintGuide *guide
</FUNCTION>
<STRUCT>
<NAME>GtkConstraintGuide</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_LAYOUT</NAME>
#define GTK_TYPE_CONSTRAINT_LAYOUT (gtk_constraint_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_LAYOUT_CHILD</NAME>
#define GTK_TYPE_CONSTRAINT_LAYOUT_CHILD (gtk_constraint_layout_child_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CONSTRAINT_VFL_PARSER_ERROR</NAME>
#define GTK_CONSTRAINT_VFL_PARSER_ERROR (gtk_constraint_vfl_parser_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gtk_constraint_vfl_parser_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_add_constraint</NAME>
<RETURNS>void</RETURNS>
GtkConstraintLayout *layout, GtkConstraint       *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_remove_constraint</NAME>
<RETURNS>void</RETURNS>
GtkConstraintLayout *layout, GtkConstraint       *constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_add_guide</NAME>
<RETURNS>void</RETURNS>
GtkConstraintLayout *layout, GtkConstraintGuide  *guide
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_remove_guide</NAME>
<RETURNS>void</RETURNS>
GtkConstraintLayout *layout, GtkConstraintGuide  *guide
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_remove_all_constraints</NAME>
<RETURNS>void</RETURNS>
GtkConstraintLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_add_constraints_from_description</NAME>
<RETURNS>GList *</RETURNS>
GtkConstraintLayout *layout, const char * const   lines[], gsize                n_lines, int                  hspacing, int                  vspacing, GError             **error, const char          *first_view, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_add_constraints_from_descriptionv</NAME>
<RETURNS>GList *</RETURNS>
GtkConstraintLayout *layout, const char * const   lines[], gsize                n_lines, int                  hspacing, int                  vspacing, GHashTable          *views, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_observe_constraints</NAME>
<RETURNS>GListModel *</RETURNS>
GtkConstraintLayout *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_constraint_layout_observe_guides</NAME>
<RETURNS>GListModel *</RETURNS>
GtkConstraintLayout *layout
</FUNCTION>
<STRUCT>
<NAME>GtkConstraintLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkConstraintLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_COUNTING_BLOOM_FILTER_BITS</NAME>
#define GTK_COUNTING_BLOOM_FILTER_BITS (12)
</MACRO>
<MACRO>
<NAME>GTK_COUNTING_BLOOM_FILTER_SIZE</NAME>
#define GTK_COUNTING_BLOOM_FILTER_SIZE (1 << GTK_COUNTING_BLOOM_FILTER_BITS)
</MACRO>
<STRUCT>
<NAME>GtkCountingBloomFilter</NAME>
struct _GtkCountingBloomFilter
{
  guint8        buckets[GTK_COUNTING_BLOOM_FILTER_SIZE];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_counting_bloom_filter_add</NAME>
<RETURNS>void</RETURNS>
GtkCountingBloomFilter         *self, guint16                         hash static inline void      gtk_counting_bloom_filter_remove        (GtkCountingBloomFilter         *self, guint16                         hash static inline gboolean  gtk_counting_bloom_filter_may_contain   (const GtkCountingBloomFilter   *self, guint16                         hash /* * GTK_COUNTING_BLOOM_FILTER_INIT: * * Initialize the bloom filter. As bloom filters are always stack-allocated, * initialization should happen when defining them, like: * ```c * GtkCountingBloomFilter filter = GTK_COUNTING_BLOOM_FILTER_INIT; * ``` * * The filter does not need to be freed. */ #define GTK_COUNTING_BLOOM_FILTER_INIT;
</FUNCTION>
<FUNCTION>
<NAME>gtk_counting_bloom_filter_remove</NAME>
<RETURNS>void</RETURNS>
GtkCountingBloomFilter *self, guint16                 hash
</FUNCTION>
<FUNCTION>
<NAME>gtk_counting_bloom_filter_may_contain</NAME>
<RETURNS>gboolean</RETURNS>
const GtkCountingBloomFilter *self, guint16                       hash
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_init</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes, GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_init_content_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes, GtkCssStyle *style, double       x, double       y, double       width, double       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_init_border_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes, GtkCssStyle *style, double       x, double       y, double       width, double       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_rect_grow</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect *dest, GskRoundedRect *src, GtkCssValue    *top, GtkCssValue    *right, GtkCssValue    *bottom, GtkCssValue    *left
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_rect_shrink</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect *dest, GskRoundedRect *src, GtkCssValue    *top_value, GtkCssValue    *right_value, GtkCssValue    *bottom_value, GtkCssValue    *left_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_padding_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes static inline const graphene_rect_t * gtk_css_boxes_get_rect (GtkCssBoxes *boxes, GtkCssArea   area
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_border_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_content_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_margin_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_outline_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_margin_rect</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_border_rect</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_padding_rect</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_content_rect</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_outline_rect</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_clamp_border_radius</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_apply_border_radius</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect    *box, const GtkCssValue *top_left, const GtkCssValue *top_right, const GtkCssValue *bottom_right, const GtkCssValue *bottom_left
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_shrink_border_radius</NAME>
<RETURNS>void</RETURNS>
graphene_size_t       *dest, const graphene_size_t *src, double                 width, double                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_shrink_corners</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect       *dest, const GskRoundedRect *src
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_border_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_padding_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_content_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_outline_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_box</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GtkCssBoxes *boxes, GtkCssArea  area
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_border_box</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_padding_box</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_content_box</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_outline_box</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CSS_PROVIDER</NAME>
#define GTK_TYPE_CSS_PROVIDER         (gtk_css_provider_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CSS_PROVIDER</NAME>
#define GTK_CSS_PROVIDER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_CSS_PROVIDER, GtkCssProvider))
</MACRO>
<MACRO>
<NAME>GTK_IS_CSS_PROVIDER</NAME>
#define GTK_IS_CSS_PROVIDER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_CSS_PROVIDER))
</MACRO>
<STRUCT>
<NAME>GtkCssProvider</NAME>
struct _GtkCssProvider
{
  GObject parent_instance;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_css_provider_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_new</NAME>
<RETURNS>GtkCssProvider *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_to_string</NAME>
<RETURNS>char *</RETURNS>
GtkCssProvider  *provider
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_data</NAME>
<RETURNS>void</RETURNS>
GtkCssProvider  *css_provider, const gchar     *data, gssize           length
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_file</NAME>
<RETURNS>void</RETURNS>
GtkCssProvider  *css_provider, GFile           *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_path</NAME>
<RETURNS>void</RETURNS>
GtkCssProvider  *css_provider, const gchar     *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_resource</NAME>
<RETURNS>void</RETURNS>
GtkCssProvider *css_provider, const gchar    *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_named</NAME>
<RETURNS>void</RETURNS>
GtkCssProvider  *provider, const char      *name, const char      *variant
</FUNCTION>
<STRUCT>
<NAME>GtkCssProviderClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCssProviderPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CUSTOM_LAYOUT</NAME>
#define GTK_TYPE_CUSTOM_LAYOUT (gtk_custom_layout_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkCustomRequestModeFunc</NAME>
<RETURNS>GtkSizeRequestMode</RETURNS>
GtkWidget *widget
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkCustomMeasureFunc</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, GtkOrientation  orientation, int             for_size, int            *minimum, int            *natural, int            *minimum_baseline, int            *natural_baseline
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkCustomAllocateFunc</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, int           width, int           height, int           baseline
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_custom_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
GtkCustomRequestModeFunc request_mode, GtkCustomMeasureFunc     measure, GtkCustomAllocateFunc    allocate
</FUNCTION>
<STRUCT>
<NAME>GtkCustomLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG</NAME>
#define GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG                  (gtk_custom_paper_unix_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CUSTOM_PAPER_UNIX_DIALOG</NAME>
#define GTK_CUSTOM_PAPER_UNIX_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG, GtkCustomPaperUnixDialog))
</MACRO>
<MACRO>
<NAME>GTK_CUSTOM_PAPER_UNIX_DIALOG_CLASS</NAME>
#define GTK_CUSTOM_PAPER_UNIX_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG, GtkCustomPaperUnixDialogClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CUSTOM_PAPER_UNIX_DIALOG</NAME>
#define GTK_IS_CUSTOM_PAPER_UNIX_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_IS_CUSTOM_PAPER_UNIX_DIALOG_CLASS</NAME>
#define GTK_IS_CUSTOM_PAPER_UNIX_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_CUSTOM_PAPER_UNIX_DIALOG_GET_CLASS</NAME>
#define GTK_CUSTOM_PAPER_UNIX_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG, GtkCustomPaperUnixDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkCustomPaperUnixDialog</NAME>
struct _GtkCustomPaperUnixDialog
{
  GtkDialog parent_instance;

  GtkCustomPaperUnixDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCustomPaperUnixDialogClass</NAME>
struct _GtkCustomPaperUnixDialogClass
{
  GtkDialogClass parent_class;

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_custom_paper_unix_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCustomPaperUnixDialogPrivate</NAME>
</STRUCT>
<ENUM>
<NAME>GtkDebugFlag</NAME>
typedef enum {
  GTK_DEBUG_TEXT            = 1 <<  0,
  GTK_DEBUG_TREE            = 1 <<  1,
  GTK_DEBUG_KEYBINDINGS     = 1 <<  2,
  GTK_DEBUG_MODULES         = 1 <<  3,
  GTK_DEBUG_GEOMETRY        = 1 <<  4,
  GTK_DEBUG_ICONTHEME       = 1 <<  5,
  GTK_DEBUG_PRINTING        = 1 <<  6,
  GTK_DEBUG_BUILDER         = 1 <<  7,
  GTK_DEBUG_SIZE_REQUEST    = 1 <<  8,
  GTK_DEBUG_NO_CSS_CACHE    = 1 <<  9,
  GTK_DEBUG_INTERACTIVE     = 1 << 11,
  GTK_DEBUG_TOUCHSCREEN     = 1 << 12,
  GTK_DEBUG_ACTIONS         = 1 << 13,
  GTK_DEBUG_RESIZE          = 1 << 14,
  GTK_DEBUG_LAYOUT          = 1 << 15,
  GTK_DEBUG_SNAPSHOT        = 1 << 16,
  GTK_DEBUG_CONSTRAINTS     = 1 << 17,
} GtkDebugFlag;
</ENUM>
<MACRO>
<NAME>GTK_DEBUG_CHECK</NAME>
#define GTK_DEBUG_CHECK(type) G_UNLIKELY (gtk_get_debug_flags () & GTK_DEBUG_##type)
</MACRO>
<MACRO>
<NAME>GTK_NOTE</NAME>
#define GTK_NOTE(type,action)                G_STMT_START {     \
    if (GTK_DEBUG_CHECK (type))		                        \
       { action; };                          } G_STMT_END
</MACRO>
<FUNCTION>
<NAME>gtk_get_debug_flags</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_set_debug_flags</NAME>
<RETURNS>void</RETURNS>
guint flags
</FUNCTION>
<ENUM>
<NAME>GtkDialogFlags</NAME>
typedef enum
{
  GTK_DIALOG_MODAL               = 1 << 0,
  GTK_DIALOG_DESTROY_WITH_PARENT = 1 << 1,
  GTK_DIALOG_USE_HEADER_BAR      = 1 << 2
} GtkDialogFlags;
</ENUM>
<ENUM>
<NAME>GtkResponseType</NAME>
typedef enum
{
  GTK_RESPONSE_NONE         = -1,
  GTK_RESPONSE_REJECT       = -2,
  GTK_RESPONSE_ACCEPT       = -3,
  GTK_RESPONSE_DELETE_EVENT = -4,
  GTK_RESPONSE_OK           = -5,
  GTK_RESPONSE_CANCEL       = -6,
  GTK_RESPONSE_CLOSE        = -7,
  GTK_RESPONSE_YES          = -8,
  GTK_RESPONSE_NO           = -9,
  GTK_RESPONSE_APPLY        = -10,
  GTK_RESPONSE_HELP         = -11
} GtkResponseType;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_DIALOG</NAME>
#define GTK_TYPE_DIALOG                  (gtk_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_DIALOG</NAME>
#define GTK_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_DIALOG, GtkDialog))
</MACRO>
<MACRO>
<NAME>GTK_DIALOG_CLASS</NAME>
#define GTK_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_DIALOG, GtkDialogClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_DIALOG</NAME>
#define GTK_IS_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_IS_DIALOG_CLASS</NAME>
#define GTK_IS_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_DIALOG_GET_CLASS</NAME>
#define GTK_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_DIALOG, GtkDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkDialog</NAME>
struct _GtkDialog
{
  GtkWindow parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkDialogClass</NAME>
struct _GtkDialogClass
{
  GtkWindowClass parent_class;

  /*< public >*/

  void (* response) (GtkDialog *dialog, gint response_id);

  /* Keybinding signals */

  void (* close)    (GtkDialog *dialog);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_new_with_buttons</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *title, GtkWindow       *parent, GtkDialogFlags   flags, const gchar     *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkDialog   *dialog, GtkWidget   *child, gint         response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDialog   *dialog, const gchar *button_text, gint         response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_buttons</NAME>
<RETURNS>void</RETURNS>
GtkDialog   *dialog, const gchar *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_set_response_sensitive</NAME>
<RETURNS>void</RETURNS>
GtkDialog *dialog, gint       response_id, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_set_default_response</NAME>
<RETURNS>void</RETURNS>
GtkDialog *dialog, gint       response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_widget_for_response</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDialog *dialog, gint       response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_response_for_widget</NAME>
<RETURNS>gint</RETURNS>
GtkDialog *dialog, GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_response</NAME>
<RETURNS>void</RETURNS>
GtkDialog *dialog, gint       response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_content_area</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_header_bar</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_handle_event</NAME>
<RETURNS>void</RETURNS>
GtkWidget     *toplevel, GdkEvent      *event
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_DRAG_ICON</NAME>
#define GTK_TYPE_DRAG_ICON (gtk_drag_icon_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_drag_icon_get_for_drag</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkDrag                *drag
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_icon_set_child</NAME>
<RETURNS>void</RETURNS>
GtkDragIcon            *self, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_icon_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDragIcon            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_icon_set_from_paintable</NAME>
<RETURNS>void</RETURNS>
GdkDrag      *drag, GdkPaintable *paintable, int           hot_x, int           hot_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_icon_create_widget_for_value</NAME>
<RETURNS>GtkWidget *</RETURNS>
const GValue           *value
</FUNCTION>
<STRUCT>
<NAME>GtkDragIcon</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_DRAG_SOURCE</NAME>
#define GTK_TYPE_DRAG_SOURCE         (gtk_drag_source_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_DRAG_SOURCE</NAME>
#define GTK_DRAG_SOURCE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_DRAG_SOURCE, GtkDragSource))
</MACRO>
<MACRO>
<NAME>GTK_DRAG_SOURCE_CLASS</NAME>
#define GTK_DRAG_SOURCE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_DRAG_SOURCE, GtkDragSourceClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_DRAG_SOURCE</NAME>
#define GTK_IS_DRAG_SOURCE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_DRAG_SOURCE))
</MACRO>
<MACRO>
<NAME>GTK_IS_DRAG_SOURCE_CLASS</NAME>
#define GTK_IS_DRAG_SOURCE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_DRAG_SOURCE))
</MACRO>
<MACRO>
<NAME>GTK_DRAG_SOURCE_GET_CLASS</NAME>
#define GTK_DRAG_SOURCE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_DRAG_SOURCE, GtkDragSourceClass))
</MACRO>
<FUNCTION>
<NAME>gtk_drag_source_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_new</NAME>
<RETURNS>GtkDragSource *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set_content</NAME>
<RETURNS>void</RETURNS>
GtkDragSource     *source, GdkContentProvider *content
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_get_content</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GtkDragSource     *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set_actions</NAME>
<RETURNS>void</RETURNS>
GtkDragSource     *source, GdkDragAction      actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GtkDragSource     *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set_icon</NAME>
<RETURNS>void</RETURNS>
GtkDragSource     *source, GdkPaintable      *paintable, int                hot_x, int                hot_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_drag_cancel</NAME>
<RETURNS>void</RETURNS>
GtkDragSource     *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_get_drag</NAME>
<RETURNS>GdkDrag *</RETURNS>
GtkDragSource     *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_check_threshold</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget         *widget, int                start_x, int                start_y, int                current_x, int                current_y
</FUNCTION>
<STRUCT>
<NAME>GtkDragSource</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkDragSourceClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_DRAWING_AREA</NAME>
#define GTK_TYPE_DRAWING_AREA            (gtk_drawing_area_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_DRAWING_AREA</NAME>
#define GTK_DRAWING_AREA(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_DRAWING_AREA, GtkDrawingArea))
</MACRO>
<MACRO>
<NAME>GTK_DRAWING_AREA_CLASS</NAME>
#define GTK_DRAWING_AREA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_DRAWING_AREA, GtkDrawingAreaClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_DRAWING_AREA</NAME>
#define GTK_IS_DRAWING_AREA(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_DRAWING_AREA))
</MACRO>
<MACRO>
<NAME>GTK_IS_DRAWING_AREA_CLASS</NAME>
#define GTK_IS_DRAWING_AREA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_DRAWING_AREA))
</MACRO>
<MACRO>
<NAME>GTK_DRAWING_AREA_GET_CLASS</NAME>
#define GTK_DRAWING_AREA_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_DRAWING_AREA, GtkDrawingAreaClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkDrawingAreaDrawFunc</NAME>
<RETURNS>void</RETURNS>
GtkDrawingArea *drawing_area, cairo_t        *cr, int             width, int             height, gpointer        user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkDrawingArea</NAME>
struct _GtkDrawingArea
{
  GtkWidget widget;
};
</STRUCT>
<STRUCT>
<NAME>GtkDrawingAreaClass</NAME>
struct _GtkDrawingAreaClass
{
  GtkWidgetClass parent_class;

  void           (* resize)         (GtkDrawingArea *area,
                                     int             width,
                                     int             height);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_drawing_area_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drawing_area_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drawing_area_set_content_width</NAME>
<RETURNS>void</RETURNS>
GtkDrawingArea         *self, int                     width
</FUNCTION>
<FUNCTION>
<NAME>gtk_drawing_area_get_content_width</NAME>
<RETURNS>int</RETURNS>
GtkDrawingArea         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drawing_area_set_content_height</NAME>
<RETURNS>void</RETURNS>
GtkDrawingArea         *self, int                     height
</FUNCTION>
<FUNCTION>
<NAME>gtk_drawing_area_get_content_height</NAME>
<RETURNS>int</RETURNS>
GtkDrawingArea         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drawing_area_set_draw_func</NAME>
<RETURNS>void</RETURNS>
GtkDrawingArea         *self, GtkDrawingAreaDrawFunc  draw_func, gpointer                user_data, GDestroyNotify          destroy
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_DROP_CONTROLLER_MOTION</NAME>
#define GTK_TYPE_DROP_CONTROLLER_MOTION         (gtk_drop_controller_motion_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_DROP_CONTROLLER_MOTION</NAME>
#define GTK_DROP_CONTROLLER_MOTION(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_DROP_CONTROLLER_MOTION, GtkDropControllerMotion))
</MACRO>
<MACRO>
<NAME>GTK_DROP_CONTROLLER_MOTION_CLASS</NAME>
#define GTK_DROP_CONTROLLER_MOTION_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_DROP_CONTROLLER_MOTION, GtkDropControllerMotionClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_DROP_CONTROLLER_MOTION</NAME>
#define GTK_IS_DROP_CONTROLLER_MOTION(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_DROP_CONTROLLER_MOTION))
</MACRO>
<MACRO>
<NAME>GTK_IS_DROP_CONTROLLER_MOTION_CLASS</NAME>
#define GTK_IS_DROP_CONTROLLER_MOTION_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_DROP_CONTROLLER_MOTION))
</MACRO>
<MACRO>
<NAME>GTK_DROP_CONTROLLER_MOTION_GET_CLASS</NAME>
#define GTK_DROP_CONTROLLER_MOTION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_DROP_CONTROLLER_MOTION, GtkDropControllerMotionClass))
</MACRO>
<FUNCTION>
<NAME>gtk_drop_controller_motion_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_controller_motion_new</NAME>
<RETURNS>GtkEventController *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_controller_motion_contains_pointer</NAME>
<RETURNS>gboolean</RETURNS>
GtkDropControllerMotion        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_controller_motion_get_drop</NAME>
<RETURNS>GdkDrop *</RETURNS>
GtkDropControllerMotion        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_controller_motion_is_pointer</NAME>
<RETURNS>gboolean</RETURNS>
GtkDropControllerMotion        *self
</FUNCTION>
<STRUCT>
<NAME>GtkDropControllerMotion</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkDropControllerMotionClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_drop_begin_event</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *drop, GdkEventType            event_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_end_event</NAME>
<RETURNS>void</RETURNS>
GdkDrop                *drop
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_status</NAME>
<RETURNS>gboolean</RETURNS>
GdkDrop                *drop, GdkDragAction           actions, GdkDragAction           preferred_action
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_DROP_TARGET</NAME>
#define GTK_TYPE_DROP_TARGET         (gtk_drop_target_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_DROP_TARGET</NAME>
#define GTK_DROP_TARGET(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_DROP_TARGET, GtkDropTarget))
</MACRO>
<MACRO>
<NAME>GTK_DROP_TARGET_CLASS</NAME>
#define GTK_DROP_TARGET_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_DROP_TARGET, GtkDropTargetClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_DROP_TARGET</NAME>
#define GTK_IS_DROP_TARGET(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_DROP_TARGET))
</MACRO>
<MACRO>
<NAME>GTK_IS_DROP_TARGET_CLASS</NAME>
#define GTK_IS_DROP_TARGET_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_DROP_TARGET))
</MACRO>
<MACRO>
<NAME>GTK_DROP_TARGET_GET_CLASS</NAME>
#define GTK_DROP_TARGET_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_DROP_TARGET, GtkDropTargetClass))
</MACRO>
<FUNCTION>
<NAME>gtk_drop_target_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_new</NAME>
<RETURNS>GtkDropTarget *</RETURNS>
GType                  type, GdkDragAction          actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_set_gtypes</NAME>
<RETURNS>void</RETURNS>
GtkDropTarget         *self, GType                 *types, gsize                  n_types
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_get_gtypes</NAME>
<RETURNS>const GType *</RETURNS>
GtkDropTarget         *self, gsize                 *n_types
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GtkDropTarget         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_set_actions</NAME>
<RETURNS>void</RETURNS>
GtkDropTarget         *self, GdkDragAction          actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GtkDropTarget         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_set_preload</NAME>
<RETURNS>void</RETURNS>
GtkDropTarget         *self, gboolean               preload
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_get_preload</NAME>
<RETURNS>gboolean</RETURNS>
GtkDropTarget         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_get_drop</NAME>
<RETURNS>GdkDrop *</RETURNS>
GtkDropTarget         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_get_value</NAME>
<RETURNS>const GValue *</RETURNS>
GtkDropTarget         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_reject</NAME>
<RETURNS>void</RETURNS>
GtkDropTarget         *self
</FUNCTION>
<STRUCT>
<NAME>GtkDropTarget</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkDropTargetClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_DROP_TARGET_ASYNC</NAME>
#define GTK_TYPE_DROP_TARGET_ASYNC         (gtk_drop_target_async_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_DROP_TARGET_ASYNC</NAME>
#define GTK_DROP_TARGET_ASYNC(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_DROP_TARGET_ASYNC, GtkDropTargetAsync))
</MACRO>
<MACRO>
<NAME>GTK_DROP_TARGET_ASYNC_CLASS</NAME>
#define GTK_DROP_TARGET_ASYNC_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_DROP_TARGET_ASYNC, GtkDropTargetAsyncClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_DROP_TARGET_ASYNC</NAME>
#define GTK_IS_DROP_TARGET_ASYNC(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_DROP_TARGET_ASYNC))
</MACRO>
<MACRO>
<NAME>GTK_IS_DROP_TARGET_ASYNC_CLASS</NAME>
#define GTK_IS_DROP_TARGET_ASYNC_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_DROP_TARGET_ASYNC))
</MACRO>
<MACRO>
<NAME>GTK_DROP_TARGET_ASYNC_GET_CLASS</NAME>
#define GTK_DROP_TARGET_ASYNC_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_DROP_TARGET_ASYNC, GtkDropTargetAsyncClass))
</MACRO>
<FUNCTION>
<NAME>gtk_drop_target_async_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_async_new</NAME>
<RETURNS>GtkDropTargetAsync *</RETURNS>
GdkContentFormats      *formats, GdkDragAction           actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_async_set_formats</NAME>
<RETURNS>void</RETURNS>
GtkDropTargetAsync     *self, GdkContentFormats      *formats
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_async_get_formats</NAME>
<RETURNS>GdkContentFormats *</RETURNS>
GtkDropTargetAsync     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_async_set_actions</NAME>
<RETURNS>void</RETURNS>
GtkDropTargetAsync     *self, GdkDragAction           actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_async_get_actions</NAME>
<RETURNS>GdkDragAction</RETURNS>
GtkDropTargetAsync     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_target_async_reject_drop</NAME>
<RETURNS>void</RETURNS>
GtkDropTargetAsync     *self, GdkDrop                *drop
</FUNCTION>
<STRUCT>
<NAME>GtkDropTargetAsync</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkDropTargetAsyncClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EDITABLE</NAME>
#define GTK_TYPE_EDITABLE             (gtk_editable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EDITABLE</NAME>
#define GTK_EDITABLE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EDITABLE, GtkEditable))
</MACRO>
<MACRO>
<NAME>GTK_IS_EDITABLE</NAME>
#define GTK_IS_EDITABLE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EDITABLE))
</MACRO>
<MACRO>
<NAME>GTK_EDITABLE_GET_IFACE</NAME>
#define GTK_EDITABLE_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_EDITABLE, GtkEditableInterface))
</MACRO>
<STRUCT>
<NAME>GtkEditableInterface</NAME>
struct _GtkEditableInterface
{
  GTypeInterface                   base_iface;

  /* signals */
  void (* insert_text)              (GtkEditable    *editable,
                                     const gchar    *text,
                                     int             length,
                                     int            *position);
  void (* delete_text)              (GtkEditable    *editable,
                                     int             start_pos,
                                     int             end_pos);
  void (* changed)                  (GtkEditable    *editable);

  /* vtable */
  const char * (* get_text)         (GtkEditable    *editable);
  void     (* do_insert_text)       (GtkEditable    *editable,
                                     const char     *text,
                                     int             length,
                                     int            *position);
  void     (* do_delete_text)       (GtkEditable    *editable,
                                     int             start_pos,
                                     int             end_pos);

  gboolean (* get_selection_bounds) (GtkEditable    *editable,
                                     int            *start_pos,
                                     int            *end_pos);
  void     (* set_selection_bounds) (GtkEditable    *editable,
                                     int             start_pos,
                                     int             end_pos);
  GtkEditable * (* get_delegate)    (GtkEditable    *editable);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_editable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_text</NAME>
<RETURNS>const char *</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_set_text</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, const char  *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_chars</NAME>
<RETURNS>char *</RETURNS>
GtkEditable *editable, int          start_pos, int          end_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_insert_text</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, const char  *text, int          length, int         *position
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_delete_text</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, int          start_pos, int          end_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_selection_bounds</NAME>
<RETURNS>gboolean</RETURNS>
GtkEditable *editable, int         *start_pos, int         *end_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_delete_selection</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_select_region</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, int          start_pos, int          end_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_set_position</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, int          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_position</NAME>
<RETURNS>int</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_editable</NAME>
<RETURNS>gboolean</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_set_editable</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, gboolean     is_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_alignment</NAME>
<RETURNS>float</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_set_alignment</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, float        xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_width_chars</NAME>
<RETURNS>int</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_set_width_chars</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, int          n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_max_width_chars</NAME>
<RETURNS>int</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_set_max_width_chars</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, int          n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_get_enable_undo</NAME>
<RETURNS>gboolean</RETURNS>
GtkEditable *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_set_enable_undo</NAME>
<RETURNS>void</RETURNS>
GtkEditable *editable, gboolean     enable_undo
</FUNCTION>
<ENUM>
<NAME>GtkEditableProperties</NAME>
typedef enum {
  GTK_EDITABLE_PROP_TEXT,
  GTK_EDITABLE_PROP_CURSOR_POSITION,
  GTK_EDITABLE_PROP_SELECTION_BOUND,
  GTK_EDITABLE_PROP_EDITABLE,
  GTK_EDITABLE_PROP_WIDTH_CHARS,
  GTK_EDITABLE_PROP_MAX_WIDTH_CHARS,
  GTK_EDITABLE_PROP_XALIGN,
  GTK_EDITABLE_PROP_ENABLE_UNDO,
  GTK_EDITABLE_NUM_PROPERTIES
} GtkEditableProperties;
</ENUM>
<FUNCTION>
<NAME>gtk_editable_install_properties</NAME>
<RETURNS>guint</RETURNS>
GObjectClass *object_class, guint         first_prop
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_init_delegate</NAME>
<RETURNS>void</RETURNS>
GtkEditable  *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_finish_delegate</NAME>
<RETURNS>void</RETURNS>
GtkEditable  *editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_delegate_set_property</NAME>
<RETURNS>gboolean</RETURNS>
GObject      *object, guint         prop_id, const GValue *value, GParamSpec   *pspec
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_delegate_get_property</NAME>
<RETURNS>gboolean</RETURNS>
GObject      *object, guint         prop_id, GValue       *value, GParamSpec   *pspec
</FUNCTION>
<STRUCT>
<NAME>GtkEditable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EMOJI_CHOOSER</NAME>
#define GTK_TYPE_EMOJI_CHOOSER                 (gtk_emoji_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EMOJI_CHOOSER</NAME>
#define GTK_EMOJI_CHOOSER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EMOJI_CHOOSER, GtkEmojiChooser))
</MACRO>
<MACRO>
<NAME>GTK_EMOJI_CHOOSER_CLASS</NAME>
#define GTK_EMOJI_CHOOSER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EMOJI_CHOOSER, GtkEmojiChooserClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EMOJI_CHOOSER</NAME>
#define GTK_IS_EMOJI_CHOOSER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EMOJI_CHOOSER))
</MACRO>
<MACRO>
<NAME>GTK_IS_EMOJI_CHOOSER_CLASS</NAME>
#define GTK_IS_EMOJI_CHOOSER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EMOJI_CHOOSER))
</MACRO>
<MACRO>
<NAME>GTK_EMOJI_CHOOSER_GET_CLASS</NAME>
#define GTK_EMOJI_CHOOSER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_EMOJI_CHOOSER, GtkEmojiChooserClass))
</MACRO>
<FUNCTION>
<NAME>gtk_emoji_chooser_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_emoji_chooser_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkEmojiChooser</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEmojiChooserClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EMOJI_COMPLETION</NAME>
#define GTK_TYPE_EMOJI_COMPLETION                 (gtk_emoji_completion_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EMOJI_COMPLETION</NAME>
#define GTK_EMOJI_COMPLETION(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EMOJI_COMPLETION, GtkEmojiCompletion))
</MACRO>
<MACRO>
<NAME>GTK_EMOJI_COMPLETION_CLASS</NAME>
#define GTK_EMOJI_COMPLETION_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EMOJI_COMPLETION, GtkEmojiCompletionClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EMOJI_COMPLETION</NAME>
#define GTK_IS_EMOJI_COMPLETION(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EMOJI_COMPLETION))
</MACRO>
<MACRO>
<NAME>GTK_IS_EMOJI_COMPLETION_CLASS</NAME>
#define GTK_IS_EMOJI_COMPLETION_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EMOJI_COMPLETION))
</MACRO>
<MACRO>
<NAME>GTK_EMOJI_COMPLETION_GET_CLASS</NAME>
#define GTK_EMOJI_COMPLETION_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_EMOJI_COMPLETION, GtkEmojiCompletionClass))
</MACRO>
<FUNCTION>
<NAME>gtk_emoji_completion_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_emoji_completion_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkText *text
</FUNCTION>
<STRUCT>
<NAME>GtkEmojiCompletion</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEmojiCompletionClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ENTRY</NAME>
#define GTK_TYPE_ENTRY                  (gtk_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ENTRY</NAME>
#define GTK_ENTRY(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY, GtkEntry))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_CLASS</NAME>
#define GTK_ENTRY_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY, GtkEntryClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ENTRY</NAME>
#define GTK_IS_ENTRY(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY))
</MACRO>
<MACRO>
<NAME>GTK_IS_ENTRY_CLASS</NAME>
#define GTK_IS_ENTRY_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_GET_CLASS</NAME>
#define GTK_ENTRY_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ENTRY, GtkEntryClass))
</MACRO>
<ENUM>
<NAME>GtkEntryIconPosition</NAME>
typedef enum
{
  GTK_ENTRY_ICON_PRIMARY,
  GTK_ENTRY_ICON_SECONDARY
} GtkEntryIconPosition;
</ENUM>
<STRUCT>
<NAME>GtkEntry</NAME>
struct _GtkEntry
{
  /*< private >*/
  GtkWidget  parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkEntryClass</NAME>
struct _GtkEntryClass
{
  GtkWidgetClass parent_class;

  /* Action signals
   */
  void (* activate)           (GtkEntry             *entry);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_entry_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_new_with_buffer</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkEntryBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_buffer</NAME>
<RETURNS>GtkEntryBuffer *</RETURNS>
GtkEntry       *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_buffer</NAME>
<RETURNS>void</RETURNS>
GtkEntry       *entry, GtkEntryBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_visibility</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry, gboolean       visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_visibility</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_invisible_char</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry, gunichar       ch
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_invisible_char</NAME>
<RETURNS>gunichar</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_unset_invisible_char</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_has_frame</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_has_frame</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_overwrite_mode</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry, gboolean       overwrite
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_overwrite_mode</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_max_length</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry, gint           max
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_max_length</NAME>
<RETURNS>gint</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_text_length</NAME>
<RETURNS>guint16</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_activates_default</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_activates_default</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_alignment</NAME>
<RETURNS>void</RETURNS>
GtkEntry      *entry, gfloat         xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_alignment</NAME>
<RETURNS>gfloat</RETURNS>
GtkEntry      *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_completion</NAME>
<RETURNS>void</RETURNS>
GtkEntry           *entry, GtkEntryCompletion *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_completion</NAME>
<RETURNS>GtkEntryCompletion *</RETURNS>
GtkEntry           *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_progress_fraction</NAME>
<RETURNS>void</RETURNS>
GtkEntry     *entry, gdouble       fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_progress_fraction</NAME>
<RETURNS>gdouble</RETURNS>
GtkEntry     *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_progress_pulse_step</NAME>
<RETURNS>void</RETURNS>
GtkEntry     *entry, gdouble       fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_progress_pulse_step</NAME>
<RETURNS>gdouble</RETURNS>
GtkEntry     *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_progress_pulse</NAME>
<RETURNS>void</RETURNS>
GtkEntry     *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_placeholder_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_placeholder_text</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, const gchar          *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_from_paintable</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, GdkPaintable         *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_from_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, const gchar          *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_from_gicon</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, GIcon                *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_storage_type</NAME>
<RETURNS>GtkImageType</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_paintable</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_gicon</NAME>
<RETURNS>GIcon *</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_activatable</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, gboolean              activatable
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_activatable</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_sensitive</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, gboolean              sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_sensitive</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_at_pos</NAME>
<RETURNS>gint</RETURNS>
GtkEntry             *entry, gint                  x, gint                  y
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_tooltip_text</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, const gchar          *tooltip
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_tooltip_text</NAME>
<RETURNS>gchar *</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_tooltip_markup</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, const gchar          *tooltip
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_tooltip_markup</NAME>
<RETURNS>gchar *</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_drag_source</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, GdkContentProvider   *provider, GdkDragAction         actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_current_icon_drag_source</NAME>
<RETURNS>gint</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_area</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, GdkRectangle         *icon_area
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_reset_im_context</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_input_purpose</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkInputPurpose       purpose
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_input_purpose</NAME>
<RETURNS>GtkInputPurpose</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_input_hints</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkInputHints         hints
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_input_hints</NAME>
<RETURNS>GtkInputHints</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_attributes</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, PangoAttrList        *attrs
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_attributes</NAME>
<RETURNS>PangoAttrList *</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_tabs</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, PangoTabArray        *tabs
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_tabs</NAME>
<RETURNS>PangoTabArray *</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_grab_focus_without_selecting</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_extra_menu</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GMenuModel           *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_extra_menu</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkEntry             *entry
</FUNCTION>
<MACRO>
<NAME>GTK_ENTRY_BUFFER_MAX_SIZE</NAME>
#define GTK_ENTRY_BUFFER_MAX_SIZE        G_MAXUSHORT
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ENTRY_BUFFER</NAME>
#define GTK_TYPE_ENTRY_BUFFER            (gtk_entry_buffer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_BUFFER</NAME>
#define GTK_ENTRY_BUFFER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_BUFFER, GtkEntryBuffer))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_BUFFER_CLASS</NAME>
#define GTK_ENTRY_BUFFER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY_BUFFER, GtkEntryBufferClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ENTRY_BUFFER</NAME>
#define GTK_IS_ENTRY_BUFFER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY_BUFFER))
</MACRO>
<MACRO>
<NAME>GTK_IS_ENTRY_BUFFER_CLASS</NAME>
#define GTK_IS_ENTRY_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY_BUFFER))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_BUFFER_GET_CLASS</NAME>
#define GTK_ENTRY_BUFFER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ENTRY_BUFFER, GtkEntryBufferClass))
</MACRO>
<STRUCT>
<NAME>GtkEntryBuffer</NAME>
struct _GtkEntryBuffer
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkEntryBufferClass</NAME>
struct _GtkEntryBufferClass
{
  GObjectClass parent_class;

  /* Signals */

  void         (*inserted_text)          (GtkEntryBuffer *buffer,
                                          guint           position,
                                          const gchar    *chars,
                                          guint           n_chars);

  void         (*deleted_text)           (GtkEntryBuffer *buffer,
                                          guint           position,
                                          guint           n_chars);

  /* Virtual Methods */

  const gchar* (*get_text)               (GtkEntryBuffer *buffer,
                                          gsize          *n_bytes);

  guint        (*get_length)             (GtkEntryBuffer *buffer);

  guint        (*insert_text)            (GtkEntryBuffer *buffer,
                                          guint           position,
                                          const gchar    *chars,
                                          guint           n_chars);

  guint        (*delete_text)            (GtkEntryBuffer *buffer,
                                          guint           position,
                                          guint           n_chars);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
  void (*_gtk_reserved5) (void);
  void (*_gtk_reserved6) (void);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_entry_buffer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_new</NAME>
<RETURNS>GtkEntryBuffer *</RETURNS>
const gchar     *initial_chars, gint             n_initial_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_bytes</NAME>
<RETURNS>gsize</RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_length</NAME>
<RETURNS>guint</RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_set_text</NAME>
<RETURNS>void</RETURNS>
GtkEntryBuffer  *buffer, const gchar     *chars, gint             n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_set_max_length</NAME>
<RETURNS>void</RETURNS>
GtkEntryBuffer  *buffer, gint             max_length
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_max_length</NAME>
<RETURNS>gint</RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_insert_text</NAME>
<RETURNS>guint</RETURNS>
GtkEntryBuffer  *buffer, guint            position, const gchar     *chars, gint             n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_delete_text</NAME>
<RETURNS>guint</RETURNS>
GtkEntryBuffer  *buffer, guint            position, gint             n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_emit_inserted_text</NAME>
<RETURNS>void</RETURNS>
GtkEntryBuffer  *buffer, guint            position, const gchar     *chars, guint            n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_emit_deleted_text</NAME>
<RETURNS>void</RETURNS>
GtkEntryBuffer  *buffer, guint            position, guint            n_chars
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ENTRY_COMPLETION</NAME>
#define GTK_TYPE_ENTRY_COMPLETION            (gtk_entry_completion_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_COMPLETION</NAME>
#define GTK_ENTRY_COMPLETION(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_COMPLETION, GtkEntryCompletion))
</MACRO>
<MACRO>
<NAME>GTK_IS_ENTRY_COMPLETION</NAME>
#define GTK_IS_ENTRY_COMPLETION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY_COMPLETION))
</MACRO>
<USER_FUNCTION>
<NAME>GtkEntryCompletionMatchFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntryCompletion *completion, const gchar        *key, GtkTreeIter        *iter, gpointer            user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_new</NAME>
<RETURNS>GtkEntryCompletion *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_new_with_area</NAME>
<RETURNS>GtkEntryCompletion *</RETURNS>
GtkCellArea                 *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_entry</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_model</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, GtkTreeModel                *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_match_func</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, GtkEntryCompletionMatchFunc  func, gpointer                     func_data, GDestroyNotify               func_notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_minimum_key_length</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gint                         length
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_minimum_key_length</NAME>
<RETURNS>gint</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_compute_prefix</NAME>
<RETURNS>gchar *</RETURNS>
GtkEntryCompletion          *completion, const char                  *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_complete</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_insert_prefix</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_insert_action_text</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gint                         index_, const gchar                 *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_insert_action_markup</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gint                         index_, const gchar                 *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_delete_action</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gint                         index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_inline_completion</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gboolean                     inline_completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_inline_completion</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_inline_selection</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gboolean                     inline_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_inline_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_popup_completion</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gboolean                     popup_completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_popup_completion</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_popup_set_width</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gboolean                     popup_set_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_popup_set_width</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_popup_single_match</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gboolean                     popup_single_match
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_popup_single_match</NAME>
<RETURNS>gboolean</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_completion_prefix</NAME>
<RETURNS>const gchar *</RETURNS>
GtkEntryCompletion *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_text_column</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, gint                         column
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_text_column</NAME>
<RETURNS>gint</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<STRUCT>
<NAME>GtkEntryCompletion</NAME>
</STRUCT>
<ENUM>
<NAME>GtkAlign</NAME>
typedef enum
{
  GTK_ALIGN_FILL,
  GTK_ALIGN_START,
  GTK_ALIGN_END,
  GTK_ALIGN_CENTER,
  GTK_ALIGN_BASELINE
} GtkAlign;
</ENUM>
<ENUM>
<NAME>GtkArrowType</NAME>
typedef enum
{
  GTK_ARROW_UP,
  GTK_ARROW_DOWN,
  GTK_ARROW_LEFT,
  GTK_ARROW_RIGHT,
  GTK_ARROW_NONE
} GtkArrowType;
</ENUM>
<ENUM>
<NAME>GtkBaselinePosition</NAME>
typedef enum
{
  GTK_BASELINE_POSITION_TOP,
  GTK_BASELINE_POSITION_CENTER,
  GTK_BASELINE_POSITION_BOTTOM
} GtkBaselinePosition;
</ENUM>
<ENUM>
<NAME>GtkDeleteType</NAME>
typedef enum
{
  GTK_DELETE_CHARS,
  GTK_DELETE_WORD_ENDS,
  GTK_DELETE_WORDS,
  GTK_DELETE_DISPLAY_LINES,
  GTK_DELETE_DISPLAY_LINE_ENDS,
  GTK_DELETE_PARAGRAPH_ENDS,
  GTK_DELETE_PARAGRAPHS,
  GTK_DELETE_WHITESPACE
} GtkDeleteType;
</ENUM>
<ENUM>
<NAME>GtkDirectionType</NAME>
typedef enum
{
  GTK_DIR_TAB_FORWARD,
  GTK_DIR_TAB_BACKWARD,
  GTK_DIR_UP,
  GTK_DIR_DOWN,
  GTK_DIR_LEFT,
  GTK_DIR_RIGHT
} GtkDirectionType;
</ENUM>
<ENUM>
<NAME>GtkIconSize</NAME>
typedef enum
{
  GTK_ICON_SIZE_INHERIT,
  GTK_ICON_SIZE_NORMAL,
  GTK_ICON_SIZE_LARGE
} GtkIconSize;
</ENUM>
<ENUM>
<NAME>GtkSensitivityType</NAME>
typedef enum
{
  GTK_SENSITIVITY_AUTO,
  GTK_SENSITIVITY_ON,
  GTK_SENSITIVITY_OFF
} GtkSensitivityType;
</ENUM>
<ENUM>
<NAME>GtkTextDirection</NAME>
typedef enum
{
  GTK_TEXT_DIR_NONE,
  GTK_TEXT_DIR_LTR,
  GTK_TEXT_DIR_RTL
} GtkTextDirection;
</ENUM>
<ENUM>
<NAME>GtkJustification</NAME>
typedef enum
{
  GTK_JUSTIFY_LEFT,
  GTK_JUSTIFY_RIGHT,
  GTK_JUSTIFY_CENTER,
  GTK_JUSTIFY_FILL
} GtkJustification;
</ENUM>
<ENUM>
<NAME>GtkMenuDirectionType</NAME>
typedef enum
{
  GTK_MENU_DIR_PARENT,
  GTK_MENU_DIR_CHILD,
  GTK_MENU_DIR_NEXT,
  GTK_MENU_DIR_PREV
} GtkMenuDirectionType;
</ENUM>
<ENUM>
<NAME>GtkMessageType</NAME>
typedef enum
{
  GTK_MESSAGE_INFO,
  GTK_MESSAGE_WARNING,
  GTK_MESSAGE_QUESTION,
  GTK_MESSAGE_ERROR,
  GTK_MESSAGE_OTHER
} GtkMessageType;
</ENUM>
<ENUM>
<NAME>GtkMovementStep</NAME>
typedef enum
{
  GTK_MOVEMENT_LOGICAL_POSITIONS,
  GTK_MOVEMENT_VISUAL_POSITIONS,
  GTK_MOVEMENT_WORDS,
  GTK_MOVEMENT_DISPLAY_LINES,
  GTK_MOVEMENT_DISPLAY_LINE_ENDS,
  GTK_MOVEMENT_PARAGRAPHS,
  GTK_MOVEMENT_PARAGRAPH_ENDS,
  GTK_MOVEMENT_PAGES,
  GTK_MOVEMENT_BUFFER_ENDS,
  GTK_MOVEMENT_HORIZONTAL_PAGES
} GtkMovementStep;
</ENUM>
<ENUM>
<NAME>GtkScrollStep</NAME>
typedef enum
{
  GTK_SCROLL_STEPS,
  GTK_SCROLL_PAGES,
  GTK_SCROLL_ENDS,
  GTK_SCROLL_HORIZONTAL_STEPS,
  GTK_SCROLL_HORIZONTAL_PAGES,
  GTK_SCROLL_HORIZONTAL_ENDS
} GtkScrollStep;
</ENUM>
<ENUM>
<NAME>GtkOrientation</NAME>
typedef enum
{
  GTK_ORIENTATION_HORIZONTAL,
  GTK_ORIENTATION_VERTICAL
} GtkOrientation;
</ENUM>
<ENUM>
<NAME>GtkOverflow</NAME>
typedef enum
{
  GTK_OVERFLOW_VISIBLE,
  GTK_OVERFLOW_HIDDEN
} GtkOverflow;
</ENUM>
<ENUM>
<NAME>GtkPackType</NAME>
typedef enum
{
  GTK_PACK_START,
  GTK_PACK_END
} GtkPackType;
</ENUM>
<ENUM>
<NAME>GtkPositionType</NAME>
typedef enum
{
  GTK_POS_LEFT,
  GTK_POS_RIGHT,
  GTK_POS_TOP,
  GTK_POS_BOTTOM
} GtkPositionType;
</ENUM>
<ENUM>
<NAME>GtkScrollType</NAME>
typedef enum
{
  GTK_SCROLL_NONE,
  GTK_SCROLL_JUMP,
  GTK_SCROLL_STEP_BACKWARD,
  GTK_SCROLL_STEP_FORWARD,
  GTK_SCROLL_PAGE_BACKWARD,
  GTK_SCROLL_PAGE_FORWARD,
  GTK_SCROLL_STEP_UP,
  GTK_SCROLL_STEP_DOWN,
  GTK_SCROLL_PAGE_UP,
  GTK_SCROLL_PAGE_DOWN,
  GTK_SCROLL_STEP_LEFT,
  GTK_SCROLL_STEP_RIGHT,
  GTK_SCROLL_PAGE_LEFT,
  GTK_SCROLL_PAGE_RIGHT,
  GTK_SCROLL_START,
  GTK_SCROLL_END
} GtkScrollType;
</ENUM>
<ENUM>
<NAME>GtkSelectionMode</NAME>
typedef enum
{
  GTK_SELECTION_NONE,
  GTK_SELECTION_SINGLE,
  GTK_SELECTION_BROWSE,
  GTK_SELECTION_MULTIPLE
} GtkSelectionMode;
</ENUM>
<ENUM>
<NAME>GtkWrapMode</NAME>
typedef enum
{
  GTK_WRAP_NONE,
  GTK_WRAP_CHAR,
  GTK_WRAP_WORD,
  GTK_WRAP_WORD_CHAR
} GtkWrapMode;
</ENUM>
<ENUM>
<NAME>GtkSortType</NAME>
typedef enum
{
  GTK_SORT_ASCENDING,
  GTK_SORT_DESCENDING
} GtkSortType;
</ENUM>
<ENUM>
<NAME>GtkPrintPages</NAME>
typedef enum
{
  GTK_PRINT_PAGES_ALL,
  GTK_PRINT_PAGES_CURRENT,
  GTK_PRINT_PAGES_RANGES,
  GTK_PRINT_PAGES_SELECTION
} GtkPrintPages;
</ENUM>
<ENUM>
<NAME>GtkPageSet</NAME>
typedef enum
{
  GTK_PAGE_SET_ALL,
  GTK_PAGE_SET_EVEN,
  GTK_PAGE_SET_ODD
} GtkPageSet;
</ENUM>
<ENUM>
<NAME>GtkNumberUpLayout</NAME>
typedef enum
{
  GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM, /*< nick=lrtb >*/
  GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP, /*< nick=lrbt >*/
  GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM, /*< nick=rltb >*/
  GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP, /*< nick=rlbt >*/
  GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT, /*< nick=tblr >*/
  GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT, /*< nick=tbrl >*/
  GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT, /*< nick=btlr >*/
  GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT  /*< nick=btrl >*/
} GtkNumberUpLayout;
</ENUM>
<ENUM>
<NAME>GtkPageOrientation</NAME>
typedef enum
{
  GTK_PAGE_ORIENTATION_PORTRAIT,
  GTK_PAGE_ORIENTATION_LANDSCAPE,
  GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
  GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
} GtkPageOrientation;
</ENUM>
<ENUM>
<NAME>GtkPrintQuality</NAME>
typedef enum
{
  GTK_PRINT_QUALITY_LOW,
  GTK_PRINT_QUALITY_NORMAL,
  GTK_PRINT_QUALITY_HIGH,
  GTK_PRINT_QUALITY_DRAFT
} GtkPrintQuality;
</ENUM>
<ENUM>
<NAME>GtkPrintDuplex</NAME>
typedef enum
{
  GTK_PRINT_DUPLEX_SIMPLEX,
  GTK_PRINT_DUPLEX_HORIZONTAL,
  GTK_PRINT_DUPLEX_VERTICAL
} GtkPrintDuplex;
</ENUM>
<ENUM>
<NAME>GtkUnit</NAME>
typedef enum
{
  GTK_UNIT_NONE,
  GTK_UNIT_POINTS,
  GTK_UNIT_INCH,
  GTK_UNIT_MM
} GtkUnit;
</ENUM>
<MACRO>
<NAME>GTK_UNIT_PIXEL</NAME>
#define GTK_UNIT_PIXEL GTK_UNIT_NONE
</MACRO>
<ENUM>
<NAME>GtkTreeViewGridLines</NAME>
typedef enum
{
  GTK_TREE_VIEW_GRID_LINES_NONE,
  GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
  GTK_TREE_VIEW_GRID_LINES_VERTICAL,
  GTK_TREE_VIEW_GRID_LINES_BOTH
} GtkTreeViewGridLines;
</ENUM>
<ENUM>
<NAME>GtkSizeGroupMode</NAME>
typedef enum {
  GTK_SIZE_GROUP_NONE,
  GTK_SIZE_GROUP_HORIZONTAL,
  GTK_SIZE_GROUP_VERTICAL,
  GTK_SIZE_GROUP_BOTH
} GtkSizeGroupMode;
</ENUM>
<ENUM>
<NAME>GtkSizeRequestMode</NAME>
typedef enum
{
  GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH = 0,
  GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT,
  GTK_SIZE_REQUEST_CONSTANT_SIZE
} GtkSizeRequestMode;
</ENUM>
<ENUM>
<NAME>GtkScrollablePolicy</NAME>
typedef enum
{
  GTK_SCROLL_MINIMUM = 0,
  GTK_SCROLL_NATURAL
} GtkScrollablePolicy;
</ENUM>
<ENUM>
<NAME>GtkStateFlags</NAME>
typedef enum
{
  GTK_STATE_FLAG_NORMAL        = 0,
  GTK_STATE_FLAG_ACTIVE        = 1 << 0,
  GTK_STATE_FLAG_PRELIGHT      = 1 << 1,
  GTK_STATE_FLAG_SELECTED      = 1 << 2,
  GTK_STATE_FLAG_INSENSITIVE   = 1 << 3,
  GTK_STATE_FLAG_INCONSISTENT  = 1 << 4,
  GTK_STATE_FLAG_FOCUSED       = 1 << 5,
  GTK_STATE_FLAG_BACKDROP      = 1 << 6,
  GTK_STATE_FLAG_DIR_LTR       = 1 << 7,
  GTK_STATE_FLAG_DIR_RTL       = 1 << 8,
  GTK_STATE_FLAG_LINK          = 1 << 9,
  GTK_STATE_FLAG_VISITED       = 1 << 10,
  GTK_STATE_FLAG_CHECKED       = 1 << 11,
  GTK_STATE_FLAG_DROP_ACTIVE   = 1 << 12,
  GTK_STATE_FLAG_FOCUS_VISIBLE = 1 << 13,
  GTK_STATE_FLAG_FOCUS_WITHIN  = 1 << 14
} GtkStateFlags;
</ENUM>
<ENUM>
<NAME>GtkBorderStyle</NAME>
typedef enum {
  GTK_BORDER_STYLE_NONE,
  GTK_BORDER_STYLE_HIDDEN,
  GTK_BORDER_STYLE_SOLID,
  GTK_BORDER_STYLE_INSET,
  GTK_BORDER_STYLE_OUTSET,
  GTK_BORDER_STYLE_DOTTED,
  GTK_BORDER_STYLE_DASHED,
  GTK_BORDER_STYLE_DOUBLE,
  GTK_BORDER_STYLE_GROOVE,
  GTK_BORDER_STYLE_RIDGE
} GtkBorderStyle;
</ENUM>
<ENUM>
<NAME>GtkLevelBarMode</NAME>
typedef enum {
  GTK_LEVEL_BAR_MODE_CONTINUOUS,
  GTK_LEVEL_BAR_MODE_DISCRETE
} GtkLevelBarMode;
</ENUM>
<ENUM>
<NAME>GtkInputPurpose</NAME>
typedef enum
{
  GTK_INPUT_PURPOSE_FREE_FORM,
  GTK_INPUT_PURPOSE_ALPHA,
  GTK_INPUT_PURPOSE_DIGITS,
  GTK_INPUT_PURPOSE_NUMBER,
  GTK_INPUT_PURPOSE_PHONE,
  GTK_INPUT_PURPOSE_URL,
  GTK_INPUT_PURPOSE_EMAIL,
  GTK_INPUT_PURPOSE_NAME,
  GTK_INPUT_PURPOSE_PASSWORD,
  GTK_INPUT_PURPOSE_PIN,
  GTK_INPUT_PURPOSE_TERMINAL,
} GtkInputPurpose;
</ENUM>
<ENUM>
<NAME>GtkInputHints</NAME>
typedef enum
{
  GTK_INPUT_HINT_NONE                = 0,
  GTK_INPUT_HINT_SPELLCHECK          = 1 << 0,
  GTK_INPUT_HINT_NO_SPELLCHECK       = 1 << 1,
  GTK_INPUT_HINT_WORD_COMPLETION     = 1 << 2,
  GTK_INPUT_HINT_LOWERCASE           = 1 << 3,
  GTK_INPUT_HINT_UPPERCASE_CHARS     = 1 << 4,
  GTK_INPUT_HINT_UPPERCASE_WORDS     = 1 << 5,
  GTK_INPUT_HINT_UPPERCASE_SENTENCES = 1 << 6,
  GTK_INPUT_HINT_INHIBIT_OSK         = 1 << 7,
  GTK_INPUT_HINT_VERTICAL_WRITING    = 1 << 8,
  GTK_INPUT_HINT_EMOJI               = 1 << 9,
  GTK_INPUT_HINT_NO_EMOJI            = 1 << 10
} GtkInputHints;
</ENUM>
<ENUM>
<NAME>GtkPropagationPhase</NAME>
typedef enum
{
  GTK_PHASE_NONE,
  GTK_PHASE_CAPTURE,
  GTK_PHASE_BUBBLE,
  GTK_PHASE_TARGET
} GtkPropagationPhase;
</ENUM>
<ENUM>
<NAME>GtkPropagationLimit</NAME>
typedef enum
{
  GTK_LIMIT_NONE,
  GTK_LIMIT_SAME_NATIVE
} GtkPropagationLimit;
</ENUM>
<ENUM>
<NAME>GtkEventSequenceState</NAME>
typedef enum
{
  GTK_EVENT_SEQUENCE_NONE,
  GTK_EVENT_SEQUENCE_CLAIMED,
  GTK_EVENT_SEQUENCE_DENIED
} GtkEventSequenceState;
</ENUM>
<ENUM>
<NAME>GtkPanDirection</NAME>
typedef enum
{
  GTK_PAN_DIRECTION_LEFT,
  GTK_PAN_DIRECTION_RIGHT,
  GTK_PAN_DIRECTION_UP,
  GTK_PAN_DIRECTION_DOWN
} GtkPanDirection;
</ENUM>
<ENUM>
<NAME>GtkShortcutScope</NAME>
typedef enum
{
  GTK_SHORTCUT_SCOPE_LOCAL,
  GTK_SHORTCUT_SCOPE_MANAGED,
  GTK_SHORTCUT_SCOPE_GLOBAL
} GtkShortcutScope;
</ENUM>
<ENUM>
<NAME>GtkPopoverConstraint</NAME>
typedef enum
{
  GTK_POPOVER_CONSTRAINT_NONE,
  GTK_POPOVER_CONSTRAINT_WINDOW
} GtkPopoverConstraint;
</ENUM>
<ENUM>
<NAME>GtkPlacesOpenFlags</NAME>
typedef enum {
  GTK_PLACES_OPEN_NORMAL     = 1 << 0,
  GTK_PLACES_OPEN_NEW_TAB    = 1 << 1,
  GTK_PLACES_OPEN_NEW_WINDOW = 1 << 2
} GtkPlacesOpenFlags;
</ENUM>
<ENUM>
<NAME>GtkPickFlags</NAME>
typedef enum {
  GTK_PICK_DEFAULT        = 0,
  GTK_PICK_INSENSITIVE    = 1 << 0,
  GTK_PICK_NON_TARGETABLE = 1 << 1
} GtkPickFlags;
</ENUM>
<ENUM>
<NAME>GtkConstraintRelation</NAME>
typedef enum {
  GTK_CONSTRAINT_RELATION_LE = -1,
  GTK_CONSTRAINT_RELATION_EQ = 0,
  GTK_CONSTRAINT_RELATION_GE = 1
} GtkConstraintRelation;
</ENUM>
<ENUM>
<NAME>GtkConstraintStrength</NAME>
typedef enum {
  GTK_CONSTRAINT_STRENGTH_REQUIRED = 1001001000,
  GTK_CONSTRAINT_STRENGTH_STRONG   = 1000000000,
  GTK_CONSTRAINT_STRENGTH_MEDIUM   = 1000,
  GTK_CONSTRAINT_STRENGTH_WEAK     = 1
} GtkConstraintStrength;
</ENUM>
<ENUM>
<NAME>GtkConstraintAttribute</NAME>
typedef enum {
  GTK_CONSTRAINT_ATTRIBUTE_NONE,
  GTK_CONSTRAINT_ATTRIBUTE_LEFT,
  GTK_CONSTRAINT_ATTRIBUTE_RIGHT,
  GTK_CONSTRAINT_ATTRIBUTE_TOP,
  GTK_CONSTRAINT_ATTRIBUTE_BOTTOM,
  GTK_CONSTRAINT_ATTRIBUTE_START,
  GTK_CONSTRAINT_ATTRIBUTE_END,
  GTK_CONSTRAINT_ATTRIBUTE_WIDTH,
  GTK_CONSTRAINT_ATTRIBUTE_HEIGHT,
  GTK_CONSTRAINT_ATTRIBUTE_CENTER_X,
  GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y,
  GTK_CONSTRAINT_ATTRIBUTE_BASELINE
} GtkConstraintAttribute;
</ENUM>
<ENUM>
<NAME>GtkConstraintVflParserError</NAME>
typedef enum {
  GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL,
  GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE,
  GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW,
  GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC,
  GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY,
  GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION
} GtkConstraintVflParserError;
</ENUM>
<ENUM>
<NAME>GtkSystemSetting</NAME>
typedef enum {
  GTK_SYSTEM_SETTING_DPI,
  GTK_SYSTEM_SETTING_FONT_NAME,
  GTK_SYSTEM_SETTING_FONT_CONFIG,
  GTK_SYSTEM_SETTING_DISPLAY,
  GTK_SYSTEM_SETTING_ICON_THEME
} GtkSystemSetting;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_EVENT_CONTROLLER</NAME>
#define GTK_TYPE_EVENT_CONTROLLER         (gtk_event_controller_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER</NAME>
#define GTK_EVENT_CONTROLLER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER, GtkEventController))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER, GtkEventControllerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER</NAME>
#define GTK_IS_EVENT_CONTROLLER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_CLASS</NAME>
#define GTK_IS_EVENT_CONTROLLER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_GET_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER, GtkEventControllerClass))
</MACRO>
<FUNCTION>
<NAME>gtk_crossing_data_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_reset</NAME>
<RETURNS>void</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_propagation_phase</NAME>
<RETURNS>GtkPropagationPhase</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_set_propagation_phase</NAME>
<RETURNS>void</RETURNS>
GtkEventController  *controller, GtkPropagationPhase  phase
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_propagation_limit</NAME>
<RETURNS>GtkPropagationLimit</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_set_propagation_limit</NAME>
<RETURNS>void</RETURNS>
GtkEventController  *controller, GtkPropagationLimit  limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_name</NAME>
<RETURNS>const char *</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_set_name</NAME>
<RETURNS>void</RETURNS>
GtkEventController *controller, const char         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_current_event</NAME>
<RETURNS>GdkEvent *</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_current_event_time</NAME>
<RETURNS>guint32</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_current_event_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_get_current_event_state</NAME>
<RETURNS>GdkModifierType</RETURNS>
GtkEventController *controller
</FUNCTION>
<STRUCT>
<NAME>GtkEventControllerClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EVENT_CONTROLLER_FOCUS</NAME>
#define GTK_TYPE_EVENT_CONTROLLER_FOCUS         (gtk_event_controller_focus_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_FOCUS</NAME>
#define GTK_EVENT_CONTROLLER_FOCUS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER_FOCUS, GtkEventControllerFocus))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_FOCUS_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_FOCUS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER_FOCUS, GtkEventControllerFocusClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_FOCUS</NAME>
#define GTK_IS_EVENT_CONTROLLER_FOCUS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER_FOCUS))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_FOCUS_CLASS</NAME>
#define GTK_IS_EVENT_CONTROLLER_FOCUS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER_FOCUS))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_FOCUS_GET_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_FOCUS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER_FOCUS, GtkEventControllerFocusClass))
</MACRO>
<FUNCTION>
<NAME>gtk_event_controller_focus_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_focus_new</NAME>
<RETURNS>GtkEventController *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_focus_contains_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkEventControllerFocus  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_focus_is_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkEventControllerFocus  *self
</FUNCTION>
<STRUCT>
<NAME>GtkEventControllerFocus</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventControllerFocusClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EVENT_CONTROLLER_KEY</NAME>
#define GTK_TYPE_EVENT_CONTROLLER_KEY         (gtk_event_controller_key_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_KEY</NAME>
#define GTK_EVENT_CONTROLLER_KEY(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER_KEY, GtkEventControllerKey))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_KEY_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_KEY_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER_KEY, GtkEventControllerKeyClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_KEY</NAME>
#define GTK_IS_EVENT_CONTROLLER_KEY(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER_KEY))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_KEY_CLASS</NAME>
#define GTK_IS_EVENT_CONTROLLER_KEY_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER_KEY))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_KEY_GET_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_KEY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER_KEY, GtkEventControllerKeyClass))
</MACRO>
<FUNCTION>
<NAME>gtk_event_controller_key_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_key_new</NAME>
<RETURNS>GtkEventController *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_key_set_im_context</NAME>
<RETURNS>void</RETURNS>
GtkEventControllerKey *controller, GtkIMContext          *im_context
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_key_get_im_context</NAME>
<RETURNS>GtkIMContext *</RETURNS>
GtkEventControllerKey *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_key_forward</NAME>
<RETURNS>gboolean</RETURNS>
GtkEventControllerKey *controller, GtkWidget             *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_key_get_group</NAME>
<RETURNS>guint</RETURNS>
GtkEventControllerKey *controller
</FUNCTION>
<STRUCT>
<NAME>GtkEventControllerKey</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventControllerKeyClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EVENT_CONTROLLER_LEGACY</NAME>
#define GTK_TYPE_EVENT_CONTROLLER_LEGACY         (gtk_event_controller_legacy_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_LEGACY</NAME>
#define GTK_EVENT_CONTROLLER_LEGACY(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER_LEGACY, GtkEventControllerLegacy))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_LEGACY_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_LEGACY_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER_LEGACY, GtkEventControllerLegacyClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_LEGACY</NAME>
#define GTK_IS_EVENT_CONTROLLER_LEGACY(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER_LEGACY))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_LEGACY_CLASS</NAME>
#define GTK_IS_EVENT_CONTROLLER_LEGACY_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER_LEGACY))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_LEGACY_GET_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_LEGACY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER_LEGACY, GtkEventControllerLegacyClass))
</MACRO>
<FUNCTION>
<NAME>gtk_event_controller_legacy_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_legacy_new</NAME>
<RETURNS>GtkEventController *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkEventControllerLegacy</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventControllerLegacyClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EVENT_CONTROLLER_MOTION</NAME>
#define GTK_TYPE_EVENT_CONTROLLER_MOTION         (gtk_event_controller_motion_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_MOTION</NAME>
#define GTK_EVENT_CONTROLLER_MOTION(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER_MOTION, GtkEventControllerMotion))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_MOTION_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_MOTION_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER_MOTION, GtkEventControllerMotionClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_MOTION</NAME>
#define GTK_IS_EVENT_CONTROLLER_MOTION(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER_MOTION))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_MOTION_CLASS</NAME>
#define GTK_IS_EVENT_CONTROLLER_MOTION_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER_MOTION))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_MOTION_GET_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_MOTION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER_MOTION, GtkEventControllerMotionClass))
</MACRO>
<FUNCTION>
<NAME>gtk_event_controller_motion_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_motion_new</NAME>
<RETURNS>GtkEventController *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_motion_contains_pointer</NAME>
<RETURNS>gboolean</RETURNS>
GtkEventControllerMotion *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_motion_is_pointer</NAME>
<RETURNS>gboolean</RETURNS>
GtkEventControllerMotion *self
</FUNCTION>
<STRUCT>
<NAME>GtkEventControllerMotion</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventControllerMotionClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EVENT_CONTROLLER_SCROLL</NAME>
#define GTK_TYPE_EVENT_CONTROLLER_SCROLL         (gtk_event_controller_scroll_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_SCROLL</NAME>
#define GTK_EVENT_CONTROLLER_SCROLL(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_EVENT_CONTROLLER_SCROLL, GtkEventControllerScroll))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_SCROLL_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_SCROLL_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_EVENT_CONTROLLER_SCROLL, GtkEventControllerScrollClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_SCROLL</NAME>
#define GTK_IS_EVENT_CONTROLLER_SCROLL(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_EVENT_CONTROLLER_SCROLL))
</MACRO>
<MACRO>
<NAME>GTK_IS_EVENT_CONTROLLER_SCROLL_CLASS</NAME>
#define GTK_IS_EVENT_CONTROLLER_SCROLL_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_EVENT_CONTROLLER_SCROLL))
</MACRO>
<MACRO>
<NAME>GTK_EVENT_CONTROLLER_SCROLL_GET_CLASS</NAME>
#define GTK_EVENT_CONTROLLER_SCROLL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_EVENT_CONTROLLER_SCROLL, GtkEventControllerScrollClass))
</MACRO>
<ENUM>
<NAME>GtkEventControllerScrollFlags</NAME>
typedef enum {
  GTK_EVENT_CONTROLLER_SCROLL_NONE       = 0,
  GTK_EVENT_CONTROLLER_SCROLL_VERTICAL   = 1 << 0,
  GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL = 1 << 1,
  GTK_EVENT_CONTROLLER_SCROLL_DISCRETE   = 1 << 2,
  GTK_EVENT_CONTROLLER_SCROLL_KINETIC    = 1 << 3,
  GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES  = (GTK_EVENT_CONTROLLER_SCROLL_VERTICAL | GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL),
} GtkEventControllerScrollFlags;
</ENUM>
<FUNCTION>
<NAME>gtk_event_controller_scroll_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_scroll_new</NAME>
<RETURNS>GtkEventController *</RETURNS>
GtkEventControllerScrollFlags  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_scroll_set_flags</NAME>
<RETURNS>void</RETURNS>
GtkEventControllerScroll      *scroll, GtkEventControllerScrollFlags  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_scroll_get_flags</NAME>
<RETURNS>GtkEventControllerScrollFlags</RETURNS>
GtkEventControllerScroll      *scroll
</FUNCTION>
<STRUCT>
<NAME>GtkEventControllerScroll</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventControllerScrollClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EXPANDER</NAME>
#define GTK_TYPE_EXPANDER            (gtk_expander_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EXPANDER</NAME>
#define GTK_EXPANDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EXPANDER, GtkExpander))
</MACRO>
<MACRO>
<NAME>GTK_IS_EXPANDER</NAME>
#define GTK_IS_EXPANDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EXPANDER))
</MACRO>
<FUNCTION>
<NAME>gtk_expander_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_expanded</NAME>
<RETURNS>void</RETURNS>
GtkExpander *expander, gboolean     expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_expanded</NAME>
<RETURNS>gboolean</RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_label</NAME>
<RETURNS>void</RETURNS>
GtkExpander *expander, const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_label</NAME>
<RETURNS>const gchar *</RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_use_underline</NAME>
<RETURNS>void</RETURNS>
GtkExpander *expander, gboolean     use_underline
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_use_underline</NAME>
<RETURNS>gboolean</RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_use_markup</NAME>
<RETURNS>void</RETURNS>
GtkExpander *expander, gboolean    use_markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_use_markup</NAME>
<RETURNS>gboolean</RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_label_widget</NAME>
<RETURNS>void</RETURNS>
GtkExpander *expander, GtkWidget   *label_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_label_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_resize_toplevel</NAME>
<RETURNS>void</RETURNS>
GtkExpander *expander, gboolean     resize_toplevel
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_resize_toplevel</NAME>
<RETURNS>gboolean</RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_child</NAME>
<RETURNS>void</RETURNS>
GtkExpander *expander, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkExpander *expander
</FUNCTION>
<STRUCT>
<NAME>GtkExpander</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER</NAME>
#define GTK_TYPE_FILE_CHOOSER             (gtk_file_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER</NAME>
#define GTK_FILE_CHOOSER(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER, GtkFileChooser))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER</NAME>
#define GTK_IS_FILE_CHOOSER(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER))
</MACRO>
<ENUM>
<NAME>GtkFileChooserAction</NAME>
typedef enum
{
  GTK_FILE_CHOOSER_ACTION_OPEN,
  GTK_FILE_CHOOSER_ACTION_SAVE,
  GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
} GtkFileChooserAction;
</ENUM>
<FUNCTION>
<NAME>gtk_file_chooser_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_FILE_CHOOSER_ERROR</NAME>
#define GTK_FILE_CHOOSER_ERROR (gtk_file_chooser_error_quark ())
</MACRO>
<ENUM>
<NAME>GtkFileChooserError</NAME>
typedef enum {
  GTK_FILE_CHOOSER_ERROR_NONEXISTENT,
  GTK_FILE_CHOOSER_ERROR_BAD_FILENAME,
  GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS,
  GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME
} GtkFileChooserError;
</ENUM>
<FUNCTION>
<NAME>gtk_file_chooser_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_action</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser       *chooser, GtkFileChooserAction  action
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_action</NAME>
<RETURNS>GtkFileChooserAction</RETURNS>
GtkFileChooser       *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_select_multiple</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser       *chooser, gboolean              select_multiple
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_select_multiple</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooser       *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_create_folders</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser       *chooser, gboolean               create_folders
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_create_folders</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_current_name</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser *chooser, const gchar    *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_current_name</NAME>
<RETURNS>gchar *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_select_all</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_unselect_all</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_file</NAME>
<RETURNS>GFile *</RETURNS>
GtkFileChooser  *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooser  *chooser, GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_select_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooser  *chooser, GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_unselect_file</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser  *chooser, GFile           *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_files</NAME>
<RETURNS>GSList *</RETURNS>
GtkFileChooser  *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_current_folder</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooser  *chooser, GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_current_folder</NAME>
<RETURNS>GFile *</RETURNS>
GtkFileChooser  *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_add_filter</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser *chooser, GtkFileFilter  *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_remove_filter</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser *chooser, GtkFileFilter  *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_list_filters</NAME>
<RETURNS>GSList *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_filter</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser *chooser, GtkFileFilter  *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_filter</NAME>
<RETURNS>GtkFileFilter *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_add_shortcut_folder</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooser *chooser, GFile          *folder, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_remove_shortcut_folder</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooser *chooser, GFile          *folder, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_list_shortcut_folders</NAME>
<RETURNS>GSList *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_add_choice</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser  *chooser, const char      *id, const char      *label, const char     **options, const char     **option_labels
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_remove_choice</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser  *chooser, const char      *id
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_choice</NAME>
<RETURNS>void</RETURNS>
GtkFileChooser  *chooser, const char      *id, const char      *option
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_choice</NAME>
<RETURNS>const char *</RETURNS>
GtkFileChooser  *chooser, const char      *id
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_BUTTON</NAME>
#define GTK_TYPE_FILE_CHOOSER_BUTTON            (gtk_file_chooser_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_BUTTON</NAME>
#define GTK_FILE_CHOOSER_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_BUTTON, GtkFileChooserButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_BUTTON</NAME>
#define GTK_IS_FILE_CHOOSER_BUTTON(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_BUTTON))
</MACRO>
<FUNCTION>
<NAME>gtk_file_chooser_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar          *title, GtkFileChooserAction  action
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_new_with_dialog</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget            *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_get_title</NAME>
<RETURNS>const gchar *</RETURNS>
GtkFileChooserButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_set_title</NAME>
<RETURNS>void</RETURNS>
GtkFileChooserButton *button, const gchar          *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_get_width_chars</NAME>
<RETURNS>gint</RETURNS>
GtkFileChooserButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_set_width_chars</NAME>
<RETURNS>void</RETURNS>
GtkFileChooserButton *button, gint                  n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_get_modal</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileChooserButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_set_modal</NAME>
<RETURNS>void</RETURNS>
GtkFileChooserButton *button, gboolean              modal
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooserButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_DIALOG</NAME>
#define GTK_TYPE_FILE_CHOOSER_DIALOG             (gtk_file_chooser_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_DIALOG</NAME>
#define GTK_FILE_CHOOSER_DIALOG(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_DIALOG, GtkFileChooserDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_DIALOG</NAME>
#define GTK_IS_FILE_CHOOSER_DIALOG(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_DIALOG))
</MACRO>
<FUNCTION>
<NAME>gtk_file_chooser_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar          *title, GtkWindow            *parent, GtkFileChooserAction  action, const gchar          *first_button_text, ...
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooserDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_EMBED</NAME>
#define GTK_TYPE_FILE_CHOOSER_EMBED             (_gtk_file_chooser_embed_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_EMBED</NAME>
#define GTK_FILE_CHOOSER_EMBED(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_EMBED, GtkFileChooserEmbed))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_EMBED</NAME>
#define GTK_IS_FILE_CHOOSER_EMBED(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_EMBED))
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_EMBED_GET_IFACE</NAME>
#define GTK_FILE_CHOOSER_EMBED_GET_IFACE(obj)   (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_FILE_CHOOSER_EMBED, GtkFileChooserEmbedIface))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserEmbedIface</NAME>
struct _GtkFileChooserEmbedIface
{
  GTypeInterface base_iface;

  /* Methods
   */
  gboolean (*should_respond)      (GtkFileChooserEmbed *chooser_embed);

  void (*initial_focus)           (GtkFileChooserEmbed *chooser_embed);
  /* Signals
   */
  void (*response_requested)      (GtkFileChooserEmbed *chooser_embed);
};
</STRUCT>
<STRUCT>
<NAME>GtkFileChooserEmbed</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_ENTRY</NAME>
#define GTK_TYPE_FILE_CHOOSER_ENTRY    (_gtk_file_chooser_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_ENTRY</NAME>
#define GTK_FILE_CHOOSER_ENTRY(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_ENTRY, GtkFileChooserEntry))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_ENTRY</NAME>
#define GTK_IS_FILE_CHOOSER_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_ENTRY))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserEntry</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_NATIVE</NAME>
#define GTK_TYPE_FILE_CHOOSER_NATIVE             (gtk_file_chooser_native_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_file_chooser_native_new</NAME>
<RETURNS>GtkFileChooserNative *</RETURNS>
const gchar          *title, GtkWindow            *parent, GtkFileChooserAction  action, const gchar          *accept_label, const gchar          *cancel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_get_accept_label</NAME>
<RETURNS>const char *</RETURNS>
GtkFileChooserNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_set_accept_label</NAME>
<RETURNS>void</RETURNS>
GtkFileChooserNative *self, const char           *accept_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_get_cancel_label</NAME>
<RETURNS>const char *</RETURNS>
GtkFileChooserNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_set_cancel_label</NAME>
<RETURNS>void</RETURNS>
GtkFileChooserNative *self, const char           *cancel_label
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooserNative</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_FILE_CHOOSER_DELEGATE_QUARK</NAME>
#define GTK_FILE_CHOOSER_DELEGATE_QUARK	  (_gtk_file_chooser_delegate_get_quark ())
</MACRO>
<ENUM>
<NAME>GtkFileChooserProp</NAME>
typedef enum {
  GTK_FILE_CHOOSER_PROP_FIRST                  = 0x1000,
  GTK_FILE_CHOOSER_PROP_ACTION                 = GTK_FILE_CHOOSER_PROP_FIRST,
  GTK_FILE_CHOOSER_PROP_FILTER,
  GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE,
  GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS,
  GTK_FILE_CHOOSER_PROP_LAST                   = GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS
} GtkFileChooserProp;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_WIDGET</NAME>
#define GTK_TYPE_FILE_CHOOSER_WIDGET             (gtk_file_chooser_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_WIDGET</NAME>
#define GTK_FILE_CHOOSER_WIDGET(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_WIDGET, GtkFileChooserWidget))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_WIDGET</NAME>
#define GTK_IS_FILE_CHOOSER_WIDGET(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_WIDGET))
</MACRO>
<FUNCTION>
<NAME>gtk_file_chooser_widget_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_widget_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkFileChooserAction  action
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooserWidget</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_FILTER</NAME>
#define GTK_TYPE_FILE_FILTER              (gtk_file_filter_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_FILTER</NAME>
#define GTK_FILE_FILTER(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_FILTER, GtkFileFilter))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_FILTER</NAME>
#define GTK_IS_FILE_FILTER(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_FILTER))
</MACRO>
<ENUM>
<NAME>GtkFileFilterFlags</NAME>
typedef enum {
  GTK_FILE_FILTER_FILENAME     = 1 << 0,
  GTK_FILE_FILTER_URI          = 1 << 1,
  GTK_FILE_FILTER_DISPLAY_NAME = 1 << 2,
  GTK_FILE_FILTER_MIME_TYPE    = 1 << 3
} GtkFileFilterFlags;
</ENUM>
<USER_FUNCTION>
<NAME>GtkFileFilterFunc</NAME>
<RETURNS>gboolean</RETURNS>
const GtkFileFilterInfo *filter_info, gpointer                 data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkFileFilterInfo</NAME>
struct _GtkFileFilterInfo
{
  GtkFileFilterFlags contains;

  const gchar *filename;
  const gchar *uri;
  const gchar *display_name;
  const gchar *mime_type;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_file_filter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_new</NAME>
<RETURNS>GtkFileFilter *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_set_name</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter *filter, const gchar   *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkFileFilter *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_mime_type</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter      *filter, const gchar        *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_pattern</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter      *filter, const gchar        *pattern
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_pixbuf_formats</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter      *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_custom</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter      *filter, GtkFileFilterFlags  needed, GtkFileFilterFunc   func, gpointer            data, GDestroyNotify      notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_get_needed</NAME>
<RETURNS>GtkFileFilterFlags</RETURNS>
GtkFileFilter           *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_filter</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileFilter           *filter, const GtkFileFilterInfo *filter_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_to_gvariant</NAME>
<RETURNS>GVariant *</RETURNS>
GtkFileFilter *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_new_from_gvariant</NAME>
<RETURNS>GtkFileFilter *</RETURNS>
GVariant      *variant
</FUNCTION>
<STRUCT>
<NAME>GtkFileFilter</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM</NAME>
#define GTK_TYPE_FILE_SYSTEM         (_gtk_file_system_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM</NAME>
#define GTK_FILE_SYSTEM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_FILE_SYSTEM, GtkFileSystem))
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_CLASS</NAME>
#define GTK_FILE_SYSTEM_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST    ((c), GTK_TYPE_FILE_SYSTEM, GtkFileSystemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM</NAME>
#define GTK_IS_FILE_SYSTEM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_FILE_SYSTEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_CLASS</NAME>
#define GTK_IS_FILE_SYSTEM_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE    ((c), GTK_TYPE_FILE_SYSTEM))
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_GET_CLASS</NAME>
#define GTK_FILE_SYSTEM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS  ((o), GTK_TYPE_FILE_SYSTEM, GtkFileSystemClass))
</MACRO>
<TYPEDEF>
<NAME>GtkFileSystem</NAME>
typedef struct GtkFileSystem          GtkFileSystem;
</TYPEDEF>
<TYPEDEF>
<NAME>GtkFileSystemPrivate</NAME>
typedef struct GtkFileSystemPrivate      GtkFileSystemPrivate;
</TYPEDEF>
<TYPEDEF>
<NAME>GtkFileSystemClass</NAME>
typedef struct GtkFileSystemClass     GtkFileSystemClass;
</TYPEDEF>
<TYPEDEF>
<NAME>GtkFileSystemVolume</NAME>
typedef struct GtkFileSystemVolume GtkFileSystemVolume; /* opaque struct */
</TYPEDEF>
<USER_FUNCTION>
<NAME>GtkFileSystemGetInfoCallback</NAME>
<RETURNS>void</RETURNS>
GCancellable        *cancellable, GFileInfo           *file_info, const GError        *error, gpointer             data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkFileSystemVolumeMountCallback</NAME>
<RETURNS>void</RETURNS>
GCancellable        *cancellable, GtkFileSystemVolume *volume, const GError        *error, gpointer             data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM_MODEL</NAME>
#define GTK_TYPE_FILE_SYSTEM_MODEL             (_gtk_file_system_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_MODEL</NAME>
#define GTK_FILE_SYSTEM_MODEL(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModel))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_MODEL</NAME>
#define GTK_IS_FILE_SYSTEM_MODEL(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_SYSTEM_MODEL))
</MACRO>
<USER_FUNCTION>
<NAME>GtkFileSystemModelGetValue</NAME>
<RETURNS>gboolean</RETURNS>
GtkFileSystemModel *model, GFile              *file, GFileInfo          *info, int                 column, GValue             *value, gpointer            user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkFileSystemModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILTER_LIST_MODEL</NAME>
#define GTK_TYPE_FILTER_LIST_MODEL (gtk_filter_list_model_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkFilterListModelFilterFunc</NAME>
<RETURNS>gboolean</RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_new</NAME>
<RETURNS>GtkFilterListModel *</RETURNS>
GListModel             *model, GtkFilterListModelFilterFunc filter_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_new_for_type</NAME>
<RETURNS>GtkFilterListModel *</RETURNS>
GType                   item_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_set_filter_func</NAME>
<RETURNS>void</RETURNS>
GtkFilterListModel     *self, GtkFilterListModelFilterFunc filter_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_set_model</NAME>
<RETURNS>void</RETURNS>
GtkFilterListModel     *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkFilterListModel     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_has_filter</NAME>
<RETURNS>gboolean</RETURNS>
GtkFilterListModel     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_refilter</NAME>
<RETURNS>void</RETURNS>
GtkFilterListModel     *self
</FUNCTION>
<STRUCT>
<NAME>GtkFilterListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FIXED</NAME>
#define GTK_TYPE_FIXED                  (gtk_fixed_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FIXED</NAME>
#define GTK_FIXED(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FIXED, GtkFixed))
</MACRO>
<MACRO>
<NAME>GTK_FIXED_CLASS</NAME>
#define GTK_FIXED_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FIXED, GtkFixedClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FIXED</NAME>
#define GTK_IS_FIXED(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FIXED))
</MACRO>
<MACRO>
<NAME>GTK_IS_FIXED_CLASS</NAME>
#define GTK_IS_FIXED_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FIXED))
</MACRO>
<MACRO>
<NAME>GTK_FIXED_GET_CLASS</NAME>
#define GTK_FIXED_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FIXED, GtkFixedClass))
</MACRO>
<STRUCT>
<NAME>GtkFixed</NAME>
struct _GtkFixed
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFixedClass</NAME>
struct _GtkFixedClass
{
  GtkWidgetClass parent_class;

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_fixed_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_put</NAME>
<RETURNS>void</RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, gint          x, gint          y
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_remove</NAME>
<RETURNS>void</RETURNS>
GtkFixed     *fixed, GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_move</NAME>
<RETURNS>void</RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, gint          x, gint          y
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_get_child_position</NAME>
<RETURNS>void</RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, gint         *x, gint         *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_set_child_transform</NAME>
<RETURNS>void</RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, GskTransform *transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_get_child_transform</NAME>
<RETURNS>GskTransform *</RETURNS>
GtkFixed     *fixed, GtkWidget    *widget
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FIXED_LAYOUT</NAME>
#define GTK_TYPE_FIXED_LAYOUT (gtk_fixed_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FIXED_LAYOUT_CHILD</NAME>
#define GTK_TYPE_FIXED_LAYOUT_CHILD (gtk_fixed_layout_child_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_fixed_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_layout_child_set_transform</NAME>
<RETURNS>void</RETURNS>
GtkFixedLayoutChild *child, GskTransform        *transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_layout_child_get_transform</NAME>
<RETURNS>GskTransform *</RETURNS>
GtkFixedLayoutChild *child
</FUNCTION>
<STRUCT>
<NAME>GtkFixedLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFixedLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FLATTEN_LIST_MODEL</NAME>
#define GTK_TYPE_FLATTEN_LIST_MODEL (gtk_flatten_list_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_flatten_list_model_new</NAME>
<RETURNS>GtkFlattenListModel *</RETURNS>
GType                   item_type, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_flatten_list_model_set_model</NAME>
<RETURNS>void</RETURNS>
GtkFlattenListModel    *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_flatten_list_model_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkFlattenListModel    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_flatten_list_model_get_model_for_item</NAME>
<RETURNS>GListModel *</RETURNS>
GtkFlattenListModel    *self, guint                   position
</FUNCTION>
<STRUCT>
<NAME>GtkFlattenListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FLOW_BOX</NAME>
#define GTK_TYPE_FLOW_BOX                  (gtk_flow_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX</NAME>
#define GTK_FLOW_BOX(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FLOW_BOX, GtkFlowBox))
</MACRO>
<MACRO>
<NAME>GTK_IS_FLOW_BOX</NAME>
#define GTK_IS_FLOW_BOX(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FLOW_BOX))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FLOW_BOX_CHILD</NAME>
#define GTK_TYPE_FLOW_BOX_CHILD            (gtk_flow_box_child_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_CHILD</NAME>
#define GTK_FLOW_BOX_CHILD(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FLOW_BOX_CHILD, GtkFlowBoxChild))
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_CHILD_CLASS</NAME>
#define GTK_FLOW_BOX_CHILD_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FLOW_BOX_CHILD, GtkFlowBoxChildClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FLOW_BOX_CHILD</NAME>
#define GTK_IS_FLOW_BOX_CHILD(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FLOW_BOX_CHILD))
</MACRO>
<MACRO>
<NAME>GTK_IS_FLOW_BOX_CHILD_CLASS</NAME>
#define GTK_IS_FLOW_BOX_CHILD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FLOW_BOX_CHILD))
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_CHILD_GET_CLASS</NAME>
#define GTK_FLOW_BOX_CHILD_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), EG_TYPE_FLOW_BOX_CHILD, GtkFlowBoxChildClass))
</MACRO>
<STRUCT>
<NAME>GtkFlowBoxChild</NAME>
struct _GtkFlowBoxChild
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFlowBoxChildClass</NAME>
struct _GtkFlowBoxChildClass
{
  GtkWidgetClass parent_class;

  void (* activate) (GtkFlowBoxChild *child);

  gpointer padding[8];
};
</STRUCT>
<USER_FUNCTION>
<NAME>GtkFlowBoxCreateWidgetFunc</NAME>
<RETURNS>GtkWidget *</RETURNS>
gpointer item, gpointer  user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_set_child</NAME>
<RETURNS>void</RETURNS>
GtkFlowBoxChild *self, GtkWidget       *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkFlowBoxChild *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_get_index</NAME>
<RETURNS>gint</RETURNS>
GtkFlowBoxChild *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkFlowBoxChild *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_changed</NAME>
<RETURNS>void</RETURNS>
GtkFlowBoxChild *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_bind_model</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox                 *box, GListModel                 *model, GtkFlowBoxCreateWidgetFunc  create_widget_func, gpointer                    user_data, GDestroyNotify              user_data_free_func
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox           *box, gboolean              homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_row_spacing</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox           *box, guint                 spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_row_spacing</NAME>
<RETURNS>guint</RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_column_spacing</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox           *box, guint                 spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_column_spacing</NAME>
<RETURNS>guint</RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_min_children_per_line</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox           *box, guint                 n_children
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_min_children_per_line</NAME>
<RETURNS>guint</RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_max_children_per_line</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox           *box, guint                 n_children
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_max_children_per_line</NAME>
<RETURNS>guint</RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_activate_on_single_click</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, gboolean           single
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_activate_on_single_click</NAME>
<RETURNS>gboolean</RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_insert</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkWidget         *widget, gint               position
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_remove</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkWidget         *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_child_at_index</NAME>
<RETURNS>GtkFlowBoxChild *</RETURNS>
GtkFlowBox        *box, gint               idx
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_child_at_pos</NAME>
<RETURNS>GtkFlowBoxChild *</RETURNS>
GtkFlowBox        *box, gint               x, gint               y
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkFlowBoxForeachFunc</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox      *box, GtkFlowBoxChild *child, gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_selected_foreach</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkFlowBoxForeachFunc func, gpointer           data
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_selected_children</NAME>
<RETURNS>GList *</RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_select_child</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkFlowBoxChild   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_unselect_child</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkFlowBoxChild   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_select_all</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_unselect_all</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_selection_mode</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkSelectionMode   mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_selection_mode</NAME>
<RETURNS>GtkSelectionMode</RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_hadjustment</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkAdjustment     *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_vadjustment</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkAdjustment     *adjustment
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkFlowBoxFilterFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkFlowBoxChild *child, gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_filter_func</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkFlowBoxFilterFunc filter_func, gpointer             user_data, GDestroyNotify       destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_invalidate_filter</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkFlowBoxSortFunc</NAME>
<RETURNS>gint</RETURNS>
GtkFlowBoxChild *child1, GtkFlowBoxChild *child2, gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox        *box, GtkFlowBoxSortFunc  sort_func, gpointer            user_data, GDestroyNotify      destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_invalidate_sort</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox         *box
</FUNCTION>
<STRUCT>
<NAME>GtkFlowBox</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_flow_box_disable_move_cursor</NAME>
<RETURNS>void</RETURNS>
GtkFlowBox *box
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FONT_BUTTON</NAME>
#define GTK_TYPE_FONT_BUTTON             (gtk_font_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FONT_BUTTON</NAME>
#define GTK_FONT_BUTTON(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_BUTTON, GtkFontButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_FONT_BUTTON</NAME>
#define GTK_IS_FONT_BUTTON(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_BUTTON))
</MACRO>
<FUNCTION>
<NAME>gtk_font_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_new_with_font</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar   *fontname
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_get_title</NAME>
<RETURNS>const gchar *</RETURNS>
GtkFontButton *font_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_set_title</NAME>
<RETURNS>void</RETURNS>
GtkFontButton *font_button, const gchar   *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_get_modal</NAME>
<RETURNS>gboolean</RETURNS>
GtkFontButton *font_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_set_modal</NAME>
<RETURNS>void</RETURNS>
GtkFontButton *font_button, gboolean       modal
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_get_use_font</NAME>
<RETURNS>gboolean</RETURNS>
GtkFontButton *font_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_set_use_font</NAME>
<RETURNS>void</RETURNS>
GtkFontButton *font_button, gboolean       use_font
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_get_use_size</NAME>
<RETURNS>gboolean</RETURNS>
GtkFontButton *font_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_set_use_size</NAME>
<RETURNS>void</RETURNS>
GtkFontButton *font_button, gboolean       use_size
</FUNCTION>
<STRUCT>
<NAME>GtkFontButton</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkFontFilterFunc</NAME>
<RETURNS>gboolean</RETURNS>
const PangoFontFamily *family, const PangoFontFace   *face, gpointer               data
</USER_FUNCTION>
<ENUM>
<NAME>GtkFontChooserLevel</NAME>
typedef enum {
  GTK_FONT_CHOOSER_LEVEL_FAMILY     = 0,
  GTK_FONT_CHOOSER_LEVEL_STYLE      = 1 << 0,
  GTK_FONT_CHOOSER_LEVEL_SIZE       = 1 << 1,
  GTK_FONT_CHOOSER_LEVEL_VARIATIONS = 1 << 2,
  GTK_FONT_CHOOSER_LEVEL_FEATURES   = 1 << 3
} GtkFontChooserLevel;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_FONT_CHOOSER</NAME>
#define GTK_TYPE_FONT_CHOOSER			(gtk_font_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER</NAME>
#define GTK_FONT_CHOOSER(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_CHOOSER, GtkFontChooser))
</MACRO>
<MACRO>
<NAME>GTK_IS_FONT_CHOOSER</NAME>
#define GTK_IS_FONT_CHOOSER(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_CHOOSER))
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_GET_IFACE</NAME>
#define GTK_FONT_CHOOSER_GET_IFACE(inst)	(G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_FONT_CHOOSER, GtkFontChooserIface))
</MACRO>
<STRUCT>
<NAME>GtkFontChooserIface</NAME>
struct _GtkFontChooserIface
{
  GTypeInterface base_iface;

  /* Methods */
  PangoFontFamily * (* get_font_family)         (GtkFontChooser  *fontchooser);
  PangoFontFace *   (* get_font_face)           (GtkFontChooser  *fontchooser);
  gint              (* get_font_size)           (GtkFontChooser  *fontchooser);

  void              (* set_filter_func)         (GtkFontChooser   *fontchooser,
                                                 GtkFontFilterFunc filter,
                                                 gpointer          user_data,
                                                 GDestroyNotify    destroy);

  /* Signals */
  void (* font_activated) (GtkFontChooser *chooser,
                           const gchar    *fontname);

  /* More methods */
  void              (* set_font_map)            (GtkFontChooser   *fontchooser,
                                                 PangoFontMap     *fontmap);
  PangoFontMap *    (* get_font_map)            (GtkFontChooser   *fontchooser);

   /* Padding */
  gpointer padding[10];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_font_chooser_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_family</NAME>
<RETURNS>PangoFontFamily *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_face</NAME>
<RETURNS>PangoFontFace *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_size</NAME>
<RETURNS>gint</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_desc</NAME>
<RETURNS>PangoFontDescription *</RETURNS>
GtkFontChooser             *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_font_desc</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser             *fontchooser, const PangoFontDescription *font_desc
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font</NAME>
<RETURNS>gchar *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_font</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, const gchar      *fontname
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_preview_text</NAME>
<RETURNS>gchar *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_preview_text</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, const gchar      *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_show_preview_entry</NAME>
<RETURNS>gboolean</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_show_preview_entry</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, gboolean          show_preview_entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_filter_func</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, GtkFontFilterFunc filter, gpointer          user_data, GDestroyNotify    destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_font_map</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, PangoFontMap     *fontmap
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_map</NAME>
<RETURNS>PangoFontMap *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_level</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, GtkFontChooserLevel level
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_level</NAME>
<RETURNS>GtkFontChooserLevel</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_features</NAME>
<RETURNS>char *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_language</NAME>
<RETURNS>char *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_language</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, const char       *language
</FUNCTION>
<STRUCT>
<NAME>GtkFontChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FONT_CHOOSER_DIALOG</NAME>
#define GTK_TYPE_FONT_CHOOSER_DIALOG              (gtk_font_chooser_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_DIALOG</NAME>
#define GTK_FONT_CHOOSER_DIALOG(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_CHOOSER_DIALOG, GtkFontChooserDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_FONT_CHOOSER_DIALOG</NAME>
#define GTK_IS_FONT_CHOOSER_DIALOG(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_CHOOSER_DIALOG))
</MACRO>
<FUNCTION>
<NAME>gtk_font_chooser_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar          *title, GtkWindow            *parent
</FUNCTION>
<STRUCT>
<NAME>GtkFontChooserDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_FONT_CHOOSER_DELEGATE_QUARK</NAME>
#define GTK_FONT_CHOOSER_DELEGATE_QUARK	(_gtk_font_chooser_delegate_get_quark ())
</MACRO>
<ENUM>
<NAME>GtkFontChooserProp</NAME>
typedef enum {
  GTK_FONT_CHOOSER_PROP_FIRST           = 0x4000,
  GTK_FONT_CHOOSER_PROP_FONT,
  GTK_FONT_CHOOSER_PROP_FONT_DESC,
  GTK_FONT_CHOOSER_PROP_PREVIEW_TEXT,
  GTK_FONT_CHOOSER_PROP_SHOW_PREVIEW_ENTRY,
  GTK_FONT_CHOOSER_PROP_LEVEL,
  GTK_FONT_CHOOSER_PROP_FONT_FEATURES,
  GTK_FONT_CHOOSER_PROP_LANGUAGE,
  GTK_FONT_CHOOSER_PROP_LAST
} GtkFontChooserProp;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_FONT_CHOOSER_WIDGET</NAME>
#define GTK_TYPE_FONT_CHOOSER_WIDGET              (gtk_font_chooser_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_WIDGET</NAME>
#define GTK_FONT_CHOOSER_WIDGET(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_CHOOSER_WIDGET, GtkFontChooserWidget))
</MACRO>
<MACRO>
<NAME>GTK_IS_FONT_CHOOSER_WIDGET</NAME>
#define GTK_IS_FONT_CHOOSER_WIDGET(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_CHOOSER_WIDGET))
</MACRO>
<FUNCTION>
<NAME>gtk_font_chooser_widget_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_widget_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkFontChooserWidget</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FRAME</NAME>
#define GTK_TYPE_FRAME                  (gtk_frame_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FRAME</NAME>
#define GTK_FRAME(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FRAME, GtkFrame))
</MACRO>
<MACRO>
<NAME>GTK_FRAME_CLASS</NAME>
#define GTK_FRAME_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FRAME, GtkFrameClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FRAME</NAME>
#define GTK_IS_FRAME(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FRAME))
</MACRO>
<MACRO>
<NAME>GTK_IS_FRAME_CLASS</NAME>
#define GTK_IS_FRAME_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FRAME))
</MACRO>
<MACRO>
<NAME>GTK_FRAME_GET_CLASS</NAME>
#define GTK_FRAME_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FRAME, GtkFrameClass))
</MACRO>
<STRUCT>
<NAME>GtkFrame</NAME>
struct _GtkFrame
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFrameClass</NAME>
struct _GtkFrameClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  void (*compute_child_allocation) (GtkFrame *frame,
                                    GtkAllocation *allocation);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_frame_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar   *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_label</NAME>
<RETURNS>void</RETURNS>
GtkFrame    *frame, const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label</NAME>
<RETURNS>const gchar *</RETURNS>
GtkFrame    *frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_label_widget</NAME>
<RETURNS>void</RETURNS>
GtkFrame      *frame, GtkWidget     *label_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkFrame      *frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_label_align</NAME>
<RETURNS>void</RETURNS>
GtkFrame      *frame, gfloat         xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label_align</NAME>
<RETURNS>gfloat</RETURNS>
GtkFrame      *frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_child</NAME>
<RETURNS>void</RETURNS>
GtkFrame      *frame, GtkWidget     *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkFrame      *frame
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_GESTURE</NAME>
#define GTK_TYPE_GESTURE         (gtk_gesture_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE</NAME>
#define GTK_GESTURE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE, GtkGesture))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_CLASS</NAME>
#define GTK_GESTURE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE, GtkGestureClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE</NAME>
#define GTK_IS_GESTURE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_CLASS</NAME>
#define GTK_IS_GESTURE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_GET_CLASS</NAME>
#define GTK_GESTURE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE, GtkGestureClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_device</NAME>
<RETURNS>GdkDevice *</RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_set_state</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture            *gesture, GtkEventSequenceState  state
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_sequence_state</NAME>
<RETURNS>GtkEventSequenceState</RETURNS>
GtkGesture            *gesture, GdkEventSequence      *sequence
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_set_sequence_state</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture            *gesture, GdkEventSequence      *sequence, GtkEventSequenceState  state
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_sequences</NAME>
<RETURNS>GList *</RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_last_updated_sequence</NAME>
<RETURNS>GdkEventSequence *</RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_handles_sequence</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture       *gesture, GdkEventSequence *sequence
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_last_event</NAME>
<RETURNS>GdkEvent *</RETURNS>
GtkGesture       *gesture, GdkEventSequence *sequence
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_point</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture       *gesture, GdkEventSequence *sequence, gdouble          *x, gdouble          *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_bounding_box</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture       *gesture, GdkRectangle     *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_bounding_box_center</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture       *gesture, gdouble          *x, gdouble          *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_is_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_is_recognized</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_group</NAME>
<RETURNS>void</RETURNS>
GtkGesture       *group_gesture, GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_ungroup</NAME>
<RETURNS>void</RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_group</NAME>
<RETURNS>GList *</RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_is_grouped_with</NAME>
<RETURNS>gboolean</RETURNS>
GtkGesture       *gesture, GtkGesture       *other
</FUNCTION>
<STRUCT>
<NAME>GtkGestureClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_CLICK</NAME>
#define GTK_TYPE_GESTURE_CLICK         (gtk_gesture_click_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_CLICK</NAME>
#define GTK_GESTURE_CLICK(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_CLICK, GtkGestureClick))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_CLICK_CLASS</NAME>
#define GTK_GESTURE_CLICK_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_CLICK, GtkGestureClickClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_CLICK</NAME>
#define GTK_IS_GESTURE_CLICK(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_CLICK))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_CLICK_CLASS</NAME>
#define GTK_IS_GESTURE_CLICK_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_CLICK))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_CLICK_GET_CLASS</NAME>
#define GTK_GESTURE_CLICK_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_CLICK, GtkGestureClickClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_click_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_click_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkGestureClick</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureClickClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureClick</NAME>
struct _GtkGestureClick
{
  GtkGestureSingle parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkGestureClickClass</NAME>
struct _GtkGestureClickClass
{
  GtkGestureSingleClass parent_class;

  void     (* pressed)  (GtkGestureClick *gesture,
                         gint             n_press,
                         gdouble          x,
                         gdouble          y);
  void     (* released) (GtkGestureClick *gesture,
                         gint             n_press,
                         gdouble          x,
                         gdouble          y);
  void     (* stopped)  (GtkGestureClick *gesture);

  /*<private>*/
  gpointer padding[10];
};
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_DRAG</NAME>
#define GTK_TYPE_GESTURE_DRAG         (gtk_gesture_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_DRAG</NAME>
#define GTK_GESTURE_DRAG(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_DRAG, GtkGestureDrag))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_DRAG_CLASS</NAME>
#define GTK_GESTURE_DRAG_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_DRAG, GtkGestureDragClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_DRAG</NAME>
#define GTK_IS_GESTURE_DRAG(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_DRAG))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_DRAG_CLASS</NAME>
#define GTK_IS_GESTURE_DRAG_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_DRAG))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_DRAG_GET_CLASS</NAME>
#define GTK_GESTURE_DRAG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_DRAG, GtkGestureDragClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_drag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_drag_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_drag_get_start_point</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureDrag *gesture, gdouble        *x, gdouble        *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_drag_get_offset</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureDrag *gesture, gdouble        *x, gdouble        *y
</FUNCTION>
<STRUCT>
<NAME>GtkGestureDrag</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureDragClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_LONG_PRESS</NAME>
#define GTK_TYPE_GESTURE_LONG_PRESS         (gtk_gesture_long_press_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_LONG_PRESS</NAME>
#define GTK_GESTURE_LONG_PRESS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_LONG_PRESS, GtkGestureLongPress))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_LONG_PRESS_CLASS</NAME>
#define GTK_GESTURE_LONG_PRESS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_LONG_PRESS, GtkGestureLongPressClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_LONG_PRESS</NAME>
#define GTK_IS_GESTURE_LONG_PRESS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_LONG_PRESS))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_LONG_PRESS_CLASS</NAME>
#define GTK_IS_GESTURE_LONG_PRESS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_LONG_PRESS))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_LONG_PRESS_GET_CLASS</NAME>
#define GTK_GESTURE_LONG_PRESS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_LONG_PRESS, GtkGestureLongPressClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_long_press_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_long_press_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_long_press_set_delay_factor</NAME>
<RETURNS>void</RETURNS>
GtkGestureLongPress *gesture, double               delay_factor
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_long_press_get_delay_factor</NAME>
<RETURNS>double</RETURNS>
GtkGestureLongPress *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureLongPress</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureLongPressClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_PAN</NAME>
#define GTK_TYPE_GESTURE_PAN         (gtk_gesture_pan_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_PAN</NAME>
#define GTK_GESTURE_PAN(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_PAN, GtkGesturePan))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_PAN_CLASS</NAME>
#define GTK_GESTURE_PAN_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_PAN, GtkGesturePanClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_PAN</NAME>
#define GTK_IS_GESTURE_PAN(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_PAN))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_PAN_CLASS</NAME>
#define GTK_IS_GESTURE_PAN_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_PAN))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_PAN_GET_CLASS</NAME>
#define GTK_GESTURE_PAN_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_PAN, GtkGesturePanClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_pan_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_pan_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_pan_get_orientation</NAME>
<RETURNS>GtkOrientation</RETURNS>
GtkGesturePan  *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_pan_set_orientation</NAME>
<RETURNS>void</RETURNS>
GtkGesturePan  *gesture, GtkOrientation  orientation
</FUNCTION>
<STRUCT>
<NAME>GtkGesturePan</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGesturePanClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_ROTATE</NAME>
#define GTK_TYPE_GESTURE_ROTATE         (gtk_gesture_rotate_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ROTATE</NAME>
#define GTK_GESTURE_ROTATE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_ROTATE, GtkGestureRotate))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ROTATE_CLASS</NAME>
#define GTK_GESTURE_ROTATE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_ROTATE, GtkGestureRotateClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ROTATE</NAME>
#define GTK_IS_GESTURE_ROTATE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_ROTATE))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ROTATE_CLASS</NAME>
#define GTK_IS_GESTURE_ROTATE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_ROTATE))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ROTATE_GET_CLASS</NAME>
#define GTK_GESTURE_ROTATE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_ROTATE, GtkGestureRotateClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_rotate_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_rotate_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_rotate_get_angle_delta</NAME>
<RETURNS>gdouble</RETURNS>
GtkGestureRotate *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureRotate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureRotateClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_SINGLE</NAME>
#define GTK_TYPE_GESTURE_SINGLE         (gtk_gesture_single_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SINGLE</NAME>
#define GTK_GESTURE_SINGLE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_SINGLE, GtkGestureSingle))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SINGLE_CLASS</NAME>
#define GTK_GESTURE_SINGLE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_SINGLE, GtkGestureSingleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SINGLE</NAME>
#define GTK_IS_GESTURE_SINGLE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_SINGLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SINGLE_CLASS</NAME>
#define GTK_IS_GESTURE_SINGLE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_SINGLE))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SINGLE_GET_CLASS</NAME>
#define GTK_GESTURE_SINGLE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_SINGLE, GtkGestureSingleClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_single_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_touch_only</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_set_touch_only</NAME>
<RETURNS>void</RETURNS>
GtkGestureSingle *gesture, gboolean          touch_only
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_exclusive</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_set_exclusive</NAME>
<RETURNS>void</RETURNS>
GtkGestureSingle *gesture, gboolean          exclusive
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_button</NAME>
<RETURNS>guint</RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_set_button</NAME>
<RETURNS>void</RETURNS>
GtkGestureSingle *gesture, guint             button
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_current_button</NAME>
<RETURNS>guint</RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_current_sequence</NAME>
<RETURNS>GdkEventSequence *</RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureSingle</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureSingleClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_STYLUS</NAME>
#define GTK_TYPE_GESTURE_STYLUS         (gtk_gesture_stylus_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_STYLUS</NAME>
#define GTK_GESTURE_STYLUS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_STYLUS, GtkGestureStylus))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_STYLUS_CLASS</NAME>
#define GTK_GESTURE_STYLUS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_STYLUS, GtkGestureStylusClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_STYLUS</NAME>
#define GTK_IS_GESTURE_STYLUS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_STYLUS))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_STYLUS_CLASS</NAME>
#define GTK_IS_GESTURE_STYLUS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_STYLUS))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_STYLUS_GET_CLASS</NAME>
#define GTK_GESTURE_STYLUS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_STYLUS, GtkGestureStylusClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_axis</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureStylus *gesture, GdkAxisUse        axis, gdouble          *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_axes</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureStylus  *gesture, GdkAxisUse         axes[], gdouble          **values
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_backlog</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureStylus  *gesture, GdkTimeCoord     **backlog, guint             *n_elems
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_device_tool</NAME>
<RETURNS>GdkDeviceTool *</RETURNS>
GtkGestureStylus *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureStylus</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureStylusClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_SWIPE</NAME>
#define GTK_TYPE_GESTURE_SWIPE         (gtk_gesture_swipe_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SWIPE</NAME>
#define GTK_GESTURE_SWIPE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_SWIPE, GtkGestureSwipe))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SWIPE_CLASS</NAME>
#define GTK_GESTURE_SWIPE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_SWIPE, GtkGestureSwipeClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SWIPE</NAME>
#define GTK_IS_GESTURE_SWIPE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_SWIPE))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SWIPE_CLASS</NAME>
#define GTK_IS_GESTURE_SWIPE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_SWIPE))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SWIPE_GET_CLASS</NAME>
#define GTK_GESTURE_SWIPE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_SWIPE, GtkGestureSwipeClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_swipe_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_swipe_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_swipe_get_velocity</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureSwipe *gesture, gdouble         *velocity_x, gdouble         *velocity_y
</FUNCTION>
<STRUCT>
<NAME>GtkGestureSwipe</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureSwipeClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_ZOOM</NAME>
#define GTK_TYPE_GESTURE_ZOOM         (gtk_gesture_zoom_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ZOOM</NAME>
#define GTK_GESTURE_ZOOM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_ZOOM, GtkGestureZoom))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ZOOM_CLASS</NAME>
#define GTK_GESTURE_ZOOM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_ZOOM, GtkGestureZoomClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ZOOM</NAME>
#define GTK_IS_GESTURE_ZOOM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_ZOOM))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ZOOM_CLASS</NAME>
#define GTK_IS_GESTURE_ZOOM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_ZOOM))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ZOOM_GET_CLASS</NAME>
#define GTK_GESTURE_ZOOM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_ZOOM, GtkGestureZoomClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_zoom_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_zoom_new</NAME>
<RETURNS>GtkGesture *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_zoom_get_scale_delta</NAME>
<RETURNS>gdouble</RETURNS>
GtkGestureZoom *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureZoom</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureZoomClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GL_AREA</NAME>
#define GTK_TYPE_GL_AREA                (gtk_gl_area_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GL_AREA</NAME>
#define GTK_GL_AREA(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_GL_AREA, GtkGLArea))
</MACRO>
<MACRO>
<NAME>GTK_IS_GL_AREA</NAME>
#define GTK_IS_GL_AREA(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_GL_AREA))
</MACRO>
<MACRO>
<NAME>GTK_GL_AREA_CLASS</NAME>
#define GTK_GL_AREA_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_GL_AREA, GtkGLAreaClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GL_AREA_CLASS</NAME>
#define GTK_IS_GL_AREA_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_GL_AREA))
</MACRO>
<MACRO>
<NAME>GTK_GL_AREA_GET_CLASS</NAME>
#define GTK_GL_AREA_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GL_AREA, GtkGLAreaClass))
</MACRO>
<STRUCT>
<NAME>GtkGLArea</NAME>
struct _GtkGLArea
{
  /*< private >*/
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkGLAreaClass</NAME>
struct _GtkGLAreaClass
{
  /*< private >*/
  GtkWidgetClass parent_class;

  /*< public >*/
  gboolean       (* render)         (GtkGLArea        *area,
                                     GdkGLContext     *context);
  void           (* resize)         (GtkGLArea        *area,
                                     int               width,
                                     int               height);
  GdkGLContext * (* create_context) (GtkGLArea        *area);

  /*< private >*/
  gpointer _padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_gl_area_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_set_use_es</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, gboolean      use_es
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_use_es</NAME>
<RETURNS>gboolean</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_set_required_version</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, gint          major, gint          minor
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_required_version</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, gint         *major, gint         *minor
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_has_depth_buffer</NAME>
<RETURNS>gboolean</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_set_has_depth_buffer</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, gboolean      has_depth_buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_has_stencil_buffer</NAME>
<RETURNS>gboolean</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_set_has_stencil_buffer</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, gboolean      has_stencil_buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_auto_render</NAME>
<RETURNS>gboolean</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_set_auto_render</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, gboolean      auto_render
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_queue_render</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_make_current</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_attach_buffers</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_set_error</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, const GError *error
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_error</NAME>
<RETURNS>GError *</RETURNS>
GtkGLArea    *area
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_GRID</NAME>
#define GTK_TYPE_GRID                   (gtk_grid_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GRID</NAME>
#define GTK_GRID(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_GRID, GtkGrid))
</MACRO>
<MACRO>
<NAME>GTK_GRID_CLASS</NAME>
#define GTK_GRID_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_GRID, GtkGridClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GRID</NAME>
#define GTK_IS_GRID(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_GRID))
</MACRO>
<MACRO>
<NAME>GTK_IS_GRID_CLASS</NAME>
#define GTK_IS_GRID_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_GRID))
</MACRO>
<MACRO>
<NAME>GTK_GRID_GET_CLASS</NAME>
#define GTK_GRID_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GRID, GtkGridClass))
</MACRO>
<STRUCT>
<NAME>GtkGrid</NAME>
struct _GtkGrid
{
  /*< private >*/
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkGridClass</NAME>
struct _GtkGridClass
{
  GtkWidgetClass parent_class;

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_grid_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_attach</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, GtkWidget       *child, gint             left, gint             top, gint             width, gint             height
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_attach_next_to</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, GtkWidget       *child, GtkWidget       *sibling, GtkPositionType  side, gint             width, gint             height
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_child_at</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkGrid         *grid, gint             left, gint             top
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_remove</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, GtkWidget       *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_insert_row</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_insert_column</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_remove_row</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_remove_column</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_insert_next_to</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, GtkWidget       *sibling, GtkPositionType  side
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_row_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, gboolean         homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_row_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_row_spacing</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, guint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_row_spacing</NAME>
<RETURNS>guint</RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_column_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, gboolean         homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_column_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_column_spacing</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, guint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_column_spacing</NAME>
<RETURNS>guint</RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_row_baseline_position</NAME>
<RETURNS>void</RETURNS>
GtkGrid      *grid, gint          row, GtkBaselinePosition pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_row_baseline_position</NAME>
<RETURNS>GtkBaselinePosition</RETURNS>
GtkGrid      *grid, gint          row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_baseline_row</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, gint             row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_baseline_row</NAME>
<RETURNS>gint</RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_query_child</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, GtkWidget       *child, gint            *left, gint            *top, gint            *width, gint            *height
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_GRID_LAYOUT</NAME>
#define GTK_TYPE_GRID_LAYOUT (gtk_grid_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_GRID_LAYOUT_CHILD</NAME>
#define GTK_TYPE_GRID_LAYOUT_CHILD (gtk_grid_layout_child_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_grid_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_row_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkGridLayout       *grid, gboolean             homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_row_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_row_spacing</NAME>
<RETURNS>void</RETURNS>
GtkGridLayout       *grid, guint                spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_row_spacing</NAME>
<RETURNS>guint</RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_column_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkGridLayout       *grid, gboolean             homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_column_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_column_spacing</NAME>
<RETURNS>void</RETURNS>
GtkGridLayout       *grid, guint                spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_column_spacing</NAME>
<RETURNS>guint</RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_row_baseline_position</NAME>
<RETURNS>void</RETURNS>
GtkGridLayout       *grid, int                  row, GtkBaselinePosition  pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_row_baseline_position</NAME>
<RETURNS>GtkBaselinePosition</RETURNS>
GtkGridLayout       *grid, int                  row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_baseline_row</NAME>
<RETURNS>void</RETURNS>
GtkGridLayout       *grid, int                  row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_baseline_row</NAME>
<RETURNS>int</RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_top_attach</NAME>
<RETURNS>void</RETURNS>
GtkGridLayoutChild  *child, int                  attach
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_top_attach</NAME>
<RETURNS>int</RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_left_attach</NAME>
<RETURNS>void</RETURNS>
GtkGridLayoutChild  *child, int                  attach
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_left_attach</NAME>
<RETURNS>int</RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_column_span</NAME>
<RETURNS>void</RETURNS>
GtkGridLayoutChild  *child, int                  span
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_column_span</NAME>
<RETURNS>int</RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_row_span</NAME>
<RETURNS>void</RETURNS>
GtkGridLayoutChild  *child, int                  span
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_row_span</NAME>
<RETURNS>int</RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<STRUCT>
<NAME>GtkGridLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGridLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_HEADER_BAR</NAME>
#define GTK_TYPE_HEADER_BAR            (gtk_header_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_HEADER_BAR</NAME>
#define GTK_HEADER_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HEADER_BAR, GtkHeaderBar))
</MACRO>
<MACRO>
<NAME>GTK_IS_HEADER_BAR</NAME>
#define GTK_IS_HEADER_BAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_HEADER_BAR))
</MACRO>
<FUNCTION>
<NAME>gtk_header_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_set_title_widget</NAME>
<RETURNS>void</RETURNS>
GtkHeaderBar *bar, GtkWidget    *title_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_title_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkHeaderBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_pack_start</NAME>
<RETURNS>void</RETURNS>
GtkHeaderBar *bar, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_pack_end</NAME>
<RETURNS>void</RETURNS>
GtkHeaderBar *bar, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_remove</NAME>
<RETURNS>void</RETURNS>
GtkHeaderBar *bar, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_show_title_buttons</NAME>
<RETURNS>gboolean</RETURNS>
GtkHeaderBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_set_show_title_buttons</NAME>
<RETURNS>void</RETURNS>
GtkHeaderBar *bar, gboolean      setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_set_decoration_layout</NAME>
<RETURNS>void</RETURNS>
GtkHeaderBar *bar, const gchar  *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_decoration_layout</NAME>
<RETURNS>const gchar *</RETURNS>
GtkHeaderBar *bar
</FUNCTION>
<STRUCT>
<NAME>GtkHeaderBar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ICON_PAINTABLE</NAME>
#define GTK_TYPE_ICON_PAINTABLE    (gtk_icon_paintable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ICON_PAINTABLE</NAME>
#define GTK_ICON_PAINTABLE(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ICON_PAINTABLE, GtkIconPaintable))
</MACRO>
<MACRO>
<NAME>GTK_IS_ICON_PAINTABLE</NAME>
#define GTK_IS_ICON_PAINTABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ICON_PAINTABLE))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_THEME</NAME>
#define GTK_TYPE_ICON_THEME        (gtk_icon_theme_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ICON_THEME</NAME>
#define GTK_ICON_THEME(obj)        (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ICON_THEME, GtkIconTheme))
</MACRO>
<MACRO>
<NAME>GTK_IS_ICON_THEME</NAME>
#define GTK_IS_ICON_THEME(obj)     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ICON_THEME))
</MACRO>
<ENUM>
<NAME>GtkIconLookupFlags</NAME>
typedef enum
{
  GTK_ICON_LOOKUP_FORCE_REGULAR  = 1 << 0,
  GTK_ICON_LOOKUP_FORCE_SYMBOLIC = 1 << 1,
  GTK_ICON_LOOKUP_PRELOAD        = 1 << 2,
} GtkIconLookupFlags;
</ENUM>
<MACRO>
<NAME>GTK_ICON_THEME_ERROR</NAME>
#define GTK_ICON_THEME_ERROR gtk_icon_theme_error_quark ()
</MACRO>
<ENUM>
<NAME>GtkIconThemeError</NAME>
typedef enum {
  GTK_ICON_THEME_NOT_FOUND,
  GTK_ICON_THEME_FAILED
} GtkIconThemeError;
</ENUM>
<FUNCTION>
<NAME>gtk_icon_theme_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_new</NAME>
<RETURNS>GtkIconTheme *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_for_display</NAME>
<RETURNS>GtkIconTheme *</RETURNS>
GdkDisplay                  *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_set_search_path</NAME>
<RETURNS>void</RETURNS>
GtkIconTheme                *self, const char * const          *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_search_path</NAME>
<RETURNS>char **</RETURNS>
GtkIconTheme                *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_add_search_path</NAME>
<RETURNS>void</RETURNS>
GtkIconTheme                *self, const char                  *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_set_resource_path</NAME>
<RETURNS>void</RETURNS>
GtkIconTheme                *self, const char * const          *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_resource_path</NAME>
<RETURNS>char **</RETURNS>
GtkIconTheme                *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_add_resource_path</NAME>
<RETURNS>void</RETURNS>
GtkIconTheme                *self, const char                  *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_set_theme_name</NAME>
<RETURNS>void</RETURNS>
GtkIconTheme                *self, const char                  *theme_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_theme_name</NAME>
<RETURNS>char *</RETURNS>
GtkIconTheme                *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_has_icon</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconTheme                *self, const gchar                 *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_icon_sizes</NAME>
<RETURNS>gint *</RETURNS>
GtkIconTheme                *self, const gchar                 *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_icon</NAME>
<RETURNS>GtkIconPaintable *</RETURNS>
GtkIconTheme                *self, const char                  *icon_name, const char                  *fallbacks[], gint                         size, gint                         scale, GtkTextDirection             direction, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_by_gicon</NAME>
<RETURNS>GtkIconPaintable *</RETURNS>
GtkIconTheme                *self, GIcon                       *icon, gint                         size, gint                         scale, GtkTextDirection             direction, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_paintable_new_for_file</NAME>
<RETURNS>GtkIconPaintable *</RETURNS>
GFile                       *file, gint                         size, gint                         scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_icon_names</NAME>
<RETURNS>char **</RETURNS>
GtkIconTheme                *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_paintable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_paintable_get_file</NAME>
<RETURNS>GFile *</RETURNS>
GtkIconPaintable  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_paintable_get_icon_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkIconPaintable  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_paintable_is_symbolic</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconPaintable  *self
</FUNCTION>
<STRUCT>
<NAME>GtkIconPaintable</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkIconTheme</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ICON_VIEW</NAME>
#define GTK_TYPE_ICON_VIEW            (gtk_icon_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ICON_VIEW</NAME>
#define GTK_ICON_VIEW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ICON_VIEW, GtkIconView))
</MACRO>
<MACRO>
<NAME>GTK_IS_ICON_VIEW</NAME>
#define GTK_IS_ICON_VIEW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ICON_VIEW))
</MACRO>
<USER_FUNCTION>
<NAME>GtkIconViewForeachFunc</NAME>
<RETURNS>void</RETURNS>
GtkIconView      *icon_view, GtkTreePath      *path, gpointer          data
</USER_FUNCTION>
<ENUM>
<NAME>GtkIconViewDropPosition</NAME>
typedef enum
{
  GTK_ICON_VIEW_NO_DROP,
  GTK_ICON_VIEW_DROP_INTO,
  GTK_ICON_VIEW_DROP_LEFT,
  GTK_ICON_VIEW_DROP_RIGHT,
  GTK_ICON_VIEW_DROP_ABOVE,
  GTK_ICON_VIEW_DROP_BELOW
} GtkIconViewDropPosition;
</ENUM>
<FUNCTION>
<NAME>gtk_icon_view_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_new_with_area</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkCellArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_new_with_model</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeModel   *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_model</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, GtkTreeModel   *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_text_column</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_text_column</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_markup_column</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_markup_column</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_pixbuf_column</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_pixbuf_column</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_orientation</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_orientation</NAME>
<RETURNS>GtkOrientation</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_columns</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            columns
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_columns</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_width</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            item_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_width</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_spacing</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_spacing</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_row_spacing</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            row_spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_row_spacing</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_column_spacing</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            column_spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_column_spacing</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_margin</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_margin</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_padding</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, gint            item_padding
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_padding</NAME>
<RETURNS>gint</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_path_at_pos</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkIconView     *icon_view, gint             x, gint             y
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_at_pos</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView     *icon_view, gint              x, gint              y, GtkTreePath     **path, GtkCellRenderer **cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_visible_range</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView      *icon_view, GtkTreePath     **start_path, GtkTreePath     **end_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_activate_on_single_click</NAME>
<RETURNS>void</RETURNS>
GtkIconView  *icon_view, gboolean      single
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_activate_on_single_click</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView  *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_selected_foreach</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view, GtkIconViewForeachFunc  func, gpointer                data
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_selection_mode</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view, GtkSelectionMode        mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_selection_mode</NAME>
<RETURNS>GtkSelectionMode</RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_select_path</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unselect_path</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_path_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_row</NAME>
<RETURNS>gint</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_column</NAME>
<RETURNS>gint</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_selected_items</NAME>
<RETURNS>GList *</RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_select_all</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unselect_all</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_item_activated</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_cursor</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path, GtkCellRenderer        *cell, gboolean                start_editing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_cursor</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView            *icon_view, GtkTreePath           **path, GtkCellRenderer       **cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_scroll_to_path</NAME>
<RETURNS>void</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path, gboolean                use_align, gfloat                  row_align, gfloat                  col_align
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_enable_model_drag_source</NAME>
<RETURNS>void</RETURNS>
GtkIconView              *icon_view, GdkModifierType           start_button_mask, GdkContentFormats        *formats, GdkDragAction             actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_enable_model_drag_dest</NAME>
<RETURNS>void</RETURNS>
GtkIconView              *icon_view, GdkContentFormats        *formats, GdkDragAction             actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unset_model_drag_source</NAME>
<RETURNS>void</RETURNS>
GtkIconView              *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unset_model_drag_dest</NAME>
<RETURNS>void</RETURNS>
GtkIconView              *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_reorderable</NAME>
<RETURNS>void</RETURNS>
GtkIconView              *icon_view, gboolean                  reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_reorderable</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView              *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_drag_dest_item</NAME>
<RETURNS>void</RETURNS>
GtkIconView              *icon_view, GtkTreePath              *path, GtkIconViewDropPosition   pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_drag_dest_item</NAME>
<RETURNS>void</RETURNS>
GtkIconView              *icon_view, GtkTreePath             **path, GtkIconViewDropPosition  *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_dest_item_at_pos</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView              *icon_view, gint                      drag_x, gint                      drag_y, GtkTreePath             **path, GtkIconViewDropPosition  *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_create_drag_icon</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkIconView              *icon_view, GtkTreePath              *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_cell_rect</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView     *icon_view, GtkTreePath     *path, GtkCellRenderer *cell, GdkRectangle    *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_tooltip_item</NAME>
<RETURNS>void</RETURNS>
GtkIconView     *icon_view, GtkTooltip      *tooltip, GtkTreePath     *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_tooltip_cell</NAME>
<RETURNS>void</RETURNS>
GtkIconView     *icon_view, GtkTooltip      *tooltip, GtkTreePath     *path, GtkCellRenderer *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_tooltip_context</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView       *icon_view, gint              *x, gint              *y, gboolean           keyboard_tip, GtkTreeModel     **model, GtkTreePath      **path, GtkTreeIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_tooltip_column</NAME>
<RETURNS>void</RETURNS>
GtkIconView       *icon_view, gint               column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_tooltip_column</NAME>
<RETURNS>gint</RETURNS>
GtkIconView       *icon_view
</FUNCTION>
<STRUCT>
<NAME>GtkIconView</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_IMAGE</NAME>
#define GTK_TYPE_IMAGE                  (gtk_image_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IMAGE</NAME>
#define GTK_IMAGE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE, GtkImage))
</MACRO>
<MACRO>
<NAME>GTK_IS_IMAGE</NAME>
#define GTK_IS_IMAGE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE))
</MACRO>
<ENUM>
<NAME>GtkImageType</NAME>
typedef enum
{
  GTK_IMAGE_EMPTY,
  GTK_IMAGE_ICON_NAME,
  GTK_IMAGE_GICON,
  GTK_IMAGE_PAINTABLE
} GtkImageType;
</ENUM>
<FUNCTION>
<NAME>gtk_image_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_file</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_resource</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_pixbuf</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkPixbuf       *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_paintable</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkPaintable    *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_icon_name</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_gicon</NAME>
<RETURNS>GtkWidget *</RETURNS>
GIcon           *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_clear</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_file</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, const gchar     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_resource</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, const gchar     *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_pixbuf</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, GdkPixbuf       *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_paintable</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, GdkPaintable    *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, const gchar     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_gicon</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, GIcon           *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_pixel_size</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, gint             pixel_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_icon_size</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, GtkIconSize      icon_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_storage_type</NAME>
<RETURNS>GtkImageType</RETURNS>
GtkImage   *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_paintable</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkImage       *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_icon_name</NAME>
<RETURNS>const char *</RETURNS>
GtkImage     *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_gicon</NAME>
<RETURNS>GIcon *</RETURNS>
GtkImage              *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_pixel_size</NAME>
<RETURNS>gint</RETURNS>
GtkImage             *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_icon_size</NAME>
<RETURNS>GtkIconSize</RETURNS>
GtkImage             *image
</FUNCTION>
<STRUCT>
<NAME>GtkImage</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_IM_CONTEXT</NAME>
#define GTK_TYPE_IM_CONTEXT              (gtk_im_context_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT</NAME>
#define GTK_IM_CONTEXT(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_CONTEXT, GtkIMContext))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_CLASS</NAME>
#define GTK_IM_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_CONTEXT, GtkIMContextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT</NAME>
#define GTK_IS_IM_CONTEXT(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT_CLASS</NAME>
#define GTK_IS_IM_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_GET_CLASS</NAME>
#define GTK_IM_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT, GtkIMContextClass))
</MACRO>
<STRUCT>
<NAME>GtkIMContext</NAME>
struct _GtkIMContext
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkIMContextClass</NAME>
struct _GtkIMContextClass
{
  /*< private >*/
  GObjectClass parent_class;

  /*< public >*/
  /* Signals */
  void     (*preedit_start)        (GtkIMContext *context);
  void     (*preedit_end)          (GtkIMContext *context);
  void     (*preedit_changed)      (GtkIMContext *context);
  void     (*commit)               (GtkIMContext *context, const gchar *str);
  gboolean (*retrieve_surrounding) (GtkIMContext *context);
  gboolean (*delete_surrounding)   (GtkIMContext *context,
				    gint          offset,
				    gint          n_chars);

  /* Virtual functions */
  void     (*set_client_widget)   (GtkIMContext   *context,
				   GtkWidget      *widget);
  void     (*get_preedit_string)  (GtkIMContext   *context,
				   gchar         **str,
				   PangoAttrList **attrs,
				   gint           *cursor_pos);
  gboolean (*filter_keypress)     (GtkIMContext   *context,
			           GdkEvent       *event);
  void     (*focus_in)            (GtkIMContext   *context);
  void     (*focus_out)           (GtkIMContext   *context);
  void     (*reset)               (GtkIMContext   *context);
  void     (*set_cursor_location) (GtkIMContext   *context,
				   GdkRectangle   *area);
  void     (*set_use_preedit)     (GtkIMContext   *context,
				   gboolean        use_preedit);
  void     (*set_surrounding)     (GtkIMContext   *context,
				   const gchar    *text,
				   gint            len,
				   gint            cursor_index);
  gboolean (*get_surrounding)     (GtkIMContext   *context,
				   gchar         **text,
				   gint           *cursor_index);
  /*< private >*/
  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
  void (*_gtk_reserved5) (void);
  void (*_gtk_reserved6) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_im_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_set_client_widget</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context, GtkWidget          *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_get_preedit_string</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context, gchar             **str, PangoAttrList     **attrs, gint               *cursor_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_filter_keypress</NAME>
<RETURNS>gboolean</RETURNS>
GtkIMContext       *context, GdkEvent           *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_focus_in</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_focus_out</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_reset</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_set_cursor_location</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context, const GdkRectangle *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_set_use_preedit</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context, gboolean            use_preedit
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_set_surrounding</NAME>
<RETURNS>void</RETURNS>
GtkIMContext       *context, const gchar        *text, gint                len, gint                cursor_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_get_surrounding</NAME>
<RETURNS>gboolean</RETURNS>
GtkIMContext       *context, gchar             **text, gint               *cursor_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_delete_surrounding</NAME>
<RETURNS>gboolean</RETURNS>
GtkIMContext       *context, gint                offset, gint                n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_broadway_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_IM_CONTEXT_IME</NAME>
#define GTK_TYPE_IM_CONTEXT_IME            (gtk_im_context_ime_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_IME</NAME>
#define GTK_IM_CONTEXT_IME(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_CONTEXT_IME, GtkIMContextIME))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_IME_CLASS</NAME>
#define GTK_IM_CONTEXT_IME_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_CONTEXT_IME, GtkIMContextIMEClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT_IME</NAME>
#define GTK_IS_IM_CONTEXT_IME(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_CONTEXT_IME))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT_IME_CLASS</NAME>
#define GTK_IS_IM_CONTEXT_IME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_CONTEXT_IME))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_IME_GET_CLASS</NAME>
#define GTK_IM_CONTEXT_IME_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT_IME, GtkIMContextIMEClass))
</MACRO>
<STRUCT>
<NAME>GtkIMContextIME</NAME>
struct _GtkIMContextIME
{
  GtkIMContext object;

  GdkSurface *client_surface;
  guint use_preedit : 1;
  guint preediting : 1;
  guint opened : 1;
  guint focus : 1;
  GdkRectangle cursor_location;
  gchar *commit_string;

  GtkIMContextIMEPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkIMContextIMEClass</NAME>
struct _GtkIMContextIMEClass
{
  GtkIMContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_im_context_ime_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_ime_register_type</NAME>
<RETURNS>void</RETURNS>
GTypeModule * type_module
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_ime_new</NAME>
<RETURNS>GtkIMContext *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkIMContextIMEPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_im_context_quartz_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_MAX_COMPOSE_LEN</NAME>
#define GTK_MAX_COMPOSE_LEN 7
</MACRO>
<MACRO>
<NAME>GTK_TYPE_IM_CONTEXT_SIMPLE</NAME>
#define GTK_TYPE_IM_CONTEXT_SIMPLE              (gtk_im_context_simple_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_SIMPLE</NAME>
#define GTK_IM_CONTEXT_SIMPLE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_CONTEXT_SIMPLE, GtkIMContextSimple))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_SIMPLE_CLASS</NAME>
#define GTK_IM_CONTEXT_SIMPLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_CONTEXT_SIMPLE, GtkIMContextSimpleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT_SIMPLE</NAME>
#define GTK_IS_IM_CONTEXT_SIMPLE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_CONTEXT_SIMPLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT_SIMPLE_CLASS</NAME>
#define GTK_IS_IM_CONTEXT_SIMPLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_CONTEXT_SIMPLE))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_SIMPLE_GET_CLASS</NAME>
#define GTK_IM_CONTEXT_SIMPLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT_SIMPLE, GtkIMContextSimpleClass))
</MACRO>
<STRUCT>
<NAME>GtkIMContextSimple</NAME>
struct _GtkIMContextSimple
{
  GtkIMContext object;

  /*< private >*/
  GtkIMContextSimplePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkIMContextSimpleClass</NAME>
struct _GtkIMContextSimpleClass
{
  GtkIMContextClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_im_context_simple_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_simple_new</NAME>
<RETURNS>GtkIMContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_simple_add_table</NAME>
<RETURNS>void</RETURNS>
GtkIMContextSimple *context_simple, guint16            *data, gint                max_seq_len, gint                n_seqs
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_simple_add_compose_file</NAME>
<RETURNS>void</RETURNS>
GtkIMContextSimple *context_simple, const gchar        *compose_file
</FUNCTION>
<STRUCT>
<NAME>GtkIMContextSimplePrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_im_context_wayland_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_modules_init</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_IM_MODULE_EXTENSION_POINT_NAME</NAME>
#define GTK_IM_MODULE_EXTENSION_POINT_NAME "gtk-im-module"
</MACRO>
<MACRO>
<NAME>GTK_TYPE_IM_MULTICONTEXT</NAME>
#define GTK_TYPE_IM_MULTICONTEXT              (gtk_im_multicontext_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IM_MULTICONTEXT</NAME>
#define GTK_IM_MULTICONTEXT(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_MULTICONTEXT, GtkIMMulticontext))
</MACRO>
<MACRO>
<NAME>GTK_IM_MULTICONTEXT_CLASS</NAME>
#define GTK_IM_MULTICONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_MULTICONTEXT, GtkIMMulticontextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_MULTICONTEXT</NAME>
#define GTK_IS_IM_MULTICONTEXT(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_MULTICONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_MULTICONTEXT_CLASS</NAME>
#define GTK_IS_IM_MULTICONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_MULTICONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IM_MULTICONTEXT_GET_CLASS</NAME>
#define GTK_IM_MULTICONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_MULTICONTEXT, GtkIMMulticontextClass))
</MACRO>
<STRUCT>
<NAME>GtkIMMulticontext</NAME>
struct _GtkIMMulticontext
{
  GtkIMContext object;

  /*< private >*/
  GtkIMMulticontextPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkIMMulticontextClass</NAME>
struct _GtkIMMulticontextClass
{
  GtkIMContextClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_im_multicontext_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_multicontext_new</NAME>
<RETURNS>GtkIMContext *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_multicontext_get_context_id</NAME>
<RETURNS>const char *</RETURNS>
GtkIMMulticontext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_multicontext_set_context_id</NAME>
<RETURNS>void</RETURNS>
GtkIMMulticontext *context, const char        *context_id
</FUNCTION>
<STRUCT>
<NAME>GtkIMMulticontextPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INFO_BAR</NAME>
#define GTK_TYPE_INFO_BAR              (gtk_info_bar_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INFO_BAR</NAME>
#define GTK_INFO_BAR(obj)              (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INFO_BAR, GtkInfoBar))
</MACRO>
<MACRO>
<NAME>GTK_IS_INFO_BAR</NAME>
#define GTK_IS_INFO_BAR(obj)           (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INFO_BAR))
</MACRO>
<FUNCTION>
<NAME>gtk_info_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_new_with_buttons</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar    *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, GtkWidget      *child, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_remove_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkInfoBar     *info_bar, const gchar    *button_text, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_buttons</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, const gchar    *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_child</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_remove_child</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_response_sensitive</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, gint            response_id, gboolean        setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_default_response</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_response</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_message_type</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, GtkMessageType  message_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_message_type</NAME>
<RETURNS>GtkMessageType</RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_show_close_button</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, gboolean        setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_show_close_button</NAME>
<RETURNS>gboolean</RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_revealed</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, gboolean        revealed
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_revealed</NAME>
<RETURNS>gboolean</RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<STRUCT>
<NAME>GtkInfoBar</NAME>
</STRUCT>
<MACRO>
<NAME>P_</NAME>
#define P_(String) g_dgettext(GETTEXT_PACKAGE "-properties",String)
</MACRO>
<MACRO>
<NAME>I_</NAME>
#define I_(string) g_intern_static_string (string)
</MACRO>
<FUNCTION>
<NAME>istring_is_inline</NAME>
<RETURNS>gboolean</RETURNS>
const IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_str</NAME>
<RETURNS>char *</RETURNS>
IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_clear</NAME>
<RETURNS>void</RETURNS>
IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_set</NAME>
<RETURNS>void</RETURNS>
IString    *str, const char *text, guint       n_bytes, guint       n_chars
</FUNCTION>
<FUNCTION>
<NAME>istring_empty</NAME>
<RETURNS>gboolean</RETURNS>
IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_ends_with_space</NAME>
<RETURNS>gboolean</RETURNS>
IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_starts_with_space</NAME>
<RETURNS>gboolean</RETURNS>
IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_contains_unichar</NAME>
<RETURNS>gboolean</RETURNS>
IString  *str, gunichar  ch
</FUNCTION>
<FUNCTION>
<NAME>istring_only_contains_space</NAME>
<RETURNS>gboolean</RETURNS>
IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_contains_space</NAME>
<RETURNS>gboolean</RETURNS>
IString *str
</FUNCTION>
<FUNCTION>
<NAME>istring_prepend</NAME>
<RETURNS>void</RETURNS>
IString *str, IString *other
</FUNCTION>
<FUNCTION>
<NAME>istring_append</NAME>
<RETURNS>void</RETURNS>
IString *str, IString *other
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_LABEL</NAME>
#define GTK_TYPE_LABEL		  (gtk_label_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LABEL</NAME>
#define GTK_LABEL(obj)		  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LABEL, GtkLabel))
</MACRO>
<MACRO>
<NAME>GTK_IS_LABEL</NAME>
#define GTK_IS_LABEL(obj)	  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LABEL))
</MACRO>
<FUNCTION>
<NAME>gtk_label_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_text</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkLabel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_attributes</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, PangoAttrList *attrs
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_attributes</NAME>
<RETURNS>PangoAttrList *</RETURNS>
GtkLabel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_label</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_label</NAME>
<RETURNS>const gchar *</RETURNS>
GtkLabel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_markup</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_use_markup</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_use_markup</NAME>
<RETURNS>gboolean</RETURNS>
GtkLabel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_use_underline</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_use_underline</NAME>
<RETURNS>gboolean</RETURNS>
GtkLabel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_markup_with_mnemonic</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, const gchar      *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_mnemonic_keyval</NAME>
<RETURNS>guint</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_mnemonic_widget</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_mnemonic_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_text_with_mnemonic</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, const gchar      *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_justify</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, GtkJustification  jtype
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_justify</NAME>
<RETURNS>GtkJustification</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_ellipsize</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, PangoEllipsizeMode mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_ellipsize</NAME>
<RETURNS>PangoEllipsizeMode</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_width_chars</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, int               n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_width_chars</NAME>
<RETURNS>gint</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_max_width_chars</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, int               n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_max_width_chars</NAME>
<RETURNS>gint</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_lines</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, gint              lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_lines</NAME>
<RETURNS>gint</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_wrap</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, gboolean          wrap
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_wrap</NAME>
<RETURNS>gboolean</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_wrap_mode</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, PangoWrapMode     wrap_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_wrap_mode</NAME>
<RETURNS>PangoWrapMode</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_selectable</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, gboolean          setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_selectable</NAME>
<RETURNS>gboolean</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_select_region</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, gint              start_offset, gint              end_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_selection_bounds</NAME>
<RETURNS>gboolean</RETURNS>
GtkLabel         *self, gint             *start, gint             *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
GtkLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_layout_offsets</NAME>
<RETURNS>void</RETURNS>
GtkLabel *self, gint     *x, gint     *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_single_line_mode</NAME>
<RETURNS>void</RETURNS>
GtkLabel *self, gboolean single_line_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_single_line_mode</NAME>
<RETURNS>gboolean</RETURNS>
GtkLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_current_uri</NAME>
<RETURNS>const gchar *</RETURNS>
GtkLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_xalign</NAME>
<RETURNS>void</RETURNS>
GtkLabel *self, gfloat    xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_xalign</NAME>
<RETURNS>gfloat</RETURNS>
GtkLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_yalign</NAME>
<RETURNS>void</RETURNS>
GtkLabel *self, gfloat    yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_yalign</NAME>
<RETURNS>gfloat</RETURNS>
GtkLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_extra_menu</NAME>
<RETURNS>void</RETURNS>
GtkLabel   *self, GMenuModel *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_extra_menu</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkLabel   *self
</FUNCTION>
<STRUCT>
<NAME>GtkLabel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LAYOUT_CHILD</NAME>
#define GTK_TYPE_LAYOUT_CHILD (gtk_layout_child_get_type())
</MACRO>
<STRUCT>
<NAME>GtkLayoutChildClass</NAME>
struct _GtkLayoutChildClass
{
  /*< private >*/
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_layout_child_get_layout_manager</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
GtkLayoutChild *layout_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_child_get_child_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkLayoutChild *layout_child
</FUNCTION>
<STRUCT>
<NAME>GtkLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LAYOUT_MANAGER</NAME>
#define GTK_TYPE_LAYOUT_MANAGER (gtk_layout_manager_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkLayoutManagerClass</NAME>
struct _GtkLayoutManagerClass
{
  /*< private >*/
  GObjectClass parent_class;

  /*< public >*/
  GtkSizeRequestMode (* get_request_mode)    (GtkLayoutManager *manager,
                                              GtkWidget        *widget);

  void               (* measure)             (GtkLayoutManager *manager,
                                              GtkWidget        *widget,
                                              GtkOrientation    orientation,
                                              int               for_size,
                                              int              *minimum,
                                              int              *natural,
                                              int              *minimum_baseline,
                                              int              *natural_baseline);

  void               (* allocate)            (GtkLayoutManager *manager,
                                              GtkWidget        *widget,
                                              int               width,
                                              int               height,
                                              int               baseline);

  GType              layout_child_type;

  GtkLayoutChild *   (* create_layout_child) (GtkLayoutManager *manager,
                                              GtkWidget        *widget,
                                              GtkWidget        *for_child);

  void               (* root)                (GtkLayoutManager *manager);
  void               (* unroot)              (GtkLayoutManager *manager);

  /*< private >*/
  gpointer _padding[16];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_layout_manager_measure</NAME>
<RETURNS>void</RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget, GtkOrientation    orientation, int               for_size, int              *minimum, int              *natural, int              *minimum_baseline, int              *natural_baseline
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_allocate</NAME>
<RETURNS>void</RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget, int               width, int               height, int               baseline
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_get_request_mode</NAME>
<RETURNS>GtkSizeRequestMode</RETURNS>
GtkLayoutManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_get_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkLayoutManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_layout_changed</NAME>
<RETURNS>void</RETURNS>
GtkLayoutManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_get_layout_child</NAME>
<RETURNS>GtkLayoutChild *</RETURNS>
GtkLayoutManager *manager, GtkWidget        *child
</FUNCTION>
<STRUCT>
<NAME>GtkLayoutManager</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_layout_manager_set_widget</NAME>
<RETURNS>void</RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_remove_layout_child</NAME>
<RETURNS>void</RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_set_root</NAME>
<RETURNS>void</RETURNS>
GtkLayoutManager *manager, GtkRoot          *root
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_LEVEL_BAR</NAME>
#define GTK_TYPE_LEVEL_BAR            (gtk_level_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR</NAME>
#define GTK_LEVEL_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LEVEL_BAR, GtkLevelBar))
</MACRO>
<MACRO>
<NAME>GTK_IS_LEVEL_BAR</NAME>
#define GTK_IS_LEVEL_BAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LEVEL_BAR))
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR_OFFSET_LOW</NAME>
#define GTK_LEVEL_BAR_OFFSET_LOW  "low"
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR_OFFSET_HIGH</NAME>
#define GTK_LEVEL_BAR_OFFSET_HIGH "high"
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR_OFFSET_FULL</NAME>
#define GTK_LEVEL_BAR_OFFSET_FULL "full"
</MACRO>
<FUNCTION>
<NAME>gtk_level_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_new_for_interval</NAME>
<RETURNS>GtkWidget *</RETURNS>
gdouble      min_value, gdouble      max_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_mode</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, GtkLevelBarMode mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_mode</NAME>
<RETURNS>GtkLevelBarMode</RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_value</NAME>
<RETURNS>gdouble</RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_min_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_min_value</NAME>
<RETURNS>gdouble</RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_max_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_max_value</NAME>
<RETURNS>gdouble</RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_inverted</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, gboolean     inverted
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_inverted</NAME>
<RETURNS>gboolean</RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_add_offset_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, const gchar *name, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_remove_offset_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_offset_value</NAME>
<RETURNS>gboolean</RETURNS>
GtkLevelBar *self, const gchar *name, gdouble     *value
</FUNCTION>
<STRUCT>
<NAME>GtkLevelBar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LINK_BUTTON</NAME>
#define GTK_TYPE_LINK_BUTTON		(gtk_link_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LINK_BUTTON</NAME>
#define GTK_LINK_BUTTON(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LINK_BUTTON, GtkLinkButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_LINK_BUTTON</NAME>
#define GTK_IS_LINK_BUTTON(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LINK_BUTTON))
</MACRO>
<FUNCTION>
<NAME>gtk_link_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar   *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_new_with_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar   *uri, const gchar   *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_get_uri</NAME>
<RETURNS>const gchar *</RETURNS>
GtkLinkButton *link_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_set_uri</NAME>
<RETURNS>void</RETURNS>
GtkLinkButton *link_button, const gchar   *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_get_visited</NAME>
<RETURNS>gboolean</RETURNS>
GtkLinkButton *link_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_set_visited</NAME>
<RETURNS>void</RETURNS>
GtkLinkButton *link_button, gboolean       visited
</FUNCTION>
<STRUCT>
<NAME>GtkLinkButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LIST_BOX</NAME>
#define GTK_TYPE_LIST_BOX (gtk_list_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX</NAME>
#define GTK_LIST_BOX(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LIST_BOX, GtkListBox))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BOX</NAME>
#define GTK_IS_LIST_BOX(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LIST_BOX))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_LIST_BOX_ROW</NAME>
#define GTK_TYPE_LIST_BOX_ROW            (gtk_list_box_row_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ROW</NAME>
#define GTK_LIST_BOX_ROW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LIST_BOX_ROW, GtkListBoxRow))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ROW_CLASS</NAME>
#define GTK_LIST_BOX_ROW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LIST_BOX_ROW, GtkListBoxRowClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BOX_ROW</NAME>
#define GTK_IS_LIST_BOX_ROW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LIST_BOX_ROW))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BOX_ROW_CLASS</NAME>
#define GTK_IS_LIST_BOX_ROW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST_BOX_ROW))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ROW_GET_CLASS</NAME>
#define GTK_LIST_BOX_ROW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LIST_BOX_ROW, GtkListBoxRowClass))
</MACRO>
<STRUCT>
<NAME>GtkListBoxRow</NAME>
struct _GtkListBoxRow
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkListBoxRowClass</NAME>
struct _GtkListBoxRowClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  void (* activate) (GtkListBoxRow *row);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<USER_FUNCTION>
<NAME>GtkListBoxFilterFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkListBoxRow *row, gpointer       user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkListBoxSortFunc</NAME>
<RETURNS>gint</RETURNS>
GtkListBoxRow *row1, GtkListBoxRow *row2, gpointer       user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkListBoxUpdateHeaderFunc</NAME>
<RETURNS>void</RETURNS>
GtkListBoxRow *row, GtkListBoxRow *before, gpointer       user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkListBoxCreateWidgetFunc</NAME>
<RETURNS>GtkWidget *</RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_set_child</NAME>
<RETURNS>void</RETURNS>
GtkListBoxRow *row, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkListBoxRow *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_get_header</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkListBoxRow *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_set_header</NAME>
<RETURNS>void</RETURNS>
GtkListBoxRow *row, GtkWidget     *header
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_get_index</NAME>
<RETURNS>gint</RETURNS>
GtkListBoxRow *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_changed</NAME>
<RETURNS>void</RETURNS>
GtkListBoxRow *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkListBoxRow *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_set_selectable</NAME>
<RETURNS>void</RETURNS>
GtkListBoxRow *row, gboolean       selectable
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_get_selectable</NAME>
<RETURNS>gboolean</RETURNS>
GtkListBoxRow *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_set_activatable</NAME>
<RETURNS>void</RETURNS>
GtkListBoxRow *row, gboolean       activatable
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_row_get_activatable</NAME>
<RETURNS>gboolean</RETURNS>
GtkListBoxRow *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_prepend</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkWidget                     *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_insert</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkWidget                     *child, gint                           position
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_remove</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkWidget                     *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_selected_row</NAME>
<RETURNS>GtkListBoxRow *</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_row_at_index</NAME>
<RETURNS>GtkListBoxRow *</RETURNS>
GtkListBox                    *box, gint                           index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_row_at_y</NAME>
<RETURNS>GtkListBoxRow *</RETURNS>
GtkListBox                    *box, gint                           y
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_select_row</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkListBoxRow                 *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_placeholder</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkWidget                     *placeholder
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_adjustment</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkAdjustment                 *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_adjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkListBox                    *box
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkListBoxForeachFunc</NAME>
<RETURNS>void</RETURNS>
GtkListBox      *box, GtkListBoxRow   *row, gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_selected_foreach</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkListBoxForeachFunc          func, gpointer                       data
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_selected_rows</NAME>
<RETURNS>GList *</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_unselect_row</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkListBoxRow                 *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_select_all</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_unselect_all</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_selection_mode</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkSelectionMode               mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_selection_mode</NAME>
<RETURNS>GtkSelectionMode</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_filter_func</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkListBoxFilterFunc           filter_func, gpointer                       user_data, GDestroyNotify                 destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_header_func</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkListBoxUpdateHeaderFunc     update_header, gpointer                       user_data, GDestroyNotify                 destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_invalidate_filter</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_invalidate_sort</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_invalidate_headers</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkListBoxSortFunc             sort_func, gpointer                       user_data, GDestroyNotify                 destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_activate_on_single_click</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, gboolean                       single
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_activate_on_single_click</NAME>
<RETURNS>gboolean</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_drag_unhighlight_row</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_drag_highlight_row</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkListBoxRow                 *row
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_bind_model</NAME>
<RETURNS>void</RETURNS>
GtkListBox                   *box, GListModel                   *model, GtkListBoxCreateWidgetFunc    create_widget_func, gpointer                      user_data, GDestroyNotify                user_data_free_func
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_set_show_separators</NAME>
<RETURNS>void</RETURNS>
GtkListBox                   *box, gboolean                      show_separators
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_show_separators</NAME>
<RETURNS>gboolean</RETURNS>
GtkListBox                   *box
</FUNCTION>
<STRUCT>
<NAME>GtkListBox</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LIST_LIST_MODEL</NAME>
#define GTK_TYPE_LIST_LIST_MODEL         (gtk_list_list_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_LIST_MODEL</NAME>
#define GTK_LIST_LIST_MODEL(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_LIST_LIST_MODEL, GtkListListModel))
</MACRO>
<MACRO>
<NAME>GTK_LIST_LIST_MODEL_CLASS</NAME>
#define GTK_LIST_LIST_MODEL_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_LIST_LIST_MODEL, GtkListListModelClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_LIST_MODEL</NAME>
#define GTK_IS_LIST_LIST_MODEL(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_LIST_LIST_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_LIST_MODEL_CLASS</NAME>
#define GTK_IS_LIST_LIST_MODEL_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_LIST_LIST_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_LIST_LIST_MODEL_GET_CLASS</NAME>
#define GTK_LIST_LIST_MODEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_LIST_LIST_MODEL, GtkListListModelClass))
</MACRO>
<FUNCTION>
<NAME>gtk_list_list_model_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_list_model_new</NAME>
<RETURNS>GtkListListModel *</RETURNS>
GType                   item_type, gpointer                (* get_first) (gpointer), gpointer                (* get_next) (gpointer, gpointer), gpointer                (* get_previous) (gpointer, gpointer), gpointer                (* get_last) (gpointer), gpointer                (* get_item) (gpointer, gpointer), gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_list_model_new_with_size</NAME>
<RETURNS>GtkListListModel *</RETURNS>
GType                   item_type, guint                   n_items, gpointer                (* get_first) (gpointer), gpointer                (* get_next) (gpointer, gpointer), gpointer                (* get_previous) (gpointer, gpointer), gpointer                (* get_last) (gpointer), gpointer                (* get_item) (gpointer, gpointer), gpointer                data, GDestroyNotify          notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_list_model_item_added</NAME>
<RETURNS>void</RETURNS>
GtkListListModel       *self, gpointer                item
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_list_model_item_added_at</NAME>
<RETURNS>void</RETURNS>
GtkListListModel       *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_list_model_item_removed</NAME>
<RETURNS>void</RETURNS>
GtkListListModel       *self, gpointer                previous
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_list_model_item_removed_at</NAME>
<RETURNS>void</RETURNS>
GtkListListModel       *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_list_model_clear</NAME>
<RETURNS>void</RETURNS>
GtkListListModel       *self
</FUNCTION>
<STRUCT>
<NAME>GtkListListModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkListListModelClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LIST_STORE</NAME>
#define GTK_TYPE_LIST_STORE	       (gtk_list_store_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_STORE</NAME>
#define GTK_LIST_STORE(obj)	       (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LIST_STORE, GtkListStore))
</MACRO>
<MACRO>
<NAME>GTK_LIST_STORE_CLASS</NAME>
#define GTK_LIST_STORE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LIST_STORE, GtkListStoreClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_STORE</NAME>
#define GTK_IS_LIST_STORE(obj)	       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LIST_STORE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_STORE_CLASS</NAME>
#define GTK_IS_LIST_STORE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST_STORE))
</MACRO>
<MACRO>
<NAME>GTK_LIST_STORE_GET_CLASS</NAME>
#define GTK_LIST_STORE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LIST_STORE, GtkListStoreClass))
</MACRO>
<STRUCT>
<NAME>GtkListStore</NAME>
struct _GtkListStore
{
  GObject parent;

  /*< private >*/
  GtkListStorePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkListStoreClass</NAME>
struct _GtkListStoreClass
{
  GObjectClass parent_class;

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_list_store_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_new</NAME>
<RETURNS>GtkListStore *</RETURNS>
gint          n_columns, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_newv</NAME>
<RETURNS>GtkListStore *</RETURNS>
gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_column_types</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_value</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          column, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_valuesv</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_valist</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, va_list       var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_remove</NAME>
<RETURNS>gboolean</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_before</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_after</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_with_values</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          position, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_with_valuesv</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          position, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_prepend</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_append</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_clear</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_iter_is_valid</NAME>
<RETURNS>gboolean</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_reorder</NAME>
<RETURNS>void</RETURNS>
GtkListStore *store, gint         *new_order
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_swap</NAME>
<RETURNS>void</RETURNS>
GtkListStore *store, GtkTreeIter  *a, GtkTreeIter  *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_move_after</NAME>
<RETURNS>void</RETURNS>
GtkListStore *store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_move_before</NAME>
<RETURNS>void</RETURNS>
GtkListStore *store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<STRUCT>
<NAME>GtkListStorePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LOCK_BUTTON</NAME>
#define GTK_TYPE_LOCK_BUTTON         (gtk_lock_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LOCK_BUTTON</NAME>
#define GTK_LOCK_BUTTON(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_LOCK_BUTTON, GtkLockButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_LOCK_BUTTON</NAME>
#define GTK_IS_LOCK_BUTTON(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_LOCK_BUTTON))
</MACRO>
<FUNCTION>
<NAME>gtk_lock_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_lock_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GPermission   *permission
</FUNCTION>
<FUNCTION>
<NAME>gtk_lock_button_get_permission</NAME>
<RETURNS>GPermission *</RETURNS>
GtkLockButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_lock_button_set_permission</NAME>
<RETURNS>void</RETURNS>
GtkLockButton *button, GPermission   *permission
</FUNCTION>
<STRUCT>
<NAME>GtkLockButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_PRIORITY_RESIZE</NAME>
#define GTK_PRIORITY_RESIZE (G_PRIORITY_HIGH_IDLE + 10)
</MACRO>
<FUNCTION>
<NAME>gtk_get_major_version</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_minor_version</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_micro_version</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_binary_age</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_interface_age</NAME>
<RETURNS>guint</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_version</NAME>
<RETURNS>const gchar *</RETURNS>
guint   required_major, guint   required_minor, guint   required_micro
</FUNCTION>
<FUNCTION>
<NAME>gtk_init</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_init_check</NAME>
<RETURNS>gboolean</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_is_initialized</NAME>
<RETURNS>gboolean</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_init_abi_check</NAME>
<RETURNS>void</RETURNS>
int     num_checks, size_t  sizeof_GtkWindow, size_t  sizeof_GtkBox
</FUNCTION>
<FUNCTION>
<NAME>gtk_init_check_abi_check</NAME>
<RETURNS>gboolean</RETURNS>
int     num_checks, size_t  sizeof_GtkWindow, size_t  sizeof_GtkBox
</FUNCTION>
<FUNCTION>
<NAME>gtk_disable_setlocale</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_default_language</NAME>
<RETURNS>PangoLanguage *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_locale_direction</NAME>
<RETURNS>GtkTextDirection</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_MAP_LIST_MODEL</NAME>
#define GTK_TYPE_MAP_LIST_MODEL (gtk_map_list_model_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkMapListModelMapFunc</NAME>
<RETURNS>gpointer</RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_new</NAME>
<RETURNS>GtkMapListModel *</RETURNS>
GType                   item_type, GListModel             *model, GtkMapListModelMapFunc  map_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_set_map_func</NAME>
<RETURNS>void</RETURNS>
GtkMapListModel        *self, GtkMapListModelMapFunc  map_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_set_model</NAME>
<RETURNS>void</RETURNS>
GtkMapListModel        *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkMapListModel        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_has_map</NAME>
<RETURNS>gboolean</RETURNS>
GtkMapListModel        *self
</FUNCTION>
<STRUCT>
<NAME>GtkMapListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MEDIA_CONTROLS</NAME>
#define GTK_TYPE_MEDIA_CONTROLS         (gtk_media_controls_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_media_controls_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkMediaStream         *stream
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_controls_get_media_stream</NAME>
<RETURNS>GtkMediaStream *</RETURNS>
GtkMediaControls       *controls
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_controls_set_media_stream</NAME>
<RETURNS>void</RETURNS>
GtkMediaControls       *controls, GtkMediaStream         *stream
</FUNCTION>
<STRUCT>
<NAME>GtkMediaControls</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_MEDIA_FILE_EXTENSION_POINT_NAME</NAME>
#define GTK_MEDIA_FILE_EXTENSION_POINT_NAME "gtk-media-file"
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MEDIA_FILE</NAME>
#define GTK_TYPE_MEDIA_FILE             (gtk_media_file_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkMediaFileClass</NAME>
struct _GtkMediaFileClass
{
  GtkMediaStreamClass parent_class;

  void                  (* open)                                (GtkMediaFile *self);
  void                  (* close)                               (GtkMediaFile *self);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_media_file_new</NAME>
<RETURNS>GtkMediaStream *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_new_for_filename</NAME>
<RETURNS>GtkMediaStream *</RETURNS>
const char     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_new_for_resource</NAME>
<RETURNS>GtkMediaStream *</RETURNS>
const char     *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_new_for_file</NAME>
<RETURNS>GtkMediaStream *</RETURNS>
GFile          *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_new_for_input_stream</NAME>
<RETURNS>GtkMediaStream *</RETURNS>
GInputStream   *stream
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_clear</NAME>
<RETURNS>void</RETURNS>
GtkMediaFile   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_set_filename</NAME>
<RETURNS>void</RETURNS>
GtkMediaFile   *self, const char     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_set_resource</NAME>
<RETURNS>void</RETURNS>
GtkMediaFile   *self, const char     *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_set_file</NAME>
<RETURNS>void</RETURNS>
GtkMediaFile   *self, GFile          *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_get_file</NAME>
<RETURNS>GFile *</RETURNS>
GtkMediaFile   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_set_input_stream</NAME>
<RETURNS>void</RETURNS>
GtkMediaFile   *self, GInputStream   *stream
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_file_get_input_stream</NAME>
<RETURNS>GInputStream *</RETURNS>
GtkMediaFile   *self
</FUNCTION>
<STRUCT>
<NAME>GtkMediaFile</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MEDIA_STREAM</NAME>
#define GTK_TYPE_MEDIA_STREAM             (gtk_media_stream_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkMediaStreamClass</NAME>
struct _GtkMediaStreamClass
{
  GObjectClass parent_class;

  gboolean              (* play)                                (GtkMediaStream *self);
  void                  (* pause)                               (GtkMediaStream *self);
  void                  (* seek)                                (GtkMediaStream *self,
                                                                 gint64          timestamp);
  void                  (* update_audio)                        (GtkMediaStream *self,
                                                                 gboolean        muted,
                                                                 double          volume);
  void                  (* realize)                             (GtkMediaStream *self,
                                                                 GdkSurface      *surface);
  void                  (* unrealize)                           (GtkMediaStream *self,
                                                                 GdkSurface      *surface);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
  void (*_gtk_reserved5) (void);
  void (*_gtk_reserved6) (void);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_media_stream_is_prepared</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_error</NAME>
<RETURNS>const GError *</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_has_audio</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_has_video</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_play</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_pause</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_playing</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_playing</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, gboolean        playing
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_ended</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_timestamp</NAME>
<RETURNS>gint64</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_duration</NAME>
<RETURNS>gint64</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_is_seekable</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_is_seeking</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_seek</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, gint64          timestamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_loop</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_loop</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, gboolean        loop
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_muted</NAME>
<RETURNS>gboolean</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_muted</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, gboolean        muted
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_volume</NAME>
<RETURNS>double</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_volume</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, double          volume
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_realize</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, GdkSurface      *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_unrealize</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, GdkSurface      *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_prepared</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, gboolean        has_audio, gboolean        has_video, gboolean        seekable, gint64          duration
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_unprepared</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_update</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, gint64          timestamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_ended</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_seek_success</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_seek_failed</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_gerror</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, GError         *error
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_error</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, GQuark          domain, gint            code, const gchar    *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_error_valist</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, GQuark          domain, gint            code, const gchar    *format, va_list         args
</FUNCTION>
<STRUCT>
<NAME>GtkMediaStream</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_BUTTON</NAME>
#define GTK_TYPE_MENU_BUTTON            (gtk_menu_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON</NAME>
#define GTK_MENU_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_BUTTON, GtkMenuButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_BUTTON</NAME>
#define GTK_IS_MENU_BUTTON(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_BUTTON))
</MACRO>
<USER_FUNCTION>
<NAME>GtkMenuButtonCreatePopupFunc</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, gpointer       user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_popover</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, GtkWidget     *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_popover</NAME>
<RETURNS>GtkPopover *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_direction</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, GtkArrowType   direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_direction</NAME>
<RETURNS>GtkArrowType</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_menu_model</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, GMenuModel    *menu_model
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_menu_model</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_align_widget</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, GtkWidget     *align_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_align_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, const char    *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_icon_name</NAME>
<RETURNS>const char *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_label</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, const char    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_label</NAME>
<RETURNS>const char *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_use_underline</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button, gboolean       use_underline
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_use_underline</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_has_frame</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton  *menu_button, gboolean        has_frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_has_frame</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuButton  *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_popup</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_popdown</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_create_popup_func</NAME>
<RETURNS>void</RETURNS>
GtkMenuButton                *menu_button, GtkMenuButtonCreatePopupFunc  func, gpointer                      user_data, GDestroyNotify                destroy_notify
</FUNCTION>
<STRUCT>
<NAME>GtkMenuButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_SECTION_BOX</NAME>
#define GTK_TYPE_MENU_SECTION_BOX                           (gtk_menu_section_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_SECTION_BOX</NAME>
#define GTK_MENU_SECTION_BOX(inst)                          (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
                                                             GTK_TYPE_MENU_SECTION_BOX, GtkMenuSectionBox))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SECTION_BOX_CLASS</NAME>
#define GTK_MENU_SECTION_BOX_CLASS(class)                   (G_TYPE_CHECK_CLASS_CAST ((class),                       \
                                                             GTK_TYPE_MENU_SECTION_BOX, GtkMenuSectionBoxClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SECTION_BOX</NAME>
#define GTK_IS_MENU_SECTION_BOX(inst)                       (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
                                                             GTK_TYPE_MENU_SECTION_BOX))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SECTION_BOX_CLASS</NAME>
#define GTK_IS_MENU_SECTION_BOX_CLASS(class)                (G_TYPE_CHECK_CLASS_TYPE ((class),                       \
                                                             GTK_TYPE_MENU_SECTION_BOX))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SECTION_BOX_GET_CLASS</NAME>
#define GTK_MENU_SECTION_BOX_GET_CLASS(inst)                (G_TYPE_INSTANCE_GET_CLASS ((inst),                      \
                                                             GTK_TYPE_MENU_SECTION_BOX, GtkMenuSectionBoxClass))
</MACRO>
<FUNCTION>
<NAME>gtk_menu_section_box_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_section_box_new_toplevel</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenu      *popover, GMenuModel          *model, GtkPopoverMenuFlags  flags
</FUNCTION>
<STRUCT>
<NAME>GtkMenuSectionBox</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_TRACKER_ITEM</NAME>
#define GTK_TYPE_MENU_TRACKER_ITEM                          (gtk_menu_tracker_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_TRACKER_ITEM</NAME>
#define GTK_MENU_TRACKER_ITEM(inst)                         (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
                                                             GTK_TYPE_MENU_TRACKER_ITEM, GtkMenuTrackerItem))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_TRACKER_ITEM</NAME>
#define GTK_IS_MENU_TRACKER_ITEM(inst)                      (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
                                                             GTK_TYPE_MENU_TRACKER_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MENU_TRACKER_ITEM_ROLE</NAME>
#define GTK_TYPE_MENU_TRACKER_ITEM_ROLE                     (gtk_menu_tracker_item_role_get_type ())
</MACRO>
<ENUM>
<NAME>GtkMenuTrackerItemRole</NAME>
typedef enum  {
  GTK_MENU_TRACKER_ITEM_ROLE_NORMAL,
  GTK_MENU_TRACKER_ITEM_ROLE_CHECK,
  GTK_MENU_TRACKER_ITEM_ROLE_RADIO,
} GtkMenuTrackerItemRole;
</ENUM>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_role_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_special</NAME>
<RETURNS>const gchar *</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_display_hint</NAME>
<RETURNS>const gchar *</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_text_direction</NAME>
<RETURNS>const gchar *</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_is_separator</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_has_link</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self, const gchar        *link_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_label</NAME>
<RETURNS>const gchar *</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_icon</NAME>
<RETURNS>GIcon *</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_verb_icon</NAME>
<RETURNS>GIcon *</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_sensitive</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_role</NAME>
<RETURNS>GtkMenuTrackerItemRole</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_toggled</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_accel</NAME>
<RETURNS>const gchar *</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_may_disappear</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_is_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_should_request_show</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_activated</NAME>
<RETURNS>void</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_request_submenu_shown</NAME>
<RETURNS>void</RETURNS>
GtkMenuTrackerItem *self, gboolean            shown
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_submenu_shown</NAME>
<RETURNS>gboolean</RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<STRUCT>
<NAME>GtkMenuTrackerItem</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkMenuTrackerInsertFunc</NAME>
<RETURNS>void</RETURNS>
GtkMenuTrackerItem       *item, gint                      position, gpointer                  user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkMenuTrackerRemoveFunc</NAME>
<RETURNS>void</RETURNS>
gint                      position, gpointer                  user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_new</NAME>
<RETURNS>GtkMenuTracker *</RETURNS>
GtkActionObservable      *observer, GMenuModel               *model, gboolean                  with_separators, gboolean                  merge_sections, gboolean                  mac_os_mode, const gchar              *action_namespace, GtkMenuTrackerInsertFunc  insert_func, GtkMenuTrackerRemoveFunc  remove_func, gpointer                  user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_new_for_item_link</NAME>
<RETURNS>GtkMenuTracker *</RETURNS>
GtkMenuTrackerItem       *item, const gchar              *link_name, gboolean                  merge_sections, gboolean                  mac_os_mode, GtkMenuTrackerInsertFunc  insert_func, GtkMenuTrackerRemoveFunc  remove_func, gpointer                  user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_free</NAME>
<RETURNS>void</RETURNS>
GtkMenuTracker           *tracker
</FUNCTION>
<STRUCT>
<NAME>GtkMenuTracker</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MESSAGE_DIALOG</NAME>
#define GTK_TYPE_MESSAGE_DIALOG                  (gtk_message_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MESSAGE_DIALOG</NAME>
#define GTK_MESSAGE_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_MESSAGE_DIALOG</NAME>
#define GTK_IS_MESSAGE_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MESSAGE_DIALOG))
</MACRO>
<STRUCT>
<NAME>GtkMessageDialog</NAME>
struct _GtkMessageDialog
{
  GtkDialog parent_instance;
};
</STRUCT>
<ENUM>
<NAME>GtkButtonsType</NAME>
typedef enum
{
  GTK_BUTTONS_NONE,
  GTK_BUTTONS_OK,
  GTK_BUTTONS_CLOSE,
  GTK_BUTTONS_CANCEL,
  GTK_BUTTONS_YES_NO,
  GTK_BUTTONS_OK_CANCEL
} GtkButtonsType;
</ENUM>
<FUNCTION>
<NAME>gtk_message_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow      *parent, GtkDialogFlags  flags, GtkMessageType  type, GtkButtonsType  buttons, const gchar    *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_new_with_markup</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow      *parent, GtkDialogFlags  flags, GtkMessageType  type, GtkButtonsType  buttons, const gchar    *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_set_markup</NAME>
<RETURNS>void</RETURNS>
GtkMessageDialog *message_dialog, const gchar      *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_format_secondary_text</NAME>
<RETURNS>void</RETURNS>
GtkMessageDialog *message_dialog, const gchar      *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_format_secondary_markup</NAME>
<RETURNS>void</RETURNS>
GtkMessageDialog *message_dialog, const gchar      *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_get_message_area</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkMessageDialog *message_dialog
</FUNCTION>
<STRUCT>
<NAME>GtkMessageDialogClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MODEL_BUTTON</NAME>
#define GTK_TYPE_MODEL_BUTTON         (gtk_model_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MODEL_BUTTON</NAME>
#define GTK_MODEL_BUTTON(inst)        (G_TYPE_CHECK_INSTANCE_CAST ((inst),                      \
                                      GTK_TYPE_MODEL_BUTTON, GtkModelButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_MODEL_BUTTON</NAME>
#define GTK_IS_MODEL_BUTTON(inst)     (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                      \
                                      GTK_TYPE_MODEL_BUTTON))
</MACRO>
<ENUM>
<NAME>GtkButtonRole</NAME>
typedef enum {
  GTK_BUTTON_ROLE_NORMAL,
  GTK_BUTTON_ROLE_CHECK,
  GTK_BUTTON_ROLE_RADIO,
  GTK_BUTTON_ROLE_TITLE
} GtkButtonRole;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_BUTTON_ROLE</NAME>
#define GTK_TYPE_BUTTON_ROLE         (gtk_button_role_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_button_role_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_model_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_model_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkModelButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MOUNT_OPERATION</NAME>
#define GTK_TYPE_MOUNT_OPERATION         (gtk_mount_operation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MOUNT_OPERATION</NAME>
#define GTK_MOUNT_OPERATION(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_MOUNT_OPERATION, GtkMountOperation))
</MACRO>
<MACRO>
<NAME>GTK_MOUNT_OPERATION_CLASS</NAME>
#define GTK_MOUNT_OPERATION_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GTK_TYPE_MOUNT_OPERATION, GtkMountOperationClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MOUNT_OPERATION</NAME>
#define GTK_IS_MOUNT_OPERATION(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_MOUNT_OPERATION))
</MACRO>
<MACRO>
<NAME>GTK_IS_MOUNT_OPERATION_CLASS</NAME>
#define GTK_IS_MOUNT_OPERATION_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_MOUNT_OPERATION))
</MACRO>
<MACRO>
<NAME>GTK_MOUNT_OPERATION_GET_CLASS</NAME>
#define GTK_MOUNT_OPERATION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_MOUNT_OPERATION, GtkMountOperationClass))
</MACRO>
<STRUCT>
<NAME>GtkMountOperation</NAME>
struct _GtkMountOperation
{
  GMountOperation parent_instance;

  GtkMountOperationPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMountOperationClass</NAME>
struct _GtkMountOperationClass
{
  GMountOperationClass parent_class;

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_mount_operation_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_new</NAME>
<RETURNS>GMountOperation *</RETURNS>
GtkWindow         *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_is_showing</NAME>
<RETURNS>gboolean</RETURNS>
GtkMountOperation *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_set_parent</NAME>
<RETURNS>void</RETURNS>
GtkMountOperation *op, GtkWindow         *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_get_parent</NAME>
<RETURNS>GtkWindow *</RETURNS>
GtkMountOperation *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_set_display</NAME>
<RETURNS>void</RETURNS>
GtkMountOperation *op, GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GtkMountOperation *op
</FUNCTION>
<STRUCT>
<NAME>GtkMountOperationPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NATIVE</NAME>
#define GTK_TYPE_NATIVE               (gtk_native_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkNativeInterface</NAME>
struct _GtkNativeInterface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/
  GdkSurface *  (* get_surface)           (GtkNative    *self);
  GskRenderer * (* get_renderer)          (GtkNative    *self);

  void          (* get_surface_transform) (GtkNative    *self,
                                           double       *x,
                                           double       *y);

  void          (* check_resize)          (GtkNative    *self);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_native_get_for_surface</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkSurface *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_check_resize</NAME>
<RETURNS>void</RETURNS>
GtkNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GtkNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_get_renderer</NAME>
<RETURNS>GskRenderer *</RETURNS>
GtkNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_get_surface_transform</NAME>
<RETURNS>void</RETURNS>
GtkNative *self, double    *x, double    *y
</FUNCTION>
<STRUCT>
<NAME>GtkNative</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NATIVE_DIALOG</NAME>
#define GTK_TYPE_NATIVE_DIALOG             (gtk_native_dialog_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkNativeDialogClass</NAME>
struct _GtkNativeDialogClass
{
  GObjectClass parent_class;

  void (* response) (GtkNativeDialog *self, gint response_id);

  /* <private> */
  void (* show) (GtkNativeDialog *self);
  void (* hide) (GtkNativeDialog *self);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_native_dialog_show</NAME>
<RETURNS>void</RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_hide</NAME>
<RETURNS>void</RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_destroy</NAME>
<RETURNS>void</RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_set_modal</NAME>
<RETURNS>void</RETURNS>
GtkNativeDialog *self, gboolean modal
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_modal</NAME>
<RETURNS>gboolean</RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_set_title</NAME>
<RETURNS>void</RETURNS>
GtkNativeDialog *self, const char *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_title</NAME>
<RETURNS>const char *</RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_set_transient_for</NAME>
<RETURNS>void</RETURNS>
GtkNativeDialog *self, GtkWindow *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_transient_for</NAME>
<RETURNS>GtkWindow *</RETURNS>
GtkNativeDialog *self
</FUNCTION>
<STRUCT>
<NAME>GtkNativeDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NO_SELECTION</NAME>
#define GTK_TYPE_NO_SELECTION (gtk_no_selection_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_no_selection_new</NAME>
<RETURNS>GtkNoSelection *</RETURNS>
GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_no_selection_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkNoSelection         *self
</FUNCTION>
<STRUCT>
<NAME>GtkNoSelection</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NOTEBOOK</NAME>
#define GTK_TYPE_NOTEBOOK                  (gtk_notebook_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK</NAME>
#define GTK_NOTEBOOK(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK, GtkNotebook))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK</NAME>
#define GTK_IS_NOTEBOOK(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_NOTEBOOK_PAGE</NAME>
#define GTK_TYPE_NOTEBOOK_PAGE (gtk_notebook_page_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_PAGE</NAME>
#define GTK_NOTEBOOK_PAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK_PAGE, GtkNotebookPage))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_PAGE</NAME>
#define GTK_IS_NOTEBOOK_PAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_PAGE))
</MACRO>
<ENUM>
<NAME>GtkNotebookTab</NAME>
typedef enum
{
  GTK_NOTEBOOK_TAB_FIRST,
  GTK_NOTEBOOK_TAB_LAST
} GtkNotebookTab;
</ENUM>
<FUNCTION>
<NAME>gtk_notebook_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_append_page</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_append_page_menu</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prepend_page</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prepend_page_menu</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_insert_page</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, gint         position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_insert_page_menu</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label, gint         position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_remove_page</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, gint         page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_group_name</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, const gchar *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_group_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_current_page</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_nth_page</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkNotebook *notebook, gint         page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_n_pages</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_num</NAME>
<RETURNS>gint</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_current_page</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, gint         page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_next_page</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prev_page</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_show_border</NAME>
<RETURNS>void</RETURNS>
GtkNotebook     *notebook, gboolean         show_border
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_show_border</NAME>
<RETURNS>gboolean</RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_show_tabs</NAME>
<RETURNS>void</RETURNS>
GtkNotebook     *notebook, gboolean         show_tabs
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_show_tabs</NAME>
<RETURNS>gboolean</RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_pos</NAME>
<RETURNS>void</RETURNS>
GtkNotebook     *notebook, GtkPositionType  pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_pos</NAME>
<RETURNS>GtkPositionType</RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_scrollable</NAME>
<RETURNS>void</RETURNS>
GtkNotebook     *notebook, gboolean         scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_scrollable</NAME>
<RETURNS>gboolean</RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_popup_enable</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_popup_disable</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_label</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_label_text</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, const gchar *tab_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_label_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_menu_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_menu_label</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_menu_label_text</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, const gchar *menu_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_menu_label_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_reorder_child</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, gint         position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_reorderable</NAME>
<RETURNS>gboolean</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_reorderable</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, gboolean     reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_detachable</NAME>
<RETURNS>gboolean</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_detachable</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, gboolean     detachable
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_detach_tab</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_action_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkNotebook *notebook, GtkPackType  pack_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *widget, GtkPackType  pack_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_page</NAME>
<RETURNS>GtkNotebookPage *</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkNotebookPage *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_pages</NAME>
<RETURNS>GListModel *</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<STRUCT>
<NAME>GtkNotebook</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkNotebookPage</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ORIENTABLE</NAME>
#define GTK_TYPE_ORIENTABLE             (gtk_orientable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ORIENTABLE</NAME>
#define GTK_ORIENTABLE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ORIENTABLE, GtkOrientable))
</MACRO>
<MACRO>
<NAME>GTK_ORIENTABLE_CLASS</NAME>
#define GTK_ORIENTABLE_CLASS(vtable)    (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_ORIENTABLE, GtkOrientableIface))
</MACRO>
<MACRO>
<NAME>GTK_IS_ORIENTABLE</NAME>
#define GTK_IS_ORIENTABLE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ORIENTABLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_ORIENTABLE_CLASS</NAME>
#define GTK_IS_ORIENTABLE_CLASS(vtable) (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_ORIENTABLE))
</MACRO>
<MACRO>
<NAME>GTK_ORIENTABLE_GET_IFACE</NAME>
#define GTK_ORIENTABLE_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_ORIENTABLE, GtkOrientableIface))
</MACRO>
<STRUCT>
<NAME>GtkOrientableIface</NAME>
struct _GtkOrientableIface
{
  GTypeInterface base_iface;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_orientable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_orientable_set_orientation</NAME>
<RETURNS>void</RETURNS>
GtkOrientable  *orientable, GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_orientable_get_orientation</NAME>
<RETURNS>GtkOrientation</RETURNS>
GtkOrientable  *orientable
</FUNCTION>
<STRUCT>
<NAME>GtkOrientable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_OVERLAY</NAME>
#define GTK_TYPE_OVERLAY             (gtk_overlay_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_OVERLAY</NAME>
#define GTK_OVERLAY(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_OVERLAY, GtkOverlay))
</MACRO>
<MACRO>
<NAME>GTK_IS_OVERLAY</NAME>
#define GTK_IS_OVERLAY(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_OVERLAY))
</MACRO>
<FUNCTION>
<NAME>gtk_overlay_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_add_overlay</NAME>
<RETURNS>void</RETURNS>
GtkOverlay *overlay, GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_remove_overlay</NAME>
<RETURNS>void</RETURNS>
GtkOverlay *overlay, GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_set_child</NAME>
<RETURNS>void</RETURNS>
GtkOverlay *overlay, GtkWidget  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkOverlay *overlay
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_get_measure_overlay</NAME>
<RETURNS>gboolean</RETURNS>
GtkOverlay *overlay, GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_set_measure_overlay</NAME>
<RETURNS>void</RETURNS>
GtkOverlay *overlay, GtkWidget  *widget, gboolean    measure
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_get_clip_overlay</NAME>
<RETURNS>gboolean</RETURNS>
GtkOverlay *overlay, GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_set_clip_overlay</NAME>
<RETURNS>void</RETURNS>
GtkOverlay *overlay, GtkWidget  *widget, gboolean    clip_overlay
</FUNCTION>
<STRUCT>
<NAME>GtkOverlay</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_OVERLAY_LAYOUT</NAME>
#define GTK_TYPE_OVERLAY_LAYOUT (gtk_overlay_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_OVERLAY_LAYOUT_CHILD</NAME>
#define GTK_TYPE_OVERLAY_LAYOUT_CHILD (gtk_overlay_layout_child_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_overlay_layout_new</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_layout_child_set_measure</NAME>
<RETURNS>void</RETURNS>
GtkOverlayLayoutChild *child, gboolean               measure
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_layout_child_get_measure</NAME>
<RETURNS>gboolean</RETURNS>
GtkOverlayLayoutChild *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_layout_child_set_clip_overlay</NAME>
<RETURNS>void</RETURNS>
GtkOverlayLayoutChild *child, gboolean               clip_overlay
</FUNCTION>
<FUNCTION>
<NAME>gtk_overlay_layout_child_get_clip_overlay</NAME>
<RETURNS>gboolean</RETURNS>
GtkOverlayLayoutChild *child
</FUNCTION>
<STRUCT>
<NAME>GtkOverlayLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkOverlayLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PAD_CONTROLLER</NAME>
#define GTK_TYPE_PAD_CONTROLLER         (gtk_pad_controller_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PAD_CONTROLLER</NAME>
#define GTK_PAD_CONTROLLER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_PAD_CONTROLLER, GtkPadController))
</MACRO>
<MACRO>
<NAME>GTK_PAD_CONTROLLER_CLASS</NAME>
#define GTK_PAD_CONTROLLER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_PAD_CONTROLLER, GtkPadControllerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PAD_CONTROLLER</NAME>
#define GTK_IS_PAD_CONTROLLER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_PAD_CONTROLLER))
</MACRO>
<MACRO>
<NAME>GTK_IS_PAD_CONTROLLER_CLASS</NAME>
#define GTK_IS_PAD_CONTROLLER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_PAD_CONTROLLER))
</MACRO>
<MACRO>
<NAME>GTK_PAD_CONTROLLER_GET_CLASS</NAME>
#define GTK_PAD_CONTROLLER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_PAD_CONTROLLER, GtkPadControllerClass))
</MACRO>
<ENUM>
<NAME>GtkPadActionType</NAME>
typedef enum {
  GTK_PAD_ACTION_BUTTON,
  GTK_PAD_ACTION_RING,
  GTK_PAD_ACTION_STRIP
} GtkPadActionType;
</ENUM>
<STRUCT>
<NAME>GtkPadActionEntry</NAME>
struct _GtkPadActionEntry {
  GtkPadActionType type;
  int index;
  int mode;
  const char *label;
  const char *action_name;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_pad_controller_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_pad_controller_new</NAME>
<RETURNS>GtkPadController *</RETURNS>
GActionGroup     *group, GdkDevice        *pad
</FUNCTION>
<FUNCTION>
<NAME>gtk_pad_controller_set_action_entries</NAME>
<RETURNS>void</RETURNS>
GtkPadController        *controller, const GtkPadActionEntry *entries, gint                     n_entries
</FUNCTION>
<FUNCTION>
<NAME>gtk_pad_controller_set_action</NAME>
<RETURNS>void</RETURNS>
GtkPadController *controller, GtkPadActionType  type, gint              index, gint              mode, const gchar      *label, const gchar      *action_name
</FUNCTION>
<STRUCT>
<NAME>GtkPadController</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPadControllerClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PAGE_SETUP</NAME>
#define GTK_TYPE_PAGE_SETUP    (gtk_page_setup_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PAGE_SETUP</NAME>
#define GTK_PAGE_SETUP(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PAGE_SETUP, GtkPageSetup))
</MACRO>
<MACRO>
<NAME>GTK_IS_PAGE_SETUP</NAME>
#define GTK_IS_PAGE_SETUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PAGE_SETUP))
</MACRO>
<FUNCTION>
<NAME>gtk_page_setup_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_copy</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GtkPageSetup       *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_orientation</NAME>
<RETURNS>GtkPageOrientation</RETURNS>
GtkPageSetup       *setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_orientation</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, GtkPageOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_paper_size</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
GtkPageSetup       *setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_paper_size</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, GtkPaperSize       *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_top_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_top_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_bottom_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_bottom_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_left_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_left_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_right_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_right_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_paper_size_and_default_margins</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup    *setup, GtkPaperSize    *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_paper_width</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_paper_height</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_page_width</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_page_height</NAME>
<RETURNS>gdouble</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new_from_file</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
const gchar         *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_load_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPageSetup        *setup, const char          *file_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_to_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPageSetup        *setup, const char          *file_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new_from_key_file</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GKeyFile            *key_file, const gchar         *group_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_load_key_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPageSetup        *setup, GKeyFile            *key_file, const gchar         *group_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_to_key_file</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup        *setup, GKeyFile            *key_file, const gchar         *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_to_gvariant</NAME>
<RETURNS>GVariant *</RETURNS>
GtkPageSetup        *setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new_from_gvariant</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GVariant            *variant
</FUNCTION>
<STRUCT>
<NAME>GtkPageSetup</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PAGE_SETUP_UNIX_DIALOG</NAME>
#define GTK_TYPE_PAGE_SETUP_UNIX_DIALOG                  (gtk_page_setup_unix_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PAGE_SETUP_UNIX_DIALOG</NAME>
#define GTK_PAGE_SETUP_UNIX_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PAGE_SETUP_UNIX_DIALOG, GtkPageSetupUnixDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_PAGE_SETUP_UNIX_DIALOG</NAME>
#define GTK_IS_PAGE_SETUP_UNIX_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PAGE_SETUP_UNIX_DIALOG))
</MACRO>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar            *title, GtkWindow              *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_set_page_setup</NAME>
<RETURNS>void</RETURNS>
GtkPageSetupUnixDialog *dialog, GtkPageSetup           *page_setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_get_page_setup</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GtkPageSetupUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_set_print_settings</NAME>
<RETURNS>void</RETURNS>
GtkPageSetupUnixDialog *dialog, GtkPrintSettings       *print_settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_get_print_settings</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GtkPageSetupUnixDialog *dialog
</FUNCTION>
<STRUCT>
<NAME>GtkPageSetupUnixDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PANED</NAME>
#define GTK_TYPE_PANED                  (gtk_paned_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PANED</NAME>
#define GTK_PANED(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PANED, GtkPaned))
</MACRO>
<MACRO>
<NAME>GTK_IS_PANED</NAME>
#define GTK_IS_PANED(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PANED))
</MACRO>
<FUNCTION>
<NAME>gtk_paned_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkOrientation orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_start_child</NAME>
<RETURNS>void</RETURNS>
GtkPaned       *paned, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_start_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPaned       *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_resize_start_child</NAME>
<RETURNS>void</RETURNS>
GtkPaned *paned, gboolean  resize
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_resize_start_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaned *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_end_child</NAME>
<RETURNS>void</RETURNS>
GtkPaned       *paned, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_end_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPaned       *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_shrink_start_child</NAME>
<RETURNS>void</RETURNS>
GtkPaned *paned, gboolean  resize
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_shrink_start_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaned *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_resize_end_child</NAME>
<RETURNS>void</RETURNS>
GtkPaned *paned, gboolean  resize
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_resize_end_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaned *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_shrink_end_child</NAME>
<RETURNS>void</RETURNS>
GtkPaned *paned, gboolean  resize
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_shrink_end_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaned *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_position</NAME>
<RETURNS>gint</RETURNS>
GtkPaned       *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_position</NAME>
<RETURNS>void</RETURNS>
GtkPaned       *paned, gint            position
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_wide_handle</NAME>
<RETURNS>void</RETURNS>
GtkPaned    *paned, gboolean     wide
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_wide_handle</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaned    *paned
</FUNCTION>
<STRUCT>
<NAME>GtkPaned</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_buildable_attribute_tag_start</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuildable       *buildable, GtkBuilder         *builder, GObject            *child, const gchar        *tagname, GtkBuildableParser *parser, gpointer           *data
</FUNCTION>
<STRUCT>
<NAME>GtkPangoAttributeParserData</NAME>
typedef struct {
  GtkBuilder    *builder;
  GObject       *object;
  PangoAttrList *attrs;
} GtkPangoAttributeParserData;
</STRUCT>
<FUNCTION>
<NAME>gtk_pango_attribute_start_element</NAME>
<RETURNS>void</RETURNS>
GtkBuildableParseContext  *context, const char                *element_name, const char               **names, const char               **values, gpointer                   user_data, GError                   **error
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PAPER_SIZE</NAME>
#define GTK_TYPE_PAPER_SIZE    (gtk_paper_size_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_A3</NAME>
#define GTK_PAPER_NAME_A3 "iso_a3"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_A4</NAME>
#define GTK_PAPER_NAME_A4 "iso_a4"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_A5</NAME>
#define GTK_PAPER_NAME_A5 "iso_a5"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_B5</NAME>
#define GTK_PAPER_NAME_B5 "iso_b5"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_LETTER</NAME>
#define GTK_PAPER_NAME_LETTER "na_letter"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_EXECUTIVE</NAME>
#define GTK_PAPER_NAME_EXECUTIVE "na_executive"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_LEGAL</NAME>
#define GTK_PAPER_NAME_LEGAL "na_legal"
</MACRO>
<FUNCTION>
<NAME>gtk_paper_size_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
const gchar  *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_ppd</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
const gchar  *ppd_name, const gchar  *ppd_display_name, gdouble       width, gdouble       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_ipp</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
const gchar  *ipp_name, gdouble       width, gdouble       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_custom</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
const gchar  *name, const gchar  *display_name, gdouble       width, gdouble       height, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_copy</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
GtkPaperSize *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_free</NAME>
<RETURNS>void</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_is_equal</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaperSize *size1, GtkPaperSize *size2
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_paper_sizes</NAME>
<RETURNS>GList *</RETURNS>
gboolean include_custom
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_display_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_ppd_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_width</NAME>
<RETURNS>gdouble</RETURNS>
GtkPaperSize *size, GtkUnit unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_height</NAME>
<RETURNS>gdouble</RETURNS>
GtkPaperSize *size, GtkUnit unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_is_custom</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_is_ipp</NAME>
<RETURNS>gboolean</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_set_size</NAME>
<RETURNS>void</RETURNS>
GtkPaperSize *size, gdouble       width, gdouble       height, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_top_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_bottom_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_left_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_right_margin</NAME>
<RETURNS>gdouble</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default</NAME>
<RETURNS>const gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_key_file</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
GKeyFile    *key_file, const gchar *group_name, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_to_key_file</NAME>
<RETURNS>void</RETURNS>
GtkPaperSize *size, GKeyFile     *key_file, const gchar  *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_gvariant</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
GVariant     *variant
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_to_gvariant</NAME>
<RETURNS>GVariant *</RETURNS>
GtkPaperSize *paper_size
</FUNCTION>
<STRUCT>
<NAME>GtkPaperSize</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PASSWORD_ENTRY</NAME>
#define GTK_TYPE_PASSWORD_ENTRY                 (gtk_password_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PASSWORD_ENTRY</NAME>
#define GTK_PASSWORD_ENTRY(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PASSWORD_ENTRY, GtkPasswordEntry))
</MACRO>
<MACRO>
<NAME>GTK_IS_PASSWORD_ENTRY</NAME>
#define GTK_IS_PASSWORD_ENTRY(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PASSWORD_ENTRY))
</MACRO>
<STRUCT>
<NAME>GtkPasswordEntry</NAME>
struct _GtkPasswordEntry
{
  GtkWidget parent;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_password_entry_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_set_show_peek_icon</NAME>
<RETURNS>void</RETURNS>
GtkPasswordEntry *entry, gboolean          show_peek_icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_get_show_peek_icon</NAME>
<RETURNS>gboolean</RETURNS>
GtkPasswordEntry *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_set_extra_menu</NAME>
<RETURNS>void</RETURNS>
GtkPasswordEntry *entry, GMenuModel       *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_get_extra_menu</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkPasswordEntry *entry
</FUNCTION>
<STRUCT>
<NAME>GtkPasswordEntryClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PATH_BAR</NAME>
#define GTK_TYPE_PATH_BAR                 (gtk_path_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PATH_BAR</NAME>
#define GTK_PATH_BAR(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PATH_BAR, GtkPathBar))
</MACRO>
<MACRO>
<NAME>GTK_PATH_BAR_CLASS</NAME>
#define GTK_PATH_BAR_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PATH_BAR, GtkPathBarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PATH_BAR</NAME>
#define GTK_IS_PATH_BAR(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PATH_BAR))
</MACRO>
<MACRO>
<NAME>GTK_IS_PATH_BAR_CLASS</NAME>
#define GTK_IS_PATH_BAR_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PATH_BAR))
</MACRO>
<MACRO>
<NAME>GTK_PATH_BAR_GET_CLASS</NAME>
#define GTK_PATH_BAR_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PATH_BAR, GtkPathBarClass))
</MACRO>
<STRUCT>
<NAME>GtkPathBar</NAME>
struct _GtkPathBar
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkPathBarClass</NAME>
struct _GtkPathBarClass
{
  GtkWidgetClass parent_class;

  void (* path_clicked) (GtkPathBar  *path_bar,
			 GFile       *file,
			 GFile       *child_file,
			 gboolean     child_is_hidden);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_path_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PICTURE</NAME>
#define GTK_TYPE_PICTURE (gtk_picture_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_picture_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_new_for_paintable</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_new_for_pixbuf</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkPixbuf              *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_new_for_file</NAME>
<RETURNS>GtkWidget *</RETURNS>
GFile                  *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_new_for_filename</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar            *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_new_for_resource</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar            *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_paintable</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, GdkPaintable           *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_get_paintable</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkPicture             *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_file</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, GFile                  *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_get_file</NAME>
<RETURNS>GFile *</RETURNS>
GtkPicture             *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_filename</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, const gchar            *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_resource</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, const gchar            *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_pixbuf</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, GdkPixbuf              *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_keep_aspect_ratio</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, gboolean                keep_aspect_ratio
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_get_keep_aspect_ratio</NAME>
<RETURNS>gboolean</RETURNS>
GtkPicture             *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_can_shrink</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, gboolean                can_shrink
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_get_can_shrink</NAME>
<RETURNS>gboolean</RETURNS>
GtkPicture             *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_alternative_text</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, const char             *alternative_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_get_alternative_text</NAME>
<RETURNS>const char *</RETURNS>
GtkPicture             *self
</FUNCTION>
<STRUCT>
<NAME>GtkPicture</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_POPOVER</NAME>
#define GTK_TYPE_POPOVER                 (gtk_popover_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_POPOVER</NAME>
#define GTK_POPOVER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_POPOVER, GtkPopover))
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_CLASS</NAME>
#define GTK_POPOVER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_POPOVER, GtkPopoverClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER</NAME>
#define GTK_IS_POPOVER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_POPOVER))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER_CLASS</NAME>
#define GTK_IS_POPOVER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_POPOVER))
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_GET_CLASS</NAME>
#define GTK_POPOVER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_POPOVER, GtkPopoverClass))
</MACRO>
<STRUCT>
<NAME>GtkPopover</NAME>
struct _GtkPopover
{
  GtkWidget parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkPopoverClass</NAME>
struct _GtkPopoverClass
{
  GtkWidgetClass parent_class;

  void (* closed)           (GtkPopover *popover);
  void (* activate_default) (GtkPopover *popover);

  /*< private >*/

  gpointer reserved[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_popover_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_child</NAME>
<RETURNS>void</RETURNS>
GtkPopover         *popover, GtkWidget          *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPopover         *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_pointing_to</NAME>
<RETURNS>void</RETURNS>
GtkPopover         *popover, const GdkRectangle *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_pointing_to</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopover         *popover, GdkRectangle       *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_position</NAME>
<RETURNS>void</RETURNS>
GtkPopover         *popover, GtkPositionType     position
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_position</NAME>
<RETURNS>GtkPositionType</RETURNS>
GtkPopover         *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_autohide</NAME>
<RETURNS>void</RETURNS>
GtkPopover         *popover, gboolean            autohide
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_autohide</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopover         *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_has_arrow</NAME>
<RETURNS>void</RETURNS>
GtkPopover         *popover, gboolean            has_arrow
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_has_arrow</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopover         *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_mnemonics_visible</NAME>
<RETURNS>void</RETURNS>
GtkPopover   *popover, gboolean      mnemonics_visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_mnemonics_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopover   *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_popup</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_popdown</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_default_widget</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover, GtkWidget  *widget
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_POPOVER_MENU</NAME>
#define GTK_TYPE_POPOVER_MENU           (gtk_popover_menu_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_MENU</NAME>
#define GTK_POPOVER_MENU(o)             (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_POPOVER_MENU, GtkPopoverMenu))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER_MENU</NAME>
#define GTK_IS_POPOVER_MENU(o)          (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_POPOVER_MENU))
</MACRO>
<FUNCTION>
<NAME>gtk_popover_menu_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_new_from_model</NAME>
<RETURNS>GtkWidget *</RETURNS>
GMenuModel *model
</FUNCTION>
<ENUM>
<NAME>GtkPopoverMenuFlags</NAME>
typedef enum {
  GTK_POPOVER_MENU_NESTED = 1 << 0
} GtkPopoverMenuFlags;
</ENUM>
<FUNCTION>
<NAME>gtk_popover_menu_new_from_model_full</NAME>
<RETURNS>GtkWidget *</RETURNS>
GMenuModel          *model, GtkPopoverMenuFlags  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_set_menu_model</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenu *popover, GMenuModel     *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_get_menu_model</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkPopoverMenu *popover
</FUNCTION>
<STRUCT>
<NAME>GtkPopoverMenu</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_POPOVER_MENU_BAR</NAME>
#define	GTK_TYPE_POPOVER_MENU_BAR               (gtk_popover_menu_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_MENU_BAR</NAME>
#define GTK_POPOVER_MENU_BAR(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_POPOVER_MENU_BAR, GtkPopoverMenuBar))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER_MENU_BAR</NAME>
#define GTK_IS_POPOVER_MENU_BAR(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_POPOVER_MENU_BAR))
</MACRO>
<FUNCTION>
<NAME>gtk_popover_menu_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_bar_new_from_model</NAME>
<RETURNS>GtkWidget *</RETURNS>
GMenuModel        *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_bar_set_menu_model</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenuBar *bar, GMenuModel        *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_bar_get_menu_model</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkPopoverMenuBar *bar
</FUNCTION>
<STRUCT>
<NAME>GtkPopoverMenuBar</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_popover_menu_bar_select_first</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenuBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_bar_get_viewable_menu_bars</NAME>
<RETURNS>GList *</RETURNS>
GtkWindow         *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_get_active_item</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPopoverMenu *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_set_active_item</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenu *menu, GtkWidget      *item
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_get_open_submenu</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPopoverMenu *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_set_open_submenu</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenu *menu, GtkWidget      *submenu
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_get_parent_menu</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPopoverMenu *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_set_parent_menu</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenu *menu, GtkWidget      *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_add_submenu</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenu *popover, GtkWidget      *submenu, const char     *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_open_submenu</NAME>
<RETURNS>void</RETURNS>
GtkPopoverMenu *popover, const gchar    *name
</FUNCTION>
<MACRO>
<NAME>START_PAGE_GENERAL</NAME>
#define START_PAGE_GENERAL 0xffffffff
</MACRO>
<MACRO>
<NAME>PD_RESULT_CANCEL</NAME>
#define PD_RESULT_CANCEL  0
</MACRO>
<MACRO>
<NAME>PD_RESULT_PRINT</NAME>
#define PD_RESULT_PRINT  1
</MACRO>
<MACRO>
<NAME>PD_RESULT_APPLY</NAME>
#define PD_RESULT_APPLY  2
</MACRO>
<MACRO>
<NAME>PD_NOCURRENTPAGE</NAME>
#define PD_NOCURRENTPAGE  0x00800000
</MACRO>
<MACRO>
<NAME>PD_CURRENTPAGE</NAME>
#define PD_CURRENTPAGE  0x00400000
</MACRO>
<STRUCT>
<NAME>GtkPrintWin32Devnames</NAME>
typedef struct {
  char *driver;
  char *device;
  char *output;
  int flags;
} GtkPrintWin32Devnames;
</STRUCT>
<FUNCTION>
<NAME>gtk_print_win32_devnames_free</NAME>
<RETURNS>void</RETURNS>
GtkPrintWin32Devnames *devnames
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_win32_devnames_from_win32</NAME>
<RETURNS>GtkPrintWin32Devnames *</RETURNS>
HGLOBAL global
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_win32_devnames_from_printer_name</NAME>
<RETURNS>GtkPrintWin32Devnames *</RETURNS>
const char *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_win32_devnames_to_win32</NAME>
<RETURNS>HGLOBAL</RETURNS>
const GtkPrintWin32Devnames *devnames
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_win32_devnames_to_win32_from_printer_name</NAME>
<RETURNS>HGLOBAL</RETURNS>
const char *printer
</FUNCTION>
<MACRO>
<NAME>GTK_PRINT_BACKEND_ERROR</NAME>
#define GTK_PRINT_BACKEND_ERROR (gtk_print_backend_error_quark ())
</MACRO>
<ENUM>
<NAME>GtkPrintBackendError</NAME>
typedef enum
{
  /* TODO: add specific errors */
  GTK_PRINT_BACKEND_ERROR_GENERIC
} GtkPrintBackendError;
</ENUM>
<FUNCTION>
<NAME>gtk_print_backend_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINT_BACKEND</NAME>
#define GTK_TYPE_PRINT_BACKEND                  (gtk_print_backend_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_BACKEND</NAME>
#define GTK_PRINT_BACKEND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_BACKEND, GtkPrintBackend))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_BACKEND_CLASS</NAME>
#define GTK_PRINT_BACKEND_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_BACKEND, GtkPrintBackendClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_BACKEND</NAME>
#define GTK_IS_PRINT_BACKEND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_BACKEND))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_BACKEND_CLASS</NAME>
#define GTK_IS_PRINT_BACKEND_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_BACKEND))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_BACKEND_GET_CLASS</NAME>
#define GTK_PRINT_BACKEND_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_BACKEND, GtkPrintBackendClass))
</MACRO>
<ENUM>
<NAME>GtkPrintBackendStatus</NAME>
typedef enum 
{
  GTK_PRINT_BACKEND_STATUS_UNKNOWN,
  GTK_PRINT_BACKEND_STATUS_OK,
  GTK_PRINT_BACKEND_STATUS_UNAVAILABLE
} GtkPrintBackendStatus;
</ENUM>
<STRUCT>
<NAME>GtkPrintBackend</NAME>
struct _GtkPrintBackend
{
  GObject parent_instance;

  GtkPrintBackendPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrintBackendClass</NAME>
struct _GtkPrintBackendClass
{
  GObjectClass parent_class;

  /* Global backend methods: */
  void                   (*request_printer_list)            (GtkPrintBackend        *backend);
  void                   (*print_stream)                    (GtkPrintBackend        *backend,
							     GtkPrintJob            *job,
							     GIOChannel             *data_io,
							     GtkPrintJobCompleteFunc callback,
							     gpointer                user_data,
							     GDestroyNotify          dnotify);

  /* Printer methods: */
  void                  (*printer_request_details)           (GtkPrinter          *printer);
  cairo_surface_t *     (*printer_create_cairo_surface)      (GtkPrinter          *printer,
							      GtkPrintSettings    *settings,
							      gdouble              height,
							      gdouble              width,
							      GIOChannel          *cache_io);
  GtkPrinterOptionSet * (*printer_get_options)               (GtkPrinter          *printer,
							      GtkPrintSettings    *settings,
							      GtkPageSetup        *page_setup,
							      GtkPrintCapabilities capabilities);
  gboolean              (*printer_mark_conflicts)            (GtkPrinter          *printer,
							      GtkPrinterOptionSet *options);
  void                  (*printer_get_settings_from_options) (GtkPrinter          *printer,
							      GtkPrinterOptionSet *options,
							      GtkPrintSettings    *settings);
  void                  (*printer_prepare_for_print)         (GtkPrinter          *printer,
							      GtkPrintJob         *print_job,
							      GtkPrintSettings    *settings,
							      GtkPageSetup        *page_setup);
  GList  *              (*printer_list_papers)               (GtkPrinter          *printer);
  GtkPageSetup *        (*printer_get_default_page_size)     (GtkPrinter          *printer);
  gboolean              (*printer_get_hard_margins)          (GtkPrinter          *printer,
							      gdouble             *top,
							      gdouble             *bottom,
							      gdouble             *left,
							      gdouble             *right);
  GtkPrintCapabilities  (*printer_get_capabilities)          (GtkPrinter          *printer);

  /* Signals */
  void                  (*printer_list_changed)              (GtkPrintBackend     *backend);
  void                  (*printer_list_done)                 (GtkPrintBackend     *backend);
  void                  (*printer_added)                     (GtkPrintBackend     *backend,
							      GtkPrinter          *printer);
  void                  (*printer_removed)                   (GtkPrintBackend     *backend,
							      GtkPrinter          *printer);
  void                  (*printer_status_changed)            (GtkPrintBackend     *backend,
							      GtkPrinter          *printer);
  void                  (*request_password)                  (GtkPrintBackend     *backend,
                                                              gpointer             auth_info_required,
                                                              gpointer             auth_info_default,
                                                              gpointer             auth_info_display,
                                                              gpointer             auth_info_visible,
                                                              const gchar         *prompt,
                                                              gboolean             can_store_auth_info);

  /* not a signal */
  void                  (*set_password)                      (GtkPrintBackend     *backend,
                                                              gchar              **auth_info_required,
                                                              gchar              **auth_info,
                                                              gboolean             store_auth_info);

  gboolean              (*printer_get_hard_margins_for_paper_size) (GtkPrinter    *printer,
								    GtkPaperSize  *paper_size,
								    gdouble       *top,
								    gdouble       *bottom,
								    gdouble       *left,
								    gdouble       *right);
};
</STRUCT>
<MACRO>
<NAME>GTK_PRINT_BACKEND_EXTENSION_POINT_NAME</NAME>
#define GTK_PRINT_BACKEND_EXTENSION_POINT_NAME "gtk-print-backend"
</MACRO>
<FUNCTION>
<NAME>gtk_print_backend_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_get_printer_list</NAME>
<RETURNS>GList *</RETURNS>
GtkPrintBackend         *print_backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_printer_list_is_done</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintBackend         *print_backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_find_printer</NAME>
<RETURNS>GtkPrinter *</RETURNS>
GtkPrintBackend         *print_backend, const gchar             *printer_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_print_stream</NAME>
<RETURNS>void</RETURNS>
GtkPrintBackend         *print_backend, GtkPrintJob             *job, GIOChannel              *data_io, GtkPrintJobCompleteFunc  callback, gpointer                 user_data, GDestroyNotify           dnotify
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_load_modules</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_destroy</NAME>
<RETURNS>void</RETURNS>
GtkPrintBackend         *print_backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_set_password</NAME>
<RETURNS>void</RETURNS>
GtkPrintBackend         *backend, gchar                  **auth_info_required, gchar                  **auth_info, gboolean                 can_store_auth_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_add_printer</NAME>
<RETURNS>void</RETURNS>
GtkPrintBackend         *print_backend, GtkPrinter              *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_remove_printer</NAME>
<RETURNS>void</RETURNS>
GtkPrintBackend         *print_backend, GtkPrinter              *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_set_list_done</NAME>
<RETURNS>void</RETURNS>
GtkPrintBackend         *backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_new</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_accepts_pdf</NAME>
<RETURNS>void</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_accepts_ps</NAME>
<RETURNS>void</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_new</NAME>
<RETURNS>void</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_active</NAME>
<RETURNS>void</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_paused</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_accepting_jobs</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_has_details</NAME>
<RETURNS>void</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_default</NAME>
<RETURNS>void</RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkPrinter      *printer, const gchar     *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_job_count</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer, gint             count
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_location</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer, const gchar     *location
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_description</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer, const gchar     *description
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_state_message</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer, const gchar     *message
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backends_init</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkPrintBackendPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_CONTEXT</NAME>
#define GTK_TYPE_PRINT_CONTEXT    (gtk_print_context_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_CONTEXT</NAME>
#define GTK_PRINT_CONTEXT(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_CONTEXT, GtkPrintContext))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_CONTEXT</NAME>
#define GTK_IS_PRINT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gtk_print_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_cairo_context</NAME>
<RETURNS>cairo_t *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_page_setup</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_width</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_height</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_dpi_x</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_dpi_y</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_hard_margins</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintContext *context, gdouble         *top, gdouble         *bottom, gdouble         *left, gdouble         *right
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_pango_fontmap</NAME>
<RETURNS>PangoFontMap *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_create_pango_context</NAME>
<RETURNS>PangoContext *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_create_pango_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_set_cairo_context</NAME>
<RETURNS>void</RETURNS>
GtkPrintContext *context, cairo_t         *cr, double           dpi_x, double           dpi_y
</FUNCTION>
<STRUCT>
<NAME>GtkPrintContext</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_CAPABILITIES</NAME>
#define GTK_TYPE_PRINT_CAPABILITIES (gtk_print_capabilities_get_type ())
</MACRO>
<ENUM>
<NAME>GtkPrintCapabilities</NAME>
typedef enum
{
  GTK_PRINT_CAPABILITY_PAGE_SET         = 1 << 0,
  GTK_PRINT_CAPABILITY_COPIES           = 1 << 1,
  GTK_PRINT_CAPABILITY_COLLATE          = 1 << 2,
  GTK_PRINT_CAPABILITY_REVERSE          = 1 << 3,
  GTK_PRINT_CAPABILITY_SCALE            = 1 << 4,
  GTK_PRINT_CAPABILITY_GENERATE_PDF     = 1 << 5,
  GTK_PRINT_CAPABILITY_GENERATE_PS      = 1 << 6,
  GTK_PRINT_CAPABILITY_PREVIEW          = 1 << 7,
  GTK_PRINT_CAPABILITY_NUMBER_UP        = 1 << 8,
  GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT = 1 << 9
} GtkPrintCapabilities;
</ENUM>
<FUNCTION>
<NAME>gtk_print_capabilities_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINTER</NAME>
#define GTK_TYPE_PRINTER                  (gtk_printer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINTER</NAME>
#define GTK_PRINTER(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINTER, GtkPrinter))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER</NAME>
#define GTK_IS_PRINTER(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINTER))
</MACRO>
<FUNCTION>
<NAME>gtk_printer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_new</NAME>
<RETURNS>GtkPrinter *</RETURNS>
const gchar     *name, GtkPrintBackend *backend, gboolean         virtual_
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_backend</NAME>
<RETURNS>GtkPrintBackend *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_state_message</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_description</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_location</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_icon_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_job_count</NAME>
<RETURNS>gint</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_paused</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_accepting_jobs</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_virtual</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_default</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_accepts_pdf</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_accepts_ps</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_list_papers</NAME>
<RETURNS>GList *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_default_page_size</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_compare</NAME>
<RETURNS>gint</RETURNS>
GtkPrinter *a, GtkPrinter *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_has_details</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter       *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_request_details</NAME>
<RETURNS>void</RETURNS>
GtkPrinter       *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_capabilities</NAME>
<RETURNS>GtkPrintCapabilities</RETURNS>
GtkPrinter       *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_hard_margins</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter       *printer, gdouble          *top, gdouble          *bottom, gdouble          *left, gdouble          *right
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_hard_margins_for_paper_size</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter       *printer, GtkPaperSize     *paper_size, gdouble          *top, gdouble          *bottom, gdouble          *left, gdouble          *right
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkPrinterFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter *printer, gpointer    data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_enumerate_printers</NAME>
<RETURNS>void</RETURNS>
GtkPrinterFunc   func, gpointer         data, GDestroyNotify   destroy, gboolean         wait
</FUNCTION>
<STRUCT>
<NAME>GtkPrintBackend</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPrinter</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINTER_OPTION</NAME>
#define GTK_TYPE_PRINTER_OPTION             (gtk_printer_option_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION</NAME>
#define GTK_PRINTER_OPTION(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINTER_OPTION, GtkPrinterOption))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER_OPTION</NAME>
#define GTK_IS_PRINTER_OPTION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINTER_OPTION))
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_GROUP_IMAGE_QUALITY</NAME>
#define GTK_PRINTER_OPTION_GROUP_IMAGE_QUALITY "ImageQuality"
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_GROUP_FINISHING</NAME>
#define GTK_PRINTER_OPTION_GROUP_FINISHING "Finishing"
</MACRO>
<ENUM>
<NAME>GtkPrinterOptionType</NAME>
typedef enum {
  GTK_PRINTER_OPTION_TYPE_BOOLEAN,
  GTK_PRINTER_OPTION_TYPE_PICKONE,
  GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD,
  GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE,
  GTK_PRINTER_OPTION_TYPE_PICKONE_REAL,
  GTK_PRINTER_OPTION_TYPE_PICKONE_INT,
  GTK_PRINTER_OPTION_TYPE_PICKONE_STRING,
  GTK_PRINTER_OPTION_TYPE_ALTERNATIVE,
  GTK_PRINTER_OPTION_TYPE_STRING,
  GTK_PRINTER_OPTION_TYPE_FILESAVE,
  GTK_PRINTER_OPTION_TYPE_INFO
} GtkPrinterOptionType;
</ENUM>
<STRUCT>
<NAME>GtkPrinterOption</NAME>
struct _GtkPrinterOption
{
  GObject parent_instance;

  char *name;
  char *display_text;
  GtkPrinterOptionType type;

  char *value;
  
  int num_choices;
  char **choices;
  char **choices_display;
  
  gboolean activates_default;

  gboolean has_conflict;
  char *group;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrinterOptionClass</NAME>
struct _GtkPrinterOptionClass
{
  GObjectClass parent_class;

  void (*changed) (GtkPrinterOption *option);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_printer_option_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_new</NAME>
<RETURNS>GtkPrinterOption *</RETURNS>
const char           *name, const char           *display_text, GtkPrinterOptionType  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption     *option, const char           *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_has_conflict</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption     *option, gboolean              has_conflict
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_clear_has_conflict</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption     *option
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_boolean</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption     *option, gboolean              value
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_allocate_choices</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption     *option, int                   num
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_choices_from_array</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption     *option, int                   num_choices, char                 *choices[], char                 *choices_display[]
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_has_choice</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinterOption     *option, const char           *choice
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_activates_default</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption     *option, gboolean              activates
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_get_activates_default</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinterOption     *option
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINTER_OPTION_SET</NAME>
#define GTK_TYPE_PRINTER_OPTION_SET             (gtk_printer_option_set_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_SET</NAME>
#define GTK_PRINTER_OPTION_SET(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINTER_OPTION_SET, GtkPrinterOptionSet))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER_OPTION_SET</NAME>
#define GTK_IS_PRINTER_OPTION_SET(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINTER_OPTION_SET))
</MACRO>
<STRUCT>
<NAME>GtkPrinterOptionSet</NAME>
struct _GtkPrinterOptionSet
{
  GObject parent_instance;

  /*< private >*/
  GPtrArray *array;
  GHashTable *hash;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrinterOptionSetClass</NAME>
struct _GtkPrinterOptionSetClass
{
  GObjectClass parent_class;

  void (*changed) (GtkPrinterOptionSet *option);


  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<USER_FUNCTION>
<NAME>GtkPrinterOptionSetFunc</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOption  *option, gpointer           user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_new</NAME>
<RETURNS>GtkPrinterOptionSet *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_add</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOptionSet     *set, GtkPrinterOption        *option
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_remove</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOptionSet     *set, GtkPrinterOption        *option
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_lookup</NAME>
<RETURNS>GtkPrinterOption *</RETURNS>
GtkPrinterOptionSet     *set, const char              *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_foreach</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOptionSet     *set, GtkPrinterOptionSetFunc  func, gpointer                 user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_clear_conflicts</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOptionSet     *set
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_get_groups</NAME>
<RETURNS>GList *</RETURNS>
GtkPrinterOptionSet     *set
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_set_foreach_in_group</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOptionSet     *set, const char              *group, GtkPrinterOptionSetFunc  func, gpointer                 user_data
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINTER_OPTION_WIDGET</NAME>
#define GTK_TYPE_PRINTER_OPTION_WIDGET                  (gtk_printer_option_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_WIDGET</NAME>
#define GTK_PRINTER_OPTION_WIDGET(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINTER_OPTION_WIDGET, GtkPrinterOptionWidget))
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_WIDGET_CLASS</NAME>
#define GTK_PRINTER_OPTION_WIDGET_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINTER_OPTION_WIDGET, GtkPrinterOptionWidgetClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER_OPTION_WIDGET</NAME>
#define GTK_IS_PRINTER_OPTION_WIDGET(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINTER_OPTION_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER_OPTION_WIDGET_CLASS</NAME>
#define GTK_IS_PRINTER_OPTION_WIDGET_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINTER_OPTION_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_WIDGET_GET_CLASS</NAME>
#define GTK_PRINTER_OPTION_WIDGET_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINTER_OPTION_WIDGET, GtkPrinterOptionWidgetClass))
</MACRO>
<TYPEDEF>
<NAME>GtkPrinterOptionWidgetPrivate</NAME>
typedef struct GtkPrinterOptionWidgetPrivate   GtkPrinterOptionWidgetPrivate;
</TYPEDEF>
<STRUCT>
<NAME>GtkPrinterOptionWidget</NAME>
struct _GtkPrinterOptionWidget
{
  GtkBox parent_instance;

  GtkPrinterOptionWidgetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrinterOptionWidgetClass</NAME>
struct _GtkPrinterOptionWidgetClass
{
  GtkBoxClass parent_class;

  void (*changed) (GtkPrinterOptionWidget *widget);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_printer_option_widget_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPrinterOption       *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_set_source</NAME>
<RETURNS>void</RETURNS>
GtkPrinterOptionWidget *setting, GtkPrinterOption       *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_has_external_label</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinterOptionWidget *setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_get_external_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPrinterOptionWidget *setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_get_value</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrinterOptionWidget *setting
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINT_JOB</NAME>
#define GTK_TYPE_PRINT_JOB                  (gtk_print_job_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_JOB</NAME>
#define GTK_PRINT_JOB(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_JOB, GtkPrintJob))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_JOB</NAME>
#define GTK_IS_PRINT_JOB(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_JOB))
</MACRO>
<USER_FUNCTION>
<NAME>GtkPrintJobCompleteFunc</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob  *print_job, gpointer      user_data, const GError *error
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_new</NAME>
<RETURNS>GtkPrintJob *</RETURNS>
const gchar              *title, GtkPrinter               *printer, GtkPrintSettings         *settings, GtkPageSetup             *page_setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_settings</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GtkPrintJob              *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_printer</NAME>
<RETURNS>GtkPrinter *</RETURNS>
GtkPrintJob              *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_title</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintJob              *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_status</NAME>
<RETURNS>GtkPrintStatus</RETURNS>
GtkPrintJob              *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_source_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintJob              *job, const gchar              *filename, GError                  **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_source_fd</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintJob              *job, int                       fd, GError                  **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_surface</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GtkPrintJob              *job, GError                  **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_track_print_status</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob              *job, gboolean                  track_status
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_track_print_status</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintJob              *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_send</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob              *job, GtkPrintJobCompleteFunc   callback, gpointer                  user_data, GDestroyNotify            dnotify
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_pages</NAME>
<RETURNS>GtkPrintPages</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_pages</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, GtkPrintPages      pages
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_page_ranges</NAME>
<RETURNS>GtkPageRange *</RETURNS>
GtkPrintJob       *job, gint              *n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_page_ranges</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, GtkPageRange      *ranges, gint               n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_page_set</NAME>
<RETURNS>GtkPageSet</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_page_set</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, GtkPageSet         page_set
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_num_copies</NAME>
<RETURNS>gint</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_num_copies</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, gint               num_copies
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_scale</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_scale</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, gdouble            scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_n_up</NAME>
<RETURNS>guint</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_n_up</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, guint              n_up
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_n_up_layout</NAME>
<RETURNS>GtkNumberUpLayout</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_n_up_layout</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, GtkNumberUpLayout  layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_rotate</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_rotate</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, gboolean           rotate
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_collate</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_collate</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, gboolean           collate
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_reverse</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_reverse</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, gboolean           reverse
</FUNCTION>
<STRUCT>
<NAME>GtkPrintJob</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_print_operation_portal_run_dialog</NAME>
<RETURNS>GtkPrintOperationResult</RETURNS>
GtkPrintOperation           *op, gboolean                     show_dialog, GtkWindow                   *parent, gboolean                    *do_print
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_portal_run_dialog_async</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation           *op, gboolean                     show_dialog, GtkWindow                   *parent, GtkPrintOperationPrintFunc   print_cb
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_portal_launch_preview</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation           *op, cairo_surface_t             *surface, GtkWindow                   *parent, const char                  *filename
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINT_OPERATION</NAME>
#define GTK_TYPE_PRINT_OPERATION                (gtk_print_operation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_OPERATION</NAME>
#define GTK_PRINT_OPERATION(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_OPERATION, GtkPrintOperation))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_OPERATION_CLASS</NAME>
#define GTK_PRINT_OPERATION_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_OPERATION, GtkPrintOperationClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_OPERATION</NAME>
#define GTK_IS_PRINT_OPERATION(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_OPERATION))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_OPERATION_CLASS</NAME>
#define GTK_IS_PRINT_OPERATION_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_OPERATION))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_OPERATION_GET_CLASS</NAME>
#define GTK_PRINT_OPERATION_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_OPERATION, GtkPrintOperationClass))
</MACRO>
<ENUM>
<NAME>GtkPrintStatus</NAME>
typedef enum {
  GTK_PRINT_STATUS_INITIAL,
  GTK_PRINT_STATUS_PREPARING,
  GTK_PRINT_STATUS_GENERATING_DATA,
  GTK_PRINT_STATUS_SENDING_DATA,
  GTK_PRINT_STATUS_PENDING,
  GTK_PRINT_STATUS_PENDING_ISSUE,
  GTK_PRINT_STATUS_PRINTING,
  GTK_PRINT_STATUS_FINISHED,
  GTK_PRINT_STATUS_FINISHED_ABORTED
} GtkPrintStatus;
</ENUM>
<ENUM>
<NAME>GtkPrintOperationResult</NAME>
typedef enum {
  GTK_PRINT_OPERATION_RESULT_ERROR,
  GTK_PRINT_OPERATION_RESULT_APPLY,
  GTK_PRINT_OPERATION_RESULT_CANCEL,
  GTK_PRINT_OPERATION_RESULT_IN_PROGRESS
} GtkPrintOperationResult;
</ENUM>
<ENUM>
<NAME>GtkPrintOperationAction</NAME>
typedef enum {
  GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
  GTK_PRINT_OPERATION_ACTION_PRINT,
  GTK_PRINT_OPERATION_ACTION_PREVIEW,
  GTK_PRINT_OPERATION_ACTION_EXPORT
} GtkPrintOperationAction;
</ENUM>
<STRUCT>
<NAME>GtkPrintOperation</NAME>
struct _GtkPrintOperation
{
  GObject parent_instance;

  /*< private >*/
  GtkPrintOperationPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrintOperationClass</NAME>
struct _GtkPrintOperationClass
{
  GObjectClass parent_class;

  /*< public >*/

  void     (*done)               (GtkPrintOperation *operation,
                                  GtkPrintOperationResult result);
  void     (*begin_print)        (GtkPrintOperation *operation,
                                  GtkPrintContext   *context);
  gboolean (*paginate)           (GtkPrintOperation *operation,
                                  GtkPrintContext   *context);
  void     (*request_page_setup) (GtkPrintOperation *operation,
                                  GtkPrintContext   *context,
                                  gint               page_nr,
                                  GtkPageSetup      *setup);
  void     (*draw_page)          (GtkPrintOperation *operation,
                                  GtkPrintContext   *context,
                                  gint               page_nr);
  void     (*end_print)          (GtkPrintOperation *operation,
                                  GtkPrintContext   *context);
  void     (*status_changed)     (GtkPrintOperation *operation);

  GtkWidget *(*create_custom_widget) (GtkPrintOperation *operation);
  void       (*custom_widget_apply)  (GtkPrintOperation *operation,
                                      GtkWidget         *widget);

  gboolean (*preview)        (GtkPrintOperation        *operation,
                              GtkPrintOperationPreview *preview,
                              GtkPrintContext          *context,
                              GtkWindow                *parent);

  void     (*update_custom_widget) (GtkPrintOperation *operation,
                                    GtkWidget         *widget,
                                    GtkPageSetup      *setup,
                                    GtkPrintSettings  *settings);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<MACRO>
<NAME>GTK_PRINT_ERROR</NAME>
#define GTK_PRINT_ERROR gtk_print_error_quark ()
</MACRO>
<ENUM>
<NAME>GtkPrintError</NAME>
typedef enum
{
  GTK_PRINT_ERROR_GENERAL,
  GTK_PRINT_ERROR_INTERNAL_ERROR,
  GTK_PRINT_ERROR_NOMEM,
  GTK_PRINT_ERROR_INVALID_FILE
} GtkPrintError;
</ENUM>
<FUNCTION>
<NAME>gtk_print_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_new</NAME>
<RETURNS>GtkPrintOperation *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_default_page_setup</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, GtkPageSetup       *default_page_setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_default_page_setup</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_print_settings</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, GtkPrintSettings   *print_settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_print_settings</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_job_name</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, const gchar        *job_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_n_pages</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gint                n_pages
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_current_page</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gint                current_page
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_use_full_page</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gboolean            full_page
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_unit</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_export_filename</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, const gchar        *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_track_print_status</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gboolean            track_status
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_show_progress</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gboolean            show_progress
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_allow_async</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gboolean            allow_async
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_custom_tab_label</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, const gchar        *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_run</NAME>
<RETURNS>GtkPrintOperationResult</RETURNS>
GtkPrintOperation  *op, GtkPrintOperationAction action, GtkWindow          *parent, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_error</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_status</NAME>
<RETURNS>GtkPrintStatus</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_status_string</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_is_finished</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_cancel</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_draw_page_finish</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_defer_drawing</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_support_selection</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gboolean            support_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_support_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_has_selection</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gboolean            has_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_has_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_embed_page_setup</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, gboolean            embed
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_embed_page_setup</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_get_n_pages_to_print</NAME>
<RETURNS>gint</RETURNS>
GtkPrintOperation  *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_run_page_setup_dialog</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GtkWindow          *parent, GtkPageSetup       *page_setup, GtkPrintSettings   *settings
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkPageSetupDoneFunc</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup *page_setup, gpointer      data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_print_run_page_setup_dialog_async</NAME>
<RETURNS>void</RETURNS>
GtkWindow            *parent, GtkPageSetup         *page_setup, GtkPrintSettings     *settings, GtkPageSetupDoneFunc  done_cb, gpointer              data
</FUNCTION>
<STRUCT>
<NAME>GtkPrintOperationPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_OPERATION_PREVIEW</NAME>
#define GTK_TYPE_PRINT_OPERATION_PREVIEW                  (gtk_print_operation_preview_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_OPERATION_PREVIEW</NAME>
#define GTK_PRINT_OPERATION_PREVIEW(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_OPERATION_PREVIEW, GtkPrintOperationPreview))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_OPERATION_PREVIEW</NAME>
#define GTK_IS_PRINT_OPERATION_PREVIEW(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_OPERATION_PREVIEW))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_OPERATION_PREVIEW_GET_IFACE</NAME>
#define GTK_PRINT_OPERATION_PREVIEW_GET_IFACE(obj)        (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_PRINT_OPERATION_PREVIEW, GtkPrintOperationPreviewIface))
</MACRO>
<STRUCT>
<NAME>GtkPrintOperationPreviewIface</NAME>
struct _GtkPrintOperationPreviewIface
{
  GTypeInterface g_iface;

  /* signals */
  void              (*ready)          (GtkPrintOperationPreview *preview,
				       GtkPrintContext          *context);
  void              (*got_page_size)  (GtkPrintOperationPreview *preview,
				       GtkPrintContext          *context,
				       GtkPageSetup             *page_setup);

  /* methods */
  void              (*render_page)    (GtkPrintOperationPreview *preview,
				       gint                      page_nr);
  gboolean          (*is_selected)    (GtkPrintOperationPreview *preview,
				       gint                      page_nr);
  void              (*end_preview)    (GtkPrintOperationPreview *preview);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
  void (*_gtk_reserved5) (void);
  void (*_gtk_reserved6) (void);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_print_operation_preview_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_preview_render_page</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperationPreview *preview, gint                      page_nr
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_preview_end_preview</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperationPreview *preview
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_preview_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintOperationPreview *preview, gint                      page_nr
</FUNCTION>
<STRUCT>
<NAME>GtkPrintOperationPreview</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_SETTINGS</NAME>
#define GTK_TYPE_PRINT_SETTINGS    (gtk_print_settings_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS</NAME>
#define GTK_PRINT_SETTINGS(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_SETTINGS, GtkPrintSettings))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_SETTINGS</NAME>
#define GTK_IS_PRINT_SETTINGS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_SETTINGS))
</MACRO>
<USER_FUNCTION>
<NAME>GtkPrintSettingsFunc</NAME>
<RETURNS>void</RETURNS>
const gchar *key, const gchar *value, gpointer     user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkPageRange</NAME>
struct _GtkPageRange
{
  gint start;
  gint end;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_print_settings_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_copy</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GtkPrintSettings     *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new_from_file</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
const gchar          *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_load_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, const gchar          *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, const gchar          *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new_from_key_file</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GKeyFile             *key_file, const gchar          *group_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_load_key_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, GKeyFile             *key_file, const gchar          *group_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_key_file</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, GKeyFile             *key_file, const gchar          *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_has_key</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, const gchar          *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_unset</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_foreach</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, GtkPrintSettingsFunc  func, gpointer              user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_bool</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_bool</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gboolean              value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_double</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_double_with_default</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gdouble               def
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_double</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gdouble               value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_length</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, GtkUnit               unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_length</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gdouble               value, GtkUnit               unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_int</NAME>
<RETURNS>gint</RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_int_with_default</NAME>
<RETURNS>gint</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gint                  def
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_int</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gint                  value
</FUNCTION>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PRINTER</NAME>
#define GTK_PRINT_SETTINGS_PRINTER          "printer"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_ORIENTATION</NAME>
#define GTK_PRINT_SETTINGS_ORIENTATION      "orientation"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAPER_FORMAT</NAME>
#define GTK_PRINT_SETTINGS_PAPER_FORMAT     "paper-format"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAPER_WIDTH</NAME>
#define GTK_PRINT_SETTINGS_PAPER_WIDTH      "paper-width"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAPER_HEIGHT</NAME>
#define GTK_PRINT_SETTINGS_PAPER_HEIGHT     "paper-height"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_N_COPIES</NAME>
#define GTK_PRINT_SETTINGS_N_COPIES         "n-copies"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_DEFAULT_SOURCE</NAME>
#define GTK_PRINT_SETTINGS_DEFAULT_SOURCE   "default-source"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_QUALITY</NAME>
#define GTK_PRINT_SETTINGS_QUALITY          "quality"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_RESOLUTION</NAME>
#define GTK_PRINT_SETTINGS_RESOLUTION       "resolution"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_USE_COLOR</NAME>
#define GTK_PRINT_SETTINGS_USE_COLOR        "use-color"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_DUPLEX</NAME>
#define GTK_PRINT_SETTINGS_DUPLEX           "duplex"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_COLLATE</NAME>
#define GTK_PRINT_SETTINGS_COLLATE          "collate"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_REVERSE</NAME>
#define GTK_PRINT_SETTINGS_REVERSE          "reverse"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_MEDIA_TYPE</NAME>
#define GTK_PRINT_SETTINGS_MEDIA_TYPE       "media-type"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_DITHER</NAME>
#define GTK_PRINT_SETTINGS_DITHER           "dither"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_SCALE</NAME>
#define GTK_PRINT_SETTINGS_SCALE            "scale"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PRINT_PAGES</NAME>
#define GTK_PRINT_SETTINGS_PRINT_PAGES      "print-pages"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAGE_RANGES</NAME>
#define GTK_PRINT_SETTINGS_PAGE_RANGES      "page-ranges"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAGE_SET</NAME>
#define GTK_PRINT_SETTINGS_PAGE_SET         "page-set"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_FINISHINGS</NAME>
#define GTK_PRINT_SETTINGS_FINISHINGS       "finishings"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_NUMBER_UP</NAME>
#define GTK_PRINT_SETTINGS_NUMBER_UP        "number-up"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT</NAME>
#define GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT "number-up-layout"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_BIN</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_BIN       "output-bin"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_RESOLUTION_X</NAME>
#define GTK_PRINT_SETTINGS_RESOLUTION_X     "resolution-x"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_RESOLUTION_Y</NAME>
#define GTK_PRINT_SETTINGS_RESOLUTION_Y     "resolution-y"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PRINTER_LPI</NAME>
#define GTK_PRINT_SETTINGS_PRINTER_LPI      "printer-lpi"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_DIR</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_DIR       "output-dir"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_BASENAME</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_BASENAME  "output-basename"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT  "output-file-format"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_URI</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_URI          "output-uri"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION</NAME>
#define GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION "win32-driver-version"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA</NAME>
#define GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA   "win32-driver-extra"
</MACRO>
<FUNCTION>
<NAME>gtk_print_settings_get_printer</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_printer</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const gchar        *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_orientation</NAME>
<RETURNS>GtkPageOrientation</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_orientation</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPageOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_paper_size</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_size</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPaperSize       *paper_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_paper_width</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintSettings   *settings, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_width</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gdouble             width, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_paper_height</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintSettings   *settings, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_height</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gdouble             height, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_use_color</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_use_color</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gboolean            use_color
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_collate</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_collate</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gboolean            collate
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_reverse</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_reverse</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gboolean            reverse
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_duplex</NAME>
<RETURNS>GtkPrintDuplex</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_duplex</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPrintDuplex      duplex
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_quality</NAME>
<RETURNS>GtkPrintQuality</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_quality</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPrintQuality     quality
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_n_copies</NAME>
<RETURNS>gint</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_n_copies</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gint                num_copies
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_number_up</NAME>
<RETURNS>gint</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_number_up</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gint                number_up
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_number_up_layout</NAME>
<RETURNS>GtkNumberUpLayout</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_number_up_layout</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkNumberUpLayout   number_up_layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution</NAME>
<RETURNS>gint</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_resolution</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gint                resolution
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution_x</NAME>
<RETURNS>gint</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution_y</NAME>
<RETURNS>gint</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_resolution_xy</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gint                resolution_x, gint                resolution_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_printer_lpi</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_printer_lpi</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gdouble             lpi
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_scale</NAME>
<RETURNS>gdouble</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_scale</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, gdouble             scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_print_pages</NAME>
<RETURNS>GtkPrintPages</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_print_pages</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPrintPages       pages
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_page_ranges</NAME>
<RETURNS>GtkPageRange *</RETURNS>
GtkPrintSettings   *settings, gint               *num_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_page_ranges</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPageRange       *page_ranges, gint                num_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_page_set</NAME>
<RETURNS>GtkPageSet</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_page_set</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPageSet          page_set
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_default_source</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_default_source</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const gchar        *default_source
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_media_type</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_media_type</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const gchar        *media_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_dither</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_dither</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const gchar        *dither
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_finishings</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_finishings</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const gchar        *finishings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_output_bin</NAME>
<RETURNS>const gchar *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_output_bin</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const gchar        *output_bin
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_gvariant</NAME>
<RETURNS>GVariant *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new_from_gvariant</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GVariant           *variant
</FUNCTION>
<STRUCT>
<NAME>GtkPrintSettings</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_UNIX_DIALOG</NAME>
#define GTK_TYPE_PRINT_UNIX_DIALOG                  (gtk_print_unix_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_UNIX_DIALOG</NAME>
#define GTK_PRINT_UNIX_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_UNIX_DIALOG, GtkPrintUnixDialog))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_UNIX_DIALOG</NAME>
#define GTK_IS_PRINT_UNIX_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_UNIX_DIALOG))
</MACRO>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar *title, GtkWindow   *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_page_setup</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog *dialog, GtkPageSetup       *page_setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_page_setup</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_current_page</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog *dialog, gint                current_page
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_current_page</NAME>
<RETURNS>gint</RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_settings</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog *dialog, GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_settings</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_selected_printer</NAME>
<RETURNS>GtkPrinter *</RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_add_custom_tab</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog *dialog, GtkWidget          *child, GtkWidget          *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_manual_capabilities</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog *dialog, GtkPrintCapabilities capabilities
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_manual_capabilities</NAME>
<RETURNS>GtkPrintCapabilities</RETURNS>
GtkPrintUnixDialog  *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_support_selection</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog  *dialog, gboolean             support_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_support_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintUnixDialog  *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_has_selection</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog  *dialog, gboolean             has_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_has_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintUnixDialog  *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_embed_page_setup</NAME>
<RETURNS>void</RETURNS>
GtkPrintUnixDialog *dialog, gboolean            embed
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_embed_page_setup</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_page_setup_set</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<STRUCT>
<NAME>GtkPrintUnixDialog</NAME>
</STRUCT>
<MACRO>
<NAME>MM_PER_INCH</NAME>
#define MM_PER_INCH 25.4
</MACRO>
<MACRO>
<NAME>POINTS_PER_INCH</NAME>
#define POINTS_PER_INCH 72
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PROGRESS_BAR</NAME>
#define GTK_TYPE_PROGRESS_BAR            (gtk_progress_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PROGRESS_BAR</NAME>
#define GTK_PROGRESS_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PROGRESS_BAR, GtkProgressBar))
</MACRO>
<MACRO>
<NAME>GTK_IS_PROGRESS_BAR</NAME>
#define GTK_IS_PROGRESS_BAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PROGRESS_BAR))
</MACRO>
<FUNCTION>
<NAME>gtk_progress_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_pulse</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_text</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar *pbar, const gchar    *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_fraction</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar *pbar, gdouble         fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_pulse_step</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar *pbar, gdouble         fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_inverted</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar *pbar, gboolean        inverted
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_fraction</NAME>
<RETURNS>gdouble</RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_pulse_step</NAME>
<RETURNS>gdouble</RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_inverted</NAME>
<RETURNS>gboolean</RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_ellipsize</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar     *pbar, PangoEllipsizeMode  mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_ellipsize</NAME>
<RETURNS>PangoEllipsizeMode</RETURNS>
GtkProgressBar     *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_show_text</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar     *pbar, gboolean            show_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_show_text</NAME>
<RETURNS>gboolean</RETURNS>
GtkProgressBar     *pbar
</FUNCTION>
<STRUCT>
<NAME>GtkProgressBar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL</NAME>
#define GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL         (gtk_property_lookup_list_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PROPERTY_LOOKUP_LIST_MODEL</NAME>
#define GTK_PROPERTY_LOOKUP_LIST_MODEL(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL, GtkPropertyLookupListModel))
</MACRO>
<MACRO>
<NAME>GTK_PROPERTY_LOOKUP_LIST_MODEL_CLASS</NAME>
#define GTK_PROPERTY_LOOKUP_LIST_MODEL_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL, GtkPropertyLookupListModelClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PROPERTY_LOOKUP_LIST_MODEL</NAME>
#define GTK_IS_PROPERTY_LOOKUP_LIST_MODEL(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_IS_PROPERTY_LOOKUP_LIST_MODEL_CLASS</NAME>
#define GTK_IS_PROPERTY_LOOKUP_LIST_MODEL_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_PROPERTY_LOOKUP_LIST_MODEL_GET_CLASS</NAME>
#define GTK_PROPERTY_LOOKUP_LIST_MODEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL, GtkPropertyLookupListModelClass))
</MACRO>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_new</NAME>
<RETURNS>GtkPropertyLookupListModel *</RETURNS>
GType                           item_type, const char                     *property_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_set_object</NAME>
<RETURNS>void</RETURNS>
GtkPropertyLookupListModel     *self, gpointer                        object
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_get_object</NAME>
<RETURNS>gpointer</RETURNS>
GtkPropertyLookupListModel     *self
</FUNCTION>
<STRUCT>
<NAME>GtkPropertyLookupListModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPropertyLookupListModelClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_QUERY</NAME>
#define GTK_TYPE_QUERY          (gtk_query_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_QUERY</NAME>
#define GTK_QUERY(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_QUERY, GtkQuery))
</MACRO>
<MACRO>
<NAME>GTK_QUERY_CLASS</NAME>
#define GTK_QUERY_CLASS(klass)  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_QUERY, GtkQueryClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_QUERY</NAME>
#define GTK_IS_QUERY(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_QUERY))
</MACRO>
<MACRO>
<NAME>GTK_IS_QUERY_CLASS</NAME>
#define GTK_IS_QUERY_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_QUERY))
</MACRO>
<MACRO>
<NAME>GTK_QUERY_GET_CLASS</NAME>
#define GTK_QUERY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_QUERY, GtkQueryClass))
</MACRO>
<STRUCT>
<NAME>GtkQuery</NAME>
struct _GtkQuery
{
  GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkQueryClass</NAME>
struct _GtkQueryClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_query_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_new</NAME>
<RETURNS>GtkQuery *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_get_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkQuery    *query
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_set_text</NAME>
<RETURNS>void</RETURNS>
GtkQuery    *query, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_get_location</NAME>
<RETURNS>GFile *</RETURNS>
GtkQuery    *query
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_set_location</NAME>
<RETURNS>void</RETURNS>
GtkQuery    *query, GFile       *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_matches_string</NAME>
<RETURNS>gboolean</RETURNS>
GtkQuery    *query, const gchar *string
</FUNCTION>
<STRUCT>
<NAME>GtkQueryPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RADIO_BUTTON</NAME>
#define GTK_TYPE_RADIO_BUTTON		       (gtk_radio_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RADIO_BUTTON</NAME>
#define GTK_RADIO_BUTTON(obj)		       (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_BUTTON, GtkRadioButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_BUTTON</NAME>
#define GTK_IS_RADIO_BUTTON(obj)	       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_BUTTON))
</MACRO>
<FUNCTION>
<NAME>gtk_radio_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GSList         *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_from_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkRadioButton *radio_group_member
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
GSList         *group, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_label_from_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkRadioButton *radio_group_member, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
GSList         *group, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_mnemonic_from_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkRadioButton *radio_group_member, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_get_group</NAME>
<RETURNS>GSList *</RETURNS>
GtkRadioButton *radio_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_set_group</NAME>
<RETURNS>void</RETURNS>
GtkRadioButton *radio_button, GSList         *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_join_group</NAME>
<RETURNS>void</RETURNS>
GtkRadioButton        *radio_button, GtkRadioButton        *group_source
</FUNCTION>
<STRUCT>
<NAME>GtkRadioButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RANGE</NAME>
#define GTK_TYPE_RANGE            (gtk_range_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RANGE</NAME>
#define GTK_RANGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RANGE, GtkRange))
</MACRO>
<MACRO>
<NAME>GTK_RANGE_CLASS</NAME>
#define GTK_RANGE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RANGE, GtkRangeClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RANGE</NAME>
#define GTK_IS_RANGE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RANGE))
</MACRO>
<MACRO>
<NAME>GTK_IS_RANGE_CLASS</NAME>
#define GTK_IS_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RANGE))
</MACRO>
<MACRO>
<NAME>GTK_RANGE_GET_CLASS</NAME>
#define GTK_RANGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RANGE, GtkRangeClass))
</MACRO>
<STRUCT>
<NAME>GtkRange</NAME>
struct _GtkRange
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkRangeClass</NAME>
struct _GtkRangeClass
{
  GtkWidgetClass parent_class;

  void (* value_changed)    (GtkRange     *range);
  void (* adjust_bounds)    (GtkRange     *range,
                             gdouble	   new_value);

  /* action signals for keybindings */
  void (* move_slider)      (GtkRange     *range,
                             GtkScrollType scroll);

  /* Virtual functions */
  void (* get_range_border) (GtkRange     *range,
                             GtkBorder    *border_);

  gboolean (* change_value) (GtkRange     *range,
                             GtkScrollType scroll,
                             gdouble       new_value);

  /*< private > */

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_range_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_adjustment</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, GtkAdjustment *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_adjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_inverted</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_inverted</NAME>
<RETURNS>gboolean</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_flippable</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gboolean       flippable
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_flippable</NAME>
<RETURNS>gboolean</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_slider_size_fixed</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gboolean       size_fixed
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_slider_size_fixed</NAME>
<RETURNS>gboolean</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_range_rect</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, GdkRectangle  *range_rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_slider_range</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gint          *slider_start, gint          *slider_end
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_increments</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gdouble        step, gdouble        page
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_range</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gdouble        min, gdouble        max
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_value</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gdouble        value
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_value</NAME>
<RETURNS>gdouble</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_show_fill_level</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gboolean       show_fill_level
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_show_fill_level</NAME>
<RETURNS>gboolean</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_restrict_to_fill_level</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gboolean       restrict_to_fill_level
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_restrict_to_fill_level</NAME>
<RETURNS>gboolean</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_fill_level</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gdouble        fill_level
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_fill_level</NAME>
<RETURNS>gdouble</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_round_digits</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, gint           round_digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_round_digits</NAME>
<RETURNS>gint</RETURNS>
GtkRange      *range
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_RECENT_INFO</NAME>
#define GTK_TYPE_RECENT_INFO			(gtk_recent_info_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_RECENT_MANAGER</NAME>
#define GTK_TYPE_RECENT_MANAGER			(gtk_recent_manager_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RECENT_MANAGER</NAME>
#define GTK_RECENT_MANAGER(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RECENT_MANAGER, GtkRecentManager))
</MACRO>
<MACRO>
<NAME>GTK_IS_RECENT_MANAGER</NAME>
#define GTK_IS_RECENT_MANAGER(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RECENT_MANAGER))
</MACRO>
<MACRO>
<NAME>GTK_RECENT_MANAGER_CLASS</NAME>
#define GTK_RECENT_MANAGER_CLASS(klass) 	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RECENT_MANAGER, GtkRecentManagerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RECENT_MANAGER_CLASS</NAME>
#define GTK_IS_RECENT_MANAGER_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RECENT_MANAGER))
</MACRO>
<MACRO>
<NAME>GTK_RECENT_MANAGER_GET_CLASS</NAME>
#define GTK_RECENT_MANAGER_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RECENT_MANAGER, GtkRecentManagerClass))
</MACRO>
<STRUCT>
<NAME>GtkRecentData</NAME>
struct _GtkRecentData
{
  gchar *display_name;
  gchar *description;

  gchar *mime_type;

  gchar *app_name;
  gchar *app_exec;

  gchar **groups;

  gboolean is_private;
};
</STRUCT>
<STRUCT>
<NAME>GtkRecentManager</NAME>
struct _GtkRecentManager
{
  /*< private >*/
  GObject parent_instance;

  GtkRecentManagerPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkRecentManagerClass</NAME>
struct _GtkRecentManagerClass
{
  /*< private >*/
  GObjectClass parent_class;

  void (*changed) (GtkRecentManager *manager);

  /* padding for future expansion */
  void (*_gtk_recent1) (void);
  void (*_gtk_recent2) (void);
  void (*_gtk_recent3) (void);
  void (*_gtk_recent4) (void);
};
</STRUCT>
<ENUM>
<NAME>GtkRecentManagerError</NAME>
typedef enum
{
  GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
  GTK_RECENT_MANAGER_ERROR_INVALID_URI,
  GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
  GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
  GTK_RECENT_MANAGER_ERROR_READ,
  GTK_RECENT_MANAGER_ERROR_WRITE,
  GTK_RECENT_MANAGER_ERROR_UNKNOWN
} GtkRecentManagerError;
</ENUM>
<MACRO>
<NAME>GTK_RECENT_MANAGER_ERROR</NAME>
#define GTK_RECENT_MANAGER_ERROR	(gtk_recent_manager_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gtk_recent_manager_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_new</NAME>
<RETURNS>GtkRecentManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_get_default</NAME>
<RETURNS>GtkRecentManager *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_add_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const gchar          *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_add_full</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const gchar          *uri, const GtkRecentData  *recent_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_remove_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const gchar          *uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_lookup_item</NAME>
<RETURNS>GtkRecentInfo *</RETURNS>
GtkRecentManager     *manager, const gchar          *uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_has_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const gchar          *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_move_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const gchar          *uri, const gchar          *new_uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_get_items</NAME>
<RETURNS>GList *</RETURNS>
GtkRecentManager     *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_purge_items</NAME>
<RETURNS>gint</RETURNS>
GtkRecentManager     *manager, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_ref</NAME>
<RETURNS>GtkRecentInfo *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_unref</NAME>
<RETURNS>void</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_uri</NAME>
<RETURNS>const gchar *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_display_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_description</NAME>
<RETURNS>const gchar *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_mime_type</NAME>
<RETURNS>const gchar *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_added</NAME>
<RETURNS>time_t</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_modified</NAME>
<RETURNS>time_t</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_visited</NAME>
<RETURNS>time_t</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_private_hint</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_application_info</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info, const gchar    *app_name, const gchar   **app_exec, guint          *count, time_t         *time_
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_create_app_info</NAME>
<RETURNS>GAppInfo *</RETURNS>
GtkRecentInfo  *info, const gchar    *app_name, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_applications</NAME>
<RETURNS>gchar **</RETURNS>
GtkRecentInfo  *info, gsize          *length
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_last_application</NAME>
<RETURNS>gchar *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_has_application</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info, const gchar    *app_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_groups</NAME>
<RETURNS>gchar **</RETURNS>
GtkRecentInfo  *info, gsize          *length
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_has_group</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info, const gchar    *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_gicon</NAME>
<RETURNS>GIcon *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_short_name</NAME>
<RETURNS>gchar *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_uri_display</NAME>
<RETURNS>gchar *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_age</NAME>
<RETURNS>gint</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_is_local</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_exists</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_match</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info_a, GtkRecentInfo  *info_b
</FUNCTION>
<STRUCT>
<NAME>GtkRecentInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRecentManagerPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_render_check</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_option</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_arrow</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              angle, gdouble              x, gdouble              y, gdouble              size
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_background</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_frame</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_expander</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_focus</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_layout</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, PangoLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_line</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x0, gdouble              y0, gdouble              x1, gdouble              y1
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_slider</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height, GtkOrientation       orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_handle</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_activity</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_icon</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, GdkTexture          *texture, gdouble              x, gdouble              y
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_REVEALER</NAME>
#define GTK_TYPE_REVEALER (gtk_revealer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_REVEALER</NAME>
#define GTK_REVEALER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_REVEALER, GtkRevealer))
</MACRO>
<MACRO>
<NAME>GTK_IS_REVEALER</NAME>
#define GTK_IS_REVEALER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_REVEALER))
</MACRO>
<ENUM>
<NAME>GtkRevealerTransitionType</NAME>
typedef enum {
  GTK_REVEALER_TRANSITION_TYPE_NONE,
  GTK_REVEALER_TRANSITION_TYPE_CROSSFADE,
  GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT,
  GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT,
  GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP,
  GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN,
  GTK_REVEALER_TRANSITION_TYPE_SWING_RIGHT,
  GTK_REVEALER_TRANSITION_TYPE_SWING_LEFT,
  GTK_REVEALER_TRANSITION_TYPE_SWING_UP,
  GTK_REVEALER_TRANSITION_TYPE_SWING_DOWN
} GtkRevealerTransitionType;
</ENUM>
<FUNCTION>
<NAME>gtk_revealer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_get_reveal_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkRevealer               *revealer
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_set_reveal_child</NAME>
<RETURNS>void</RETURNS>
GtkRevealer               *revealer, gboolean                   reveal_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_get_child_revealed</NAME>
<RETURNS>gboolean</RETURNS>
GtkRevealer               *revealer
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_get_transition_duration</NAME>
<RETURNS>guint</RETURNS>
GtkRevealer               *revealer
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_set_transition_duration</NAME>
<RETURNS>void</RETURNS>
GtkRevealer               *revealer, guint                      duration
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_set_transition_type</NAME>
<RETURNS>void</RETURNS>
GtkRevealer               *revealer, GtkRevealerTransitionType  transition
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_get_transition_type</NAME>
<RETURNS>GtkRevealerTransitionType</RETURNS>
GtkRevealer               *revealer
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_set_child</NAME>
<RETURNS>void</RETURNS>
GtkRevealer               *revealer, GtkWidget                 *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_revealer_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkRevealer               *revealer
</FUNCTION>
<STRUCT>
<NAME>GtkRevealer</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ROOT</NAME>
#define GTK_TYPE_ROOT               (gtk_root_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_root_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GtkRoot *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_set_focus</NAME>
<RETURNS>void</RETURNS>
GtkRoot   *self, GtkWidget *focus
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_get_focus</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkRoot   *self
</FUNCTION>
<STRUCT>
<NAME>GtkRoot</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRootInterface</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRootInterface</NAME>
struct _GtkRootInterface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/
  GdkDisplay * (* get_display)  (GtkRoot *self);

  GtkConstraintSolver * (* get_constraint_solver) (GtkRoot *self);

  GtkWidget *  (* get_focus)    (GtkRoot   *self);
  void         (* set_focus)    (GtkRoot   *self,
                                 GtkWidget *focus);

};
</STRUCT>
<FUNCTION>
<NAME>gtk_root_get_constraint_solver</NAME>
<RETURNS>GtkConstraintSolver *</RETURNS>
GtkRoot *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_start_layout</NAME>
<RETURNS>void</RETURNS>
GtkRoot *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_stop_layout</NAME>
<RETURNS>void</RETURNS>
GtkRoot *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_queue_restyle</NAME>
<RETURNS>void</RETURNS>
GtkRoot *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SCALE</NAME>
#define GTK_TYPE_SCALE            (gtk_scale_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCALE</NAME>
#define GTK_SCALE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE, GtkScale))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_CLASS</NAME>
#define GTK_SCALE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE, GtkScaleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE</NAME>
#define GTK_IS_SCALE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_CLASS</NAME>
#define GTK_IS_SCALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_GET_CLASS</NAME>
#define GTK_SCALE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE, GtkScaleClass))
</MACRO>
<STRUCT>
<NAME>GtkScale</NAME>
struct _GtkScale
{
  GtkRange parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleClass</NAME>
struct _GtkScaleClass
{
  GtkRangeClass parent_class;

  void (* get_layout_offsets) (GtkScale *scale,
                               gint     *x,
                               gint     *y);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<USER_FUNCTION>
<NAME>GtkScaleFormatValueFunc</NAME>
<RETURNS>char *</RETURNS>
GtkScale *scale, double    value, gpointer  user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkOrientation   orientation, GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_new_with_range</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkOrientation   orientation, gdouble          min, gdouble          max, gdouble          step
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_digits</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, gint             digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_digits</NAME>
<RETURNS>gint</RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_draw_value</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, gboolean         draw_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_draw_value</NAME>
<RETURNS>gboolean</RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_has_origin</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, gboolean         has_origin
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_has_origin</NAME>
<RETURNS>gboolean</RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_value_pos</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, GtkPositionType  pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_value_pos</NAME>
<RETURNS>GtkPositionType</RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_layout_offsets</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, gint            *x, gint            *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_add_mark</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, gdouble          value, GtkPositionType  position, const gchar     *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_clear_marks</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_format_value_func</NAME>
<RETURNS>void</RETURNS>
GtkScale                *scale, GtkScaleFormatValueFunc  func, gpointer                 user_data, GDestroyNotify           destroy_notify
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SCALE_BUTTON</NAME>
#define GTK_TYPE_SCALE_BUTTON                 (gtk_scale_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON</NAME>
#define GTK_SCALE_BUTTON(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_BUTTON, GtkScaleButton))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON_CLASS</NAME>
#define GTK_SCALE_BUTTON_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_BUTTON, GtkScaleButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_BUTTON</NAME>
#define GTK_IS_SCALE_BUTTON(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_BUTTON_CLASS</NAME>
#define GTK_IS_SCALE_BUTTON_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON_GET_CLASS</NAME>
#define GTK_SCALE_BUTTON_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE_BUTTON, GtkScaleButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkScaleButton</NAME>
struct _GtkScaleButton
{
  GtkButton parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleButtonClass</NAME>
struct _GtkScaleButtonClass
{
  GtkButtonClass parent_class;

  /* signals */
  void	(* value_changed) (GtkScaleButton *button,
                           gdouble         value);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scale_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
gdouble          min, gdouble          max, gdouble          step, const gchar    **icons
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_set_icons</NAME>
<RETURNS>void</RETURNS>
GtkScaleButton  *button, const gchar    **icons
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_get_value</NAME>
<RETURNS>gdouble</RETURNS>
GtkScaleButton  *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_set_value</NAME>
<RETURNS>void</RETURNS>
GtkScaleButton  *button, gdouble          value
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_get_adjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkScaleButton  *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_set_adjustment</NAME>
<RETURNS>void</RETURNS>
GtkScaleButton  *button, GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_get_plus_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkScaleButton  *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_get_minus_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkScaleButton  *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_get_popup</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkScaleButton  *button
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SCROLLABLE</NAME>
#define GTK_TYPE_SCROLLABLE            (gtk_scrollable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCROLLABLE</NAME>
#define GTK_SCROLLABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj),     GTK_TYPE_SCROLLABLE, GtkScrollable))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLABLE</NAME>
#define GTK_IS_SCROLLABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj),     GTK_TYPE_SCROLLABLE))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLABLE_GET_IFACE</NAME>
#define GTK_SCROLLABLE_GET_IFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_SCROLLABLE, GtkScrollableInterface))
</MACRO>
<STRUCT>
<NAME>GtkScrollableInterface</NAME>
struct _GtkScrollableInterface
{
  GTypeInterface base_iface;

  gboolean (* get_border) (GtkScrollable *scrollable,
                           GtkBorder     *border);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scrollable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_hadjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_hadjustment</NAME>
<RETURNS>void</RETURNS>
GtkScrollable       *scrollable, GtkAdjustment       *hadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_vadjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_vadjustment</NAME>
<RETURNS>void</RETURNS>
GtkScrollable       *scrollable, GtkAdjustment       *vadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_hscroll_policy</NAME>
<RETURNS>GtkScrollablePolicy</RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_hscroll_policy</NAME>
<RETURNS>void</RETURNS>
GtkScrollable       *scrollable, GtkScrollablePolicy  policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_vscroll_policy</NAME>
<RETURNS>GtkScrollablePolicy</RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_vscroll_policy</NAME>
<RETURNS>void</RETURNS>
GtkScrollable       *scrollable, GtkScrollablePolicy  policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_border</NAME>
<RETURNS>gboolean</RETURNS>
GtkScrollable       *scrollable, GtkBorder           *border
</FUNCTION>
<STRUCT>
<NAME>GtkScrollable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCROLLBAR</NAME>
#define GTK_TYPE_SCROLLBAR            (gtk_scrollbar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCROLLBAR</NAME>
#define GTK_SCROLLBAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLBAR, GtkScrollbar))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLBAR</NAME>
#define GTK_IS_SCROLLBAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLBAR))
</MACRO>
<FUNCTION>
<NAME>gtk_scrollbar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollbar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkOrientation  orientation, GtkAdjustment  *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollbar_set_adjustment</NAME>
<RETURNS>void</RETURNS>
GtkScrollbar  *self, GtkAdjustment *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollbar_get_adjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkScrollbar  *self
</FUNCTION>
<STRUCT>
<NAME>GtkScrollbar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCROLLED_WINDOW</NAME>
#define GTK_TYPE_SCROLLED_WINDOW            (gtk_scrolled_window_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW</NAME>
#define GTK_SCROLLED_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindow))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLED_WINDOW</NAME>
#define GTK_IS_SCROLLED_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLED_WINDOW))
</MACRO>
<ENUM>
<NAME>GtkCornerType</NAME>
typedef enum
{
  GTK_CORNER_TOP_LEFT,
  GTK_CORNER_BOTTOM_LEFT,
  GTK_CORNER_TOP_RIGHT,
  GTK_CORNER_BOTTOM_RIGHT
} GtkCornerType;
</ENUM>
<ENUM>
<NAME>GtkPolicyType</NAME>
typedef enum
{
  GTK_POLICY_ALWAYS,
  GTK_POLICY_AUTOMATIC,
  GTK_POLICY_NEVER,
  GTK_POLICY_EXTERNAL
} GtkPolicyType;
</ENUM>
<FUNCTION>
<NAME>gtk_scrolled_window_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAdjustment     *hadjustment, GtkAdjustment     *vadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_hadjustment</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, GtkAdjustment     *hadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_vadjustment</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, GtkAdjustment     *vadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_hadjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_vadjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_hscrollbar</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_vscrollbar</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_policy</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, GtkPolicyType      hscrollbar_policy, GtkPolicyType      vscrollbar_policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_policy</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, GtkPolicyType     *hscrollbar_policy, GtkPolicyType     *vscrollbar_policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_placement</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, GtkCornerType      window_placement
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_unset_placement</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_placement</NAME>
<RETURNS>GtkCornerType</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_has_frame</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           has_frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_has_frame</NAME>
<RETURNS>gboolean</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_min_content_width</NAME>
<RETURNS>gint</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_min_content_width</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gint               width
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_min_content_height</NAME>
<RETURNS>gint</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_min_content_height</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gint               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_kinetic_scrolling</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           kinetic_scrolling
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_kinetic_scrolling</NAME>
<RETURNS>gboolean</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_capture_button_press</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           capture_button_press
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_capture_button_press</NAME>
<RETURNS>gboolean</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_overlay_scrolling</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           overlay_scrolling
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_overlay_scrolling</NAME>
<RETURNS>gboolean</RETURNS>
GtkScrolledWindow   *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_max_content_width</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gint               width
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_max_content_width</NAME>
<RETURNS>gint</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_max_content_height</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gint               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_max_content_height</NAME>
<RETURNS>gint</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_propagate_natural_width</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           propagate
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_propagate_natural_width</NAME>
<RETURNS>gboolean</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_propagate_natural_height</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           propagate
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_propagate_natural_height</NAME>
<RETURNS>gboolean</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_child</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, GtkWidget         *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<STRUCT>
<NAME>GtkScrolledWindow</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_BAR</NAME>
#define GTK_TYPE_SEARCH_BAR                 (gtk_search_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_BAR</NAME>
#define GTK_SEARCH_BAR(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_BAR, GtkSearchBar))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_BAR</NAME>
#define GTK_IS_SEARCH_BAR(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_BAR))
</MACRO>
<FUNCTION>
<NAME>gtk_search_bar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_connect_entry</NAME>
<RETURNS>void</RETURNS>
GtkSearchBar *bar, GtkEditable  *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_get_search_mode</NAME>
<RETURNS>gboolean</RETURNS>
GtkSearchBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_set_search_mode</NAME>
<RETURNS>void</RETURNS>
GtkSearchBar *bar, gboolean      search_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_get_show_close_button</NAME>
<RETURNS>gboolean</RETURNS>
GtkSearchBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_set_show_close_button</NAME>
<RETURNS>void</RETURNS>
GtkSearchBar *bar, gboolean      visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_set_key_capture_widget</NAME>
<RETURNS>void</RETURNS>
GtkSearchBar *bar, GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_get_key_capture_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkSearchBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_set_child</NAME>
<RETURNS>void</RETURNS>
GtkSearchBar *bar, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_bar_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkSearchBar *bar
</FUNCTION>
<STRUCT>
<NAME>GtkSearchBar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENGINE</NAME>
#define GTK_TYPE_SEARCH_ENGINE		(_gtk_search_engine_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE</NAME>
#define GTK_SEARCH_ENGINE(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENGINE, GtkSearchEngine))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_CLASS</NAME>
#define GTK_SEARCH_ENGINE_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENGINE, GtkSearchEngineClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE</NAME>
#define GTK_IS_SEARCH_ENGINE(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENGINE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_CLASS</NAME>
#define GTK_IS_SEARCH_ENGINE_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENGINE))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_GET_CLASS</NAME>
#define GTK_SEARCH_ENGINE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENGINE, GtkSearchEngineClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchHit</NAME>
struct _GtkSearchHit
{
  GFile *file;
  GFileInfo *info; /* may be NULL */
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngine</NAME>
struct _GtkSearchEngine
{
  GObject parent;

  GtkSearchEnginePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineClass</NAME>
struct _GtkSearchEngineClass 
{
  GObjectClass parent_class;
  
  /* VTable */
  void     (*set_query)       (GtkSearchEngine *engine, 
			       GtkQuery        *query);
  void     (*start)           (GtkSearchEngine *engine);
  void     (*stop)            (GtkSearchEngine *engine);
  
  /* Signals */
  void     (*hits_added)      (GtkSearchEngine *engine, 
			       GList           *hits);
  void     (*finished)        (GtkSearchEngine *engine);
  void     (*error)           (GtkSearchEngine *engine, 
			       const gchar     *error_message);
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEnginePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENGINE_MODEL</NAME>
#define GTK_TYPE_SEARCH_ENGINE_MODEL		(_gtk_search_engine_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_MODEL</NAME>
#define GTK_SEARCH_ENGINE_MODEL(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENGINE_MODEL, GtkSearchEngineModel))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_MODEL_CLASS</NAME>
#define GTK_SEARCH_ENGINE_MODEL_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENGINE_MODEL, GtkSearchEngineModelClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_MODEL</NAME>
#define GTK_IS_SEARCH_ENGINE_MODEL(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENGINE_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_MODEL_CLASS</NAME>
#define GTK_IS_SEARCH_ENGINE_MODEL_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENGINE_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_MODEL_GET_CLASS</NAME>
#define GTK_SEARCH_ENGINE_MODEL_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENGINE_MODEL, GtkSearchEngineModelClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchEngineModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineModelClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENGINE_QUARTZ</NAME>
#define GTK_TYPE_SEARCH_ENGINE_QUARTZ			(_gtk_search_engine_quartz_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_QUARTZ</NAME>
#define GTK_SEARCH_ENGINE_QUARTZ(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENGINE_QUARTZ, GtkSearchEngineQuartz))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_QUARTZ_CLASS</NAME>
#define GTK_SEARCH_ENGINE_QUARTZ_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENGINE_QUARTZ, GtkSearchEngineQuartzClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_QUARTZ</NAME>
#define GTK_IS_SEARCH_ENGINE_QUARTZ(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENGINE_QUARTZ))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_QUARTZ_CLASS</NAME>
#define GTK_IS_SEARCH_ENGINE_QUARTZ_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENGINE_QUARTZ))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_QUARTZ_GET_CLASS</NAME>
#define GTK_SEARCH_ENGINE_QUARTZ_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENGINE_QUARTZ, GtkSearchEngineQuartzClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchEngineQuartz</NAME>
struct _GtkSearchEngineQuartz
{
  GtkSearchEngine parent;

  GtkSearchEngineQuartzPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineQuartzClass</NAME>
struct _GtkSearchEngineQuartzClass
{
  GtkSearchEngineClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineQuartzPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENGINE_TRACKER</NAME>
#define GTK_TYPE_SEARCH_ENGINE_TRACKER		(_gtk_search_engine_tracker_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_TRACKER</NAME>
#define GTK_SEARCH_ENGINE_TRACKER(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTracker))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_TRACKER_CLASS</NAME>
#define GTK_SEARCH_ENGINE_TRACKER_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTrackerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_TRACKER</NAME>
#define GTK_IS_SEARCH_ENGINE_TRACKER(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENGINE_TRACKER))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_TRACKER_CLASS</NAME>
#define GTK_IS_SEARCH_ENGINE_TRACKER_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENGINE_TRACKER))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_TRACKER_GET_CLASS</NAME>
#define GTK_SEARCH_ENGINE_TRACKER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTrackerClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchEngineTracker</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineTrackerClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENTRY</NAME>
#define GTK_TYPE_SEARCH_ENTRY                 (gtk_search_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENTRY</NAME>
#define GTK_SEARCH_ENTRY(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENTRY, GtkSearchEntry))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENTRY</NAME>
#define GTK_IS_SEARCH_ENTRY(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENTRY))
</MACRO>
<FUNCTION>
<NAME>gtk_search_entry_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_entry_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_entry_set_key_capture_widget</NAME>
<RETURNS>void</RETURNS>
GtkSearchEntry *entry, GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_search_entry_get_key_capture_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkSearchEntry *entry
</FUNCTION>
<STRUCT>
<NAME>GtkSearchEntry</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SELECTION_MODEL</NAME>
#define GTK_TYPE_SELECTION_MODEL       (gtk_selection_model_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkSelectionModelInterface</NAME>
struct _GtkSelectionModelInterface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/
  gboolean              (* is_selected)                         (GtkSelectionModel      *model,
                                                                 guint                   position);

  gboolean              (* select_item)                         (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 gboolean                exclusive);
  gboolean              (* unselect_item)                       (GtkSelectionModel      *model,
                                                                 guint                   position);
  gboolean              (* select_range)                        (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                   n_items,
                                                                 gboolean                exclusive);
  gboolean              (* unselect_range)                      (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                   n_items);
  gboolean              (* select_all)                          (GtkSelectionModel      *model);
  gboolean              (* unselect_all)                        (GtkSelectionModel      *model);
  void                  (* query_range)                         (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                  *start_range,
                                                                 guint                  *n_items,
                                                                 gboolean               *selected);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_selection_model_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_select_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, guint                   position, gboolean                exclusive
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_unselect_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_select_range</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, guint                   position, guint                   n_items, gboolean                exclusive
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_unselect_range</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, guint                   position, guint                   n_items
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_select_all</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_unselect_all</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_query_range</NAME>
<RETURNS>void</RETURNS>
GtkSelectionModel      *model, guint                   position, guint                  *start_range, guint                  *n_items, gboolean               *selected
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_selection_changed</NAME>
<RETURNS>void</RETURNS>
GtkSelectionModel      *model, guint                   position, guint                   n_items
</FUNCTION>
<STRUCT>
<NAME>GtkSelectionModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEPARATOR</NAME>
#define GTK_TYPE_SEPARATOR                  (gtk_separator_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR</NAME>
#define GTK_SEPARATOR(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR, GtkSeparator))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEPARATOR</NAME>
#define GTK_IS_SEPARATOR(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR))
</MACRO>
<FUNCTION>
<NAME>gtk_separator_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_separator_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkOrientation orientation
</FUNCTION>
<STRUCT>
<NAME>GtkSeparator</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SETTINGS</NAME>
#define GTK_TYPE_SETTINGS             (gtk_settings_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SETTINGS</NAME>
#define GTK_SETTINGS(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SETTINGS, GtkSettings))
</MACRO>
<MACRO>
<NAME>GTK_IS_SETTINGS</NAME>
#define GTK_IS_SETTINGS(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SETTINGS))
</MACRO>
<STRUCT>
<NAME>GtkSettingsValue</NAME>
struct _GtkSettingsValue
{
  /* origin should be something like "filename:linenumber" for rc files,
   * or e.g. "XProperty" for other sources
   */
  gchar *origin;

  /* valid types are LONG, DOUBLE and STRING corresponding to the token parsed,
   * or a GSTRING holding an unparsed statement
   */
  GValue value;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_settings_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_settings_get_default</NAME>
<RETURNS>GtkSettings *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_settings_get_for_display</NAME>
<RETURNS>GtkSettings *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_settings_reset_property</NAME>
<RETURNS>void</RETURNS>
GtkSettings            *settings, const gchar            *name
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT</NAME>
#define GTK_TYPE_SHORTCUT         (gtk_shortcut_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_shortcut_new</NAME>
<RETURNS>GtkShortcut *</RETURNS>
GtkShortcutTrigger     *trigger, GtkShortcutAction      *action
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_new_with_arguments</NAME>
<RETURNS>GtkShortcut *</RETURNS>
GtkShortcutTrigger     *trigger, GtkShortcutAction      *action, const gchar            *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_get_trigger</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
GtkShortcut            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_set_trigger</NAME>
<RETURNS>void</RETURNS>
GtkShortcut            *self, GtkShortcutTrigger     *trigger
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_get_action</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
GtkShortcut            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_set_action</NAME>
<RETURNS>void</RETURNS>
GtkShortcut            *self, GtkShortcutAction      *action
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_get_arguments</NAME>
<RETURNS>GVariant *</RETURNS>
GtkShortcut            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_set_arguments</NAME>
<RETURNS>void</RETURNS>
GtkShortcut            *self, GVariant               *args
</FUNCTION>
<STRUCT>
<NAME>GtkShortcut</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_ACTION</NAME>
#define GTK_TYPE_SHORTCUT_ACTION (gtk_shortcut_action_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkShortcutFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget *widget, GVariant  *args, gpointer   user_data
</USER_FUNCTION>
<ENUM>
<NAME>GtkShortcutActionFlags</NAME>
typedef enum {
  GTK_SHORTCUT_ACTION_EXCLUSIVE = 1 << 0
} GtkShortcutActionFlags;
</ENUM>
<FUNCTION>
<NAME>gtk_shortcut_action_to_string</NAME>
<RETURNS>char *</RETURNS>
GtkShortcutAction      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_action_parse_string</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
const char *            string
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_action_print</NAME>
<RETURNS>void</RETURNS>
GtkShortcutAction      *self, GString                *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_action_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkShortcutAction      *self, GtkShortcutActionFlags  flags, GtkWidget              *widget, GVariant               *args
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_NOTHING_ACTION</NAME>
#define GTK_TYPE_NOTHING_ACTION (gtk_nothing_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_nothing_action_get</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CALLBACK_ACTION</NAME>
#define GTK_TYPE_CALLBACK_ACTION (gtk_callback_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_callback_action_new</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
GtkShortcutFunc         callback, gpointer                data, GDestroyNotify          destroy
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_MNEMONIC_ACTION</NAME>
#define GTK_TYPE_MNEMONIC_ACTION (gtk_mnemonic_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_mnemonic_action_get</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ACTIVATE_ACTION</NAME>
#define GTK_TYPE_ACTIVATE_ACTION (gtk_activate_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_activate_action_get</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SIGNAL_ACTION</NAME>
#define GTK_TYPE_SIGNAL_ACTION (gtk_signal_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_signal_action_new</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
const char      *signal_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_signal_action_get_signal_name</NAME>
<RETURNS>const char *</RETURNS>
GtkSignalAction *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_NAMED_ACTION</NAME>
#define GTK_TYPE_NAMED_ACTION (gtk_named_action_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_named_action_new</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
const char     *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_named_action_get_action_name</NAME>
<RETURNS>const char *</RETURNS>
GtkNamedAction *self
</FUNCTION>
<STRUCT>
<NAME>GtkActivateAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCallbackAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkMnemonicAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkNamedAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkNothingAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSignalAction</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_shortcut_action_parse_builder</NAME>
<RETURNS>GtkShortcutAction *</RETURNS>
GtkBuilder              *builder, const char              *string, GError                 **error
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_CONTROLLER</NAME>
#define GTK_TYPE_SHORTCUT_CONTROLLER         (gtk_shortcut_controller_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUT_CONTROLLER</NAME>
#define GTK_SHORTCUT_CONTROLLER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_SHORTCUT_CONTROLLER, GtkShortcutController))
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUT_CONTROLLER_CLASS</NAME>
#define GTK_SHORTCUT_CONTROLLER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_SHORTCUT_CONTROLLER, GtkShortcutControllerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SHORTCUT_CONTROLLER</NAME>
#define GTK_IS_SHORTCUT_CONTROLLER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_SHORTCUT_CONTROLLER))
</MACRO>
<MACRO>
<NAME>GTK_IS_SHORTCUT_CONTROLLER_CLASS</NAME>
#define GTK_IS_SHORTCUT_CONTROLLER_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_SHORTCUT_CONTROLLER))
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUT_CONTROLLER_GET_CLASS</NAME>
#define GTK_SHORTCUT_CONTROLLER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_SHORTCUT_CONTROLLER, GtkShortcutControllerClass))
</MACRO>
<FUNCTION>
<NAME>gtk_shortcut_controller_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_new</NAME>
<RETURNS>GtkEventController *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_new_for_model</NAME>
<RETURNS>GtkEventController *</RETURNS>
GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_set_mnemonics_modifiers</NAME>
<RETURNS>void</RETURNS>
GtkShortcutController  *self, GdkModifierType         modifiers
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_get_mnemonics_modifiers</NAME>
<RETURNS>GdkModifierType</RETURNS>
GtkShortcutController  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_set_scope</NAME>
<RETURNS>void</RETURNS>
GtkShortcutController  *self, GtkShortcutScope        scope
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_get_scope</NAME>
<RETURNS>GtkShortcutScope</RETURNS>
GtkShortcutController  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_add_shortcut</NAME>
<RETURNS>void</RETURNS>
GtkShortcutController  *self, GtkShortcut            *shortcut
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_remove_shortcut</NAME>
<RETURNS>void</RETURNS>
GtkShortcutController  *self, GtkShortcut            *shortcut
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutController</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutControllerClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_shortcut_controller_root</NAME>
<RETURNS>void</RETURNS>
GtkShortcutController  *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_controller_unroot</NAME>
<RETURNS>void</RETURNS>
GtkShortcutController  *controller
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_LABEL</NAME>
#define GTK_TYPE_SHORTCUT_LABEL (gtk_shortcut_label_get_type())
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUT_LABEL</NAME>
#define GTK_SHORTCUT_LABEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SHORTCUT_LABEL, GtkShortcutLabel))
</MACRO>
<MACRO>
<NAME>GTK_IS_SHORTCUT_LABEL</NAME>
#define GTK_IS_SHORTCUT_LABEL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SHORTCUT_LABEL))
</MACRO>
<FUNCTION>
<NAME>gtk_shortcut_label_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar      *accelerator
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_get_accelerator</NAME>
<RETURNS>const gchar *</RETURNS>
GtkShortcutLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_set_accelerator</NAME>
<RETURNS>void</RETURNS>
GtkShortcutLabel *self, const gchar      *accelerator
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_get_disabled_text</NAME>
<RETURNS>const gchar *</RETURNS>
GtkShortcutLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_set_disabled_text</NAME>
<RETURNS>void</RETURNS>
GtkShortcutLabel *self, const gchar      *disabled_text
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutLabel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutLabelClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_MANAGER</NAME>
#define GTK_TYPE_SHORTCUT_MANAGER               (gtk_shortcut_manager_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkShortcutManagerInterface</NAME>
struct _GtkShortcutManagerInterface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/
  void                  (* add_controller)              (GtkShortcutManager           *self,
                                                         GtkShortcutController        *controller);
  void                  (* remove_controller)           (GtkShortcutManager           *self,
                                                         GtkShortcutController        *controller);
};
</STRUCT>
<STRUCT>
<NAME>GtkShortcutManager</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_shortcut_manager_create_controllers</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SHORTCUTS_GROUP</NAME>
#define GTK_TYPE_SHORTCUTS_GROUP            (gtk_shortcuts_group_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_GROUP</NAME>
#define GTK_SHORTCUTS_GROUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SHORTCUTS_GROUP, GtkShortcutsGroup))
</MACRO>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_GROUP</NAME>
#define GTK_IS_SHORTCUTS_GROUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SHORTCUTS_GROUP))
</MACRO>
<FUNCTION>
<NAME>gtk_shortcuts_group_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutsGroup</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutsGroupClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SHORTCUTS_SECTION</NAME>
#define GTK_TYPE_SHORTCUTS_SECTION (gtk_shortcuts_section_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_SECTION</NAME>
#define GTK_SHORTCUTS_SECTION(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SHORTCUTS_SECTION, GtkShortcutsSection))
</MACRO>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_SECTION</NAME>
#define GTK_IS_SHORTCUTS_SECTION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SHORTCUTS_SECTION))
</MACRO>
<FUNCTION>
<NAME>gtk_shortcuts_section_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutsSection</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutsSectionClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SHORTCUTS_SHORTCUT</NAME>
#define GTK_TYPE_SHORTCUTS_SHORTCUT (gtk_shortcuts_shortcut_get_type())
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_SHORTCUT</NAME>
#define GTK_SHORTCUTS_SHORTCUT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SHORTCUTS_SHORTCUT, GtkShortcutsShortcut))
</MACRO>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_SHORTCUT</NAME>
#define GTK_IS_SHORTCUTS_SHORTCUT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SHORTCUTS_SHORTCUT))
</MACRO>
<ENUM>
<NAME>GtkShortcutType</NAME>
typedef enum {
  GTK_SHORTCUT_ACCELERATOR,
  GTK_SHORTCUT_GESTURE_PINCH,
  GTK_SHORTCUT_GESTURE_STRETCH,
  GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE,
  GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE,
  GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT,
  GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT,
  GTK_SHORTCUT_GESTURE,
  GTK_SHORTCUT_GESTURE_SWIPE_LEFT,
  GTK_SHORTCUT_GESTURE_SWIPE_RIGHT
} GtkShortcutType;
</ENUM>
<FUNCTION>
<NAME>gtk_shortcuts_shortcut_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutsShortcut</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutsShortcutClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SHORTCUTS_WINDOW</NAME>
#define GTK_TYPE_SHORTCUTS_WINDOW            (gtk_shortcuts_window_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_WINDOW</NAME>
#define GTK_SHORTCUTS_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SHORTCUTS_WINDOW, GtkShortcutsWindow))
</MACRO>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_WINDOW</NAME>
#define GTK_IS_SHORTCUTS_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SHORTCUTS_WINDOW))
</MACRO>
<STRUCT>
<NAME>GtkShortcutsWindow</NAME>
struct _GtkShortcutsWindow
{
  GtkWindow window;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_shortcuts_window_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutsWindowClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_TRIGGER</NAME>
#define GTK_TYPE_SHORTCUT_TRIGGER (gtk_shortcut_trigger_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_shortcut_trigger_parse_string</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
const char         *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_to_string</NAME>
<RETURNS>char *</RETURNS>
GtkShortcutTrigger *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_print</NAME>
<RETURNS>void</RETURNS>
GtkShortcutTrigger *self, GString            *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_to_label</NAME>
<RETURNS>char *</RETURNS>
GtkShortcutTrigger *self, GdkDisplay         *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_print_label</NAME>
<RETURNS>gboolean</RETURNS>
GtkShortcutTrigger *self, GdkDisplay         *display, GString            *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_hash</NAME>
<RETURNS>guint</RETURNS>
gconstpointer       trigger
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_equal</NAME>
<RETURNS>gboolean</RETURNS>
gconstpointer       trigger1, gconstpointer       trigger2
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_compare</NAME>
<RETURNS>gint</RETURNS>
gconstpointer       trigger1, gconstpointer       trigger2
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_trigger_trigger</NAME>
<RETURNS>GdkKeyMatch</RETURNS>
GtkShortcutTrigger *self, GdkEvent           *event, gboolean            enable_mnemonics
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_NEVER_TRIGGER</NAME>
#define GTK_TYPE_NEVER_TRIGGER (gtk_never_trigger_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_never_trigger_get</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_KEYVAL_TRIGGER</NAME>
#define GTK_TYPE_KEYVAL_TRIGGER (gtk_keyval_trigger_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_keyval_trigger_new</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
guint             keyval, GdkModifierType   modifiers
</FUNCTION>
<FUNCTION>
<NAME>gtk_keyval_trigger_get_modifiers</NAME>
<RETURNS>GdkModifierType</RETURNS>
GtkKeyvalTrigger *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_keyval_trigger_get_keyval</NAME>
<RETURNS>guint</RETURNS>
GtkKeyvalTrigger *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_MNEMONIC_TRIGGER</NAME>
#define GTK_TYPE_MNEMONIC_TRIGGER (gtk_mnemonic_trigger_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_mnemonic_trigger_new</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
guint               keyval
</FUNCTION>
<FUNCTION>
<NAME>gtk_mnemonic_trigger_get_keyval</NAME>
<RETURNS>guint</RETURNS>
GtkMnemonicTrigger *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ALTERNATIVE_TRIGGER</NAME>
#define GTK_TYPE_ALTERNATIVE_TRIGGER (gtk_alternative_trigger_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_alternative_trigger_new</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
GtkShortcutTrigger    *first, GtkShortcutTrigger    *second
</FUNCTION>
<FUNCTION>
<NAME>gtk_alternative_trigger_get_first</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
GtkAlternativeTrigger *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_alternative_trigger_get_second</NAME>
<RETURNS>GtkShortcutTrigger *</RETURNS>
GtkAlternativeTrigger *self
</FUNCTION>
<STRUCT>
<NAME>GtkAlternativeTrigger</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkKeyvalTrigger</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkMnemonicTrigger</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkNeverTrigger</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutTrigger</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_show_uri_full</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *parent, const char          *uri, guint32              timestamp, GCancellable        *cancellable, GAsyncReadyCallback  callback, gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_show_uri_full_finish</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow     *parent, GAsyncResult  *result, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_show_uri</NAME>
<RETURNS>void</RETURNS>
GtkWindow  *parent, const char *uri, guint32     timestamp
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SINGLE_SELECTION</NAME>
#define GTK_TYPE_SINGLE_SELECTION (gtk_single_selection_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_single_selection_new</NAME>
<RETURNS>GtkSingleSelection *</RETURNS>
GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkSingleSelection     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_get_selected</NAME>
<RETURNS>guint</RETURNS>
GtkSingleSelection     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_set_selected</NAME>
<RETURNS>void</RETURNS>
GtkSingleSelection     *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_get_selected_item</NAME>
<RETURNS>gpointer</RETURNS>
GtkSingleSelection     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_get_autoselect</NAME>
<RETURNS>gboolean</RETURNS>
GtkSingleSelection     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_set_autoselect</NAME>
<RETURNS>void</RETURNS>
GtkSingleSelection     *self, gboolean                autoselect
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_get_can_unselect</NAME>
<RETURNS>gboolean</RETURNS>
GtkSingleSelection     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_single_selection_set_can_unselect</NAME>
<RETURNS>void</RETURNS>
GtkSingleSelection     *self, gboolean                can_unselect
</FUNCTION>
<STRUCT>
<NAME>GtkSingleSelection</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SIZE_GROUP</NAME>
#define GTK_TYPE_SIZE_GROUP            (gtk_size_group_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SIZE_GROUP</NAME>
#define GTK_SIZE_GROUP(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SIZE_GROUP, GtkSizeGroup))
</MACRO>
<MACRO>
<NAME>GTK_IS_SIZE_GROUP</NAME>
#define GTK_IS_SIZE_GROUP(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SIZE_GROUP))
</MACRO>
<STRUCT>
<NAME>GtkSizeGroup</NAME>
struct _GtkSizeGroup
{
  GObject parent_instance;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_size_group_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_size_group_new</NAME>
<RETURNS>GtkSizeGroup *</RETURNS>
GtkSizeGroupMode  mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_size_group_set_mode</NAME>
<RETURNS>void</RETURNS>
GtkSizeGroup     *size_group, GtkSizeGroupMode  mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_size_group_get_mode</NAME>
<RETURNS>GtkSizeGroupMode</RETURNS>
GtkSizeGroup     *size_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_size_group_add_widget</NAME>
<RETURNS>void</RETURNS>
GtkSizeGroup     *size_group, GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_size_group_remove_widget</NAME>
<RETURNS>void</RETURNS>
GtkSizeGroup     *size_group, GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_size_group_get_widgets</NAME>
<RETURNS>GSList *</RETURNS>
GtkSizeGroup     *size_group
</FUNCTION>
<STRUCT>
<NAME>GtkRequestedSize</NAME>
struct _GtkRequestedSize
{
  gpointer data;
  gint     minimum_size;
  gint     natural_size;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_distribute_natural_allocation</NAME>
<RETURNS>gint</RETURNS>
gint              extra_space, guint             n_requested_sizes, GtkRequestedSize *sizes
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SLICE_LIST_MODEL</NAME>
#define GTK_TYPE_SLICE_LIST_MODEL (gtk_slice_list_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_slice_list_model_new</NAME>
<RETURNS>GtkSliceListModel *</RETURNS>
GListModel             *model, guint                   offset, guint                   size
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_new_for_type</NAME>
<RETURNS>GtkSliceListModel *</RETURNS>
GType                   item_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_set_model</NAME>
<RETURNS>void</RETURNS>
GtkSliceListModel      *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkSliceListModel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_set_offset</NAME>
<RETURNS>void</RETURNS>
GtkSliceListModel      *self, guint                   offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_get_offset</NAME>
<RETURNS>guint</RETURNS>
GtkSliceListModel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_set_size</NAME>
<RETURNS>void</RETURNS>
GtkSliceListModel      *self, guint                   size
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_get_size</NAME>
<RETURNS>guint</RETURNS>
GtkSliceListModel      *self
</FUNCTION>
<STRUCT>
<NAME>GtkSliceListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SNAPSHOT</NAME>
#define GTK_TYPE_SNAPSHOT               (gtk_snapshot_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SNAPSHOT</NAME>
#define GTK_SNAPSHOT(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SNAPSHOT, GtkSnapshot))
</MACRO>
<MACRO>
<NAME>GTK_IS_SNAPSHOT</NAME>
#define GTK_IS_SNAPSHOT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SNAPSHOT))
</MACRO>
<FUNCTION>
<NAME>gtk_snapshot_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_new</NAME>
<RETURNS>GtkSnapshot *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_free_to_node</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_free_to_paintable</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkSnapshot            *snapshot, const graphene_size_t  *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_to_node</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_to_paintable</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkSnapshot            *snapshot, const graphene_size_t  *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_debug</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const char             *message, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_opacity</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, double                  opacity
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_blur</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, double                  radius
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_color_matrix</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_matrix_t*color_matrix, const graphene_vec4_t  *color_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_repeat</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_rect_t  *child_bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_clip</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_rounded_clip</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_shadow</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const GskShadow        *shadow, gsize                   n_shadows
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_blend</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GskBlendMode            blend_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_cross_fade</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, double                  progress
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_pop</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_save</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_restore</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_transform</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GskTransform           *transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_transform_matrix</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_matrix_t*matrix
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_translate</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_point_t *point
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_translate_3d</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_point3d_t*point
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_rotate</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, float                  angle
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_rotate_3d</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, float                   angle, const graphene_vec3_t  *axis
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_scale</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, float                   factor_x, float                   factor_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_scale_3d</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, float                   factor_x, float                   factor_y, float                   factor_z
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_perspective</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, float                   depth
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_node</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GskRenderNode          *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_cairo</NAME>
<RETURNS>cairo_t *</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_texture</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GdkTexture             *texture, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_color</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const GdkRGBA          *color, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_linear_gradient</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_point_t *start_point, const graphene_point_t *end_point, const GskColorStop     *stops, gsize                   n_stops
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_repeating_linear_gradient</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_point_t *start_point, const graphene_point_t *end_point, const GskColorStop     *stops, gsize                   n_stops
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_border</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *outline, const float             border_width[4], const GdkRGBA           border_color[4]
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_inset_shadow</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *outline, const GdkRGBA          *color, float                   dx, float                   dy, float                   spread, float                   blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_outset_shadow</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *outline, const GdkRGBA          *color, float                   dx, float                   dy, float                   spread, float                   blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_layout</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, PangoLayout            *layout, const GdkRGBA          *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_background</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, gdouble                 width, gdouble                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_frame</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, gdouble                 width, gdouble                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_focus</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, gdouble                 width, gdouble                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_layout</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, PangoLayout            *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_insertion_cursor</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, PangoLayout            *layout, int                     index, PangoDirection          direction
</FUNCTION>
<STRUCT>
<NAME>GtkSnapshotClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SORT_LIST_MODEL</NAME>
#define GTK_TYPE_SORT_LIST_MODEL (gtk_sort_list_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_sort_list_model_new</NAME>
<RETURNS>GtkSortListModel *</RETURNS>
GListModel             *model, GCompareDataFunc        sort_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_new_for_type</NAME>
<RETURNS>GtkSortListModel *</RETURNS>
GType                   item_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_set_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkSortListModel       *self, GCompareDataFunc        sort_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_has_sort</NAME>
<RETURNS>gboolean</RETURNS>
GtkSortListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_set_model</NAME>
<RETURNS>void</RETURNS>
GtkSortListModel       *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkSortListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_resort</NAME>
<RETURNS>void</RETURNS>
GtkSortListModel       *self
</FUNCTION>
<STRUCT>
<NAME>GtkSortListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SPIN_BUTTON</NAME>
#define GTK_TYPE_SPIN_BUTTON                  (gtk_spin_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SPIN_BUTTON</NAME>
#define GTK_SPIN_BUTTON(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPIN_BUTTON, GtkSpinButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPIN_BUTTON</NAME>
#define GTK_IS_SPIN_BUTTON(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPIN_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_INPUT_ERROR</NAME>
#define GTK_INPUT_ERROR -1
</MACRO>
<ENUM>
<NAME>GtkSpinButtonUpdatePolicy</NAME>
typedef enum
{
  GTK_UPDATE_ALWAYS,
  GTK_UPDATE_IF_VALID
} GtkSpinButtonUpdatePolicy;
</ENUM>
<ENUM>
<NAME>GtkSpinType</NAME>
typedef enum
{
  GTK_SPIN_STEP_FORWARD,
  GTK_SPIN_STEP_BACKWARD,
  GTK_SPIN_PAGE_FORWARD,
  GTK_SPIN_PAGE_BACKWARD,
  GTK_SPIN_HOME,
  GTK_SPIN_END,
  GTK_SPIN_USER_DEFINED
} GtkSpinType;
</ENUM>
<FUNCTION>
<NAME>gtk_spin_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_configure</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, GtkAdjustment  *adjustment, gdouble	    climb_rate, guint	    digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAdjustment  *adjustment, gdouble	    climb_rate, guint	    digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_new_with_range</NAME>
<RETURNS>GtkWidget *</RETURNS>
gdouble  min, gdouble  max, gdouble  step
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_adjustment</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, GtkAdjustment  *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_adjustment</NAME>
<RETURNS>GtkAdjustment *</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_digits</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, guint	    digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_digits</NAME>
<RETURNS>guint</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_increments</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gdouble         step, gdouble         page
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_increments</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gdouble        *step, gdouble        *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_range</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gdouble         min, gdouble         max
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_range</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gdouble        *min, gdouble        *max
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_value</NAME>
<RETURNS>gdouble</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_value_as_int</NAME>
<RETURNS>gint</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_value</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gdouble	    value
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_update_policy</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, GtkSpinButtonUpdatePolicy  policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_update_policy</NAME>
<RETURNS>GtkSpinButtonUpdatePolicy</RETURNS>
GtkSpinButton *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_numeric</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gboolean	    numeric
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_numeric</NAME>
<RETURNS>gboolean</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_spin</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, GtkSpinType     direction, gdouble	    increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_wrap</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gboolean	    wrap
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_wrap</NAME>
<RETURNS>gboolean</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_snap_to_ticks</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, gboolean	    snap_to_ticks
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_snap_to_ticks</NAME>
<RETURNS>gboolean</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_update</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<STRUCT>
<NAME>GtkSpinButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SPINNER</NAME>
#define GTK_TYPE_SPINNER           (gtk_spinner_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SPINNER</NAME>
#define GTK_SPINNER(obj)           (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPINNER, GtkSpinner))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPINNER</NAME>
#define GTK_IS_SPINNER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPINNER))
</MACRO>
<FUNCTION>
<NAME>gtk_spinner_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_spinner_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_spinner_start</NAME>
<RETURNS>void</RETURNS>
GtkSpinner *spinner
</FUNCTION>
<FUNCTION>
<NAME>gtk_spinner_stop</NAME>
<RETURNS>void</RETURNS>
GtkSpinner *spinner
</FUNCTION>
<FUNCTION>
<NAME>gtk_spinner_set_spinning</NAME>
<RETURNS>void</RETURNS>
GtkSpinner *spinner, gboolean    spinning
</FUNCTION>
<FUNCTION>
<NAME>gtk_spinner_get_spinning</NAME>
<RETURNS>gboolean</RETURNS>
GtkSpinner *spinner
</FUNCTION>
<STRUCT>
<NAME>GtkSpinner</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_STACK</NAME>
#define GTK_TYPE_STACK (gtk_stack_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STACK</NAME>
#define GTK_STACK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STACK, GtkStack))
</MACRO>
<MACRO>
<NAME>GTK_IS_STACK</NAME>
#define GTK_IS_STACK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STACK))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_STACK_PAGE</NAME>
#define GTK_TYPE_STACK_PAGE (gtk_stack_page_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STACK_PAGE</NAME>
#define GTK_STACK_PAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STACK_PAGE, GtkStackPage))
</MACRO>
<MACRO>
<NAME>GTK_IS_STACK_PAGE</NAME>
#define GTK_IS_STACK_PAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STACK_PAGE))
</MACRO>
<ENUM>
<NAME>GtkStackTransitionType</NAME>
typedef enum {
  GTK_STACK_TRANSITION_TYPE_NONE,
  GTK_STACK_TRANSITION_TYPE_CROSSFADE,
  GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT,
  GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT,
  GTK_STACK_TRANSITION_TYPE_SLIDE_UP,
  GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN,
  GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT,
  GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN,
  GTK_STACK_TRANSITION_TYPE_OVER_UP,
  GTK_STACK_TRANSITION_TYPE_OVER_DOWN,
  GTK_STACK_TRANSITION_TYPE_OVER_LEFT,
  GTK_STACK_TRANSITION_TYPE_OVER_RIGHT,
  GTK_STACK_TRANSITION_TYPE_UNDER_UP,
  GTK_STACK_TRANSITION_TYPE_UNDER_DOWN,
  GTK_STACK_TRANSITION_TYPE_UNDER_LEFT,
  GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT,
  GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN,
  GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP,
  GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT,
  GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT,
  GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT,
  GTK_STACK_TRANSITION_TYPE_ROTATE_RIGHT,
  GTK_STACK_TRANSITION_TYPE_ROTATE_LEFT_RIGHT
} GtkStackTransitionType;
</ENUM>
<FUNCTION>
<NAME>gtk_stack_page_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkStackPage           *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkStackPage           *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_set_visible</NAME>
<RETURNS>void</RETURNS>
GtkStackPage           *page, gboolean                visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_add_named</NAME>
<RETURNS>GtkStackPage *</RETURNS>
GtkStack               *stack, GtkWidget              *child, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_add_titled</NAME>
<RETURNS>GtkStackPage *</RETURNS>
GtkStack               *stack, GtkWidget              *child, const gchar            *name, const gchar            *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_remove</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_page</NAME>
<RETURNS>GtkStackPage *</RETURNS>
GtkStack               *stack, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_child_by_name</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkStack               *stack, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_visible_child</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_visible_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_visible_child_name</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_visible_child_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_visible_child_full</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, const gchar            *name, GtkStackTransitionType  transition
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_homogeneous</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, gboolean                homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_homogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_hhomogeneous</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, gboolean                hhomogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_hhomogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_vhomogeneous</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, gboolean                vhomogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_vhomogeneous</NAME>
<RETURNS>gboolean</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_transition_duration</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, guint                   duration
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_transition_duration</NAME>
<RETURNS>guint</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_transition_type</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, GtkStackTransitionType  transition
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_transition_type</NAME>
<RETURNS>GtkStackTransitionType</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_transition_running</NAME>
<RETURNS>gboolean</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_interpolate_size</NAME>
<RETURNS>void</RETURNS>
GtkStack *stack, gboolean  interpolate_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_interpolate_size</NAME>
<RETURNS>gboolean</RETURNS>
GtkStack *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_pages</NAME>
<RETURNS>GtkSelectionModel *</RETURNS>
GtkStack *stack
</FUNCTION>
<STRUCT>
<NAME>GtkStack</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkStackPage</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_STACK_SIDEBAR</NAME>
#define GTK_TYPE_STACK_SIDEBAR           (gtk_stack_sidebar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STACK_SIDEBAR</NAME>
#define GTK_STACK_SIDEBAR(obj)           (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STACK_SIDEBAR, GtkStackSidebar))
</MACRO>
<MACRO>
<NAME>GTK_IS_STACK_SIDEBAR</NAME>
#define GTK_IS_STACK_SIDEBAR(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STACK_SIDEBAR))
</MACRO>
<FUNCTION>
<NAME>gtk_stack_sidebar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_sidebar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_sidebar_set_stack</NAME>
<RETURNS>void</RETURNS>
GtkStackSidebar *self, GtkStack        *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_sidebar_get_stack</NAME>
<RETURNS>GtkStack *</RETURNS>
GtkStackSidebar *self
</FUNCTION>
<STRUCT>
<NAME>GtkStackSidebar</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_STACK_SWITCHER</NAME>
#define GTK_TYPE_STACK_SWITCHER            (gtk_stack_switcher_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STACK_SWITCHER</NAME>
#define GTK_STACK_SWITCHER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STACK_SWITCHER, GtkStackSwitcher))
</MACRO>
<MACRO>
<NAME>GTK_IS_STACK_SWITCHER</NAME>
#define GTK_IS_STACK_SWITCHER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STACK_SWITCHER))
</MACRO>
<FUNCTION>
<NAME>gtk_stack_switcher_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_switcher_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_switcher_set_stack</NAME>
<RETURNS>void</RETURNS>
GtkStackSwitcher *switcher, GtkStack         *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_switcher_get_stack</NAME>
<RETURNS>GtkStack *</RETURNS>
GtkStackSwitcher *switcher
</FUNCTION>
<STRUCT>
<NAME>GtkStackSwitcher</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_STATUSBAR</NAME>
#define GTK_TYPE_STATUSBAR            (gtk_statusbar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STATUSBAR</NAME>
#define GTK_STATUSBAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STATUSBAR, GtkStatusbar))
</MACRO>
<MACRO>
<NAME>GTK_IS_STATUSBAR</NAME>
#define GTK_IS_STATUSBAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STATUSBAR))
</MACRO>
<FUNCTION>
<NAME>gtk_statusbar_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_get_context_id</NAME>
<RETURNS>guint</RETURNS>
GtkStatusbar *statusbar, const gchar  *context_description
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_push</NAME>
<RETURNS>guint</RETURNS>
GtkStatusbar *statusbar, guint	       context_id, const gchar  *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_pop</NAME>
<RETURNS>void</RETURNS>
GtkStatusbar *statusbar, guint	       context_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_remove</NAME>
<RETURNS>void</RETURNS>
GtkStatusbar *statusbar, guint	       context_id, guint         message_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_remove_all</NAME>
<RETURNS>void</RETURNS>
GtkStatusbar *statusbar, guint	       context_id
</FUNCTION>
<STRUCT>
<NAME>GtkStatusbar</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_statusbar_get_message</NAME>
<RETURNS>const char *</RETURNS>
GtkStatusbar *statusbar
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_STYLE_CONTEXT</NAME>
#define GTK_TYPE_STYLE_CONTEXT         (gtk_style_context_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CONTEXT</NAME>
#define GTK_STYLE_CONTEXT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContext))
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CONTEXT_CLASS</NAME>
#define GTK_STYLE_CONTEXT_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST    ((c), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_STYLE_CONTEXT</NAME>
#define GTK_IS_STYLE_CONTEXT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_STYLE_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IS_STYLE_CONTEXT_CLASS</NAME>
#define GTK_IS_STYLE_CONTEXT_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE    ((c), GTK_TYPE_STYLE_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CONTEXT_GET_CLASS</NAME>
#define GTK_STYLE_CONTEXT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS  ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass))
</MACRO>
<STRUCT>
<NAME>GtkStyleContext</NAME>
struct _GtkStyleContext
{
  GObject parent_object;
};
</STRUCT>
<STRUCT>
<NAME>GtkStyleContextClass</NAME>
struct _GtkStyleContextClass
{
  GObjectClass parent_class;

  void (* changed) (GtkStyleContext *context);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<MACRO>
<NAME>GTK_STYLE_CLASS_CELL</NAME>
#define GTK_STYLE_CLASS_CELL "cell"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DIM_LABEL</NAME>
#define GTK_STYLE_CLASS_DIM_LABEL "dim-label"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ENTRY</NAME>
#define GTK_STYLE_CLASS_ENTRY "entry"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LABEL</NAME>
#define GTK_STYLE_CLASS_LABEL "label"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_COMBOBOX_ENTRY</NAME>
#define GTK_STYLE_CLASS_COMBOBOX_ENTRY "combobox-entry"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_BUTTON</NAME>
#define GTK_STYLE_CLASS_BUTTON "button"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LIST</NAME>
#define GTK_STYLE_CLASS_LIST "list"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LIST_ROW</NAME>
#define GTK_STYLE_CLASS_LIST_ROW "list-row"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CALENDAR</NAME>
#define GTK_STYLE_CLASS_CALENDAR "calendar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SLIDER</NAME>
#define GTK_STYLE_CLASS_SLIDER "slider"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_BACKGROUND</NAME>
#define GTK_STYLE_CLASS_BACKGROUND "background"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RUBBERBAND</NAME>
#define GTK_STYLE_CLASS_RUBBERBAND "rubberband"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CSD</NAME>
#define GTK_STYLE_CLASS_CSD "csd"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOOLTIP</NAME>
#define GTK_STYLE_CLASS_TOOLTIP "tooltip"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MENU</NAME>
#define GTK_STYLE_CLASS_MENU "menu"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CONTEXT_MENU</NAME>
#define GTK_STYLE_CLASS_CONTEXT_MENU "context-menu"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOUCH_SELECTION</NAME>
#define GTK_STYLE_CLASS_TOUCH_SELECTION "touch-selection"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MENUBAR</NAME>
#define GTK_STYLE_CLASS_MENUBAR "menubar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MENUITEM</NAME>
#define GTK_STYLE_CLASS_MENUITEM "menuitem"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOOLBAR</NAME>
#define GTK_STYLE_CLASS_TOOLBAR "toolbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_STATUSBAR</NAME>
#define GTK_STYLE_CLASS_STATUSBAR "statusbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RADIO</NAME>
#define GTK_STYLE_CLASS_RADIO "radio"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CHECK</NAME>
#define GTK_STYLE_CLASS_CHECK "check"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DEFAULT</NAME>
#define GTK_STYLE_CLASS_DEFAULT "default"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TROUGH</NAME>
#define GTK_STYLE_CLASS_TROUGH "trough"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCROLLBAR</NAME>
#define GTK_STYLE_CLASS_SCROLLBAR "scrollbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCROLLBARS_JUNCTION</NAME>
#define GTK_STYLE_CLASS_SCROLLBARS_JUNCTION "scrollbars-junction"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCALE</NAME>
#define GTK_STYLE_CLASS_SCALE "scale"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE</NAME>
#define GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE "scale-has-marks-above"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW</NAME>
#define GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW "scale-has-marks-below"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_HEADER</NAME>
#define GTK_STYLE_CLASS_HEADER "header"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ACCELERATOR</NAME>
#define GTK_STYLE_CLASS_ACCELERATOR "accelerator"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RAISED</NAME>
#define GTK_STYLE_CLASS_RAISED "raised"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LINKED</NAME>
#define GTK_STYLE_CLASS_LINKED "linked"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DOCK</NAME>
#define GTK_STYLE_CLASS_DOCK "dock"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PROGRESSBAR</NAME>
#define GTK_STYLE_CLASS_PROGRESSBAR "progressbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SPINNER</NAME>
#define GTK_STYLE_CLASS_SPINNER "spinner"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MARK</NAME>
#define GTK_STYLE_CLASS_MARK "mark"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_EXPANDER</NAME>
#define GTK_STYLE_CLASS_EXPANDER "expander"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SPINBUTTON</NAME>
#define GTK_STYLE_CLASS_SPINBUTTON "spinbutton"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_NOTEBOOK</NAME>
#define GTK_STYLE_CLASS_NOTEBOOK "notebook"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_VIEW</NAME>
#define GTK_STYLE_CLASS_VIEW "view"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SIDEBAR</NAME>
#define GTK_STYLE_CLASS_SIDEBAR "sidebar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_IMAGE</NAME>
#define GTK_STYLE_CLASS_IMAGE "image"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_HIGHLIGHT</NAME>
#define GTK_STYLE_CLASS_HIGHLIGHT "highlight"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_FRAME</NAME>
#define GTK_STYLE_CLASS_FRAME "frame"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DND</NAME>
#define GTK_STYLE_CLASS_DND "dnd"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PANE_SEPARATOR</NAME>
#define GTK_STYLE_CLASS_PANE_SEPARATOR "pane-separator"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SEPARATOR</NAME>
#define GTK_STYLE_CLASS_SEPARATOR "separator"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_INFO</NAME>
#define GTK_STYLE_CLASS_INFO "info"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_WARNING</NAME>
#define GTK_STYLE_CLASS_WARNING "warning"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_QUESTION</NAME>
#define GTK_STYLE_CLASS_QUESTION "question"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ERROR</NAME>
#define GTK_STYLE_CLASS_ERROR "error"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_HORIZONTAL</NAME>
#define GTK_STYLE_CLASS_HORIZONTAL "horizontal"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_VERTICAL</NAME>
#define GTK_STYLE_CLASS_VERTICAL "vertical"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOP</NAME>
#define GTK_STYLE_CLASS_TOP "top"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_BOTTOM</NAME>
#define GTK_STYLE_CLASS_BOTTOM "bottom"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LEFT</NAME>
#define GTK_STYLE_CLASS_LEFT "left"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RIGHT</NAME>
#define GTK_STYLE_CLASS_RIGHT "right"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PULSE</NAME>
#define GTK_STYLE_CLASS_PULSE "pulse"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ARROW</NAME>
#define GTK_STYLE_CLASS_ARROW "arrow"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_OSD</NAME>
#define GTK_STYLE_CLASS_OSD "osd"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LEVEL_BAR</NAME>
#define GTK_STYLE_CLASS_LEVEL_BAR "level-bar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CURSOR_HANDLE</NAME>
#define GTK_STYLE_CLASS_CURSOR_HANDLE "cursor-handle"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_INSERTION_CURSOR</NAME>
#define GTK_STYLE_CLASS_INSERTION_CURSOR "insertion-cursor"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TITLEBAR</NAME>
#define GTK_STYLE_CLASS_TITLEBAR "titlebar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TITLE</NAME>
#define GTK_STYLE_CLASS_TITLE "title"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SUBTITLE</NAME>
#define GTK_STYLE_CLASS_SUBTITLE "subtitle"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_NEEDS_ATTENTION</NAME>
#define GTK_STYLE_CLASS_NEEDS_ATTENTION "needs-attention"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SUGGESTED_ACTION</NAME>
#define GTK_STYLE_CLASS_SUGGESTED_ACTION "suggested-action"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DESTRUCTIVE_ACTION</NAME>
#define GTK_STYLE_CLASS_DESTRUCTIVE_ACTION "destructive-action"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_POPOVER</NAME>
#define GTK_STYLE_CLASS_POPOVER "popover"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_POPUP</NAME>
#define GTK_STYLE_CLASS_POPUP "popup"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MESSAGE_DIALOG</NAME>
#define GTK_STYLE_CLASS_MESSAGE_DIALOG "message-dialog"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_FLAT</NAME>
#define GTK_STYLE_CLASS_FLAT "flat"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_READ_ONLY</NAME>
#define GTK_STYLE_CLASS_READ_ONLY "read-only"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_OVERSHOOT</NAME>
#define GTK_STYLE_CLASS_OVERSHOOT "overshoot"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_UNDERSHOOT</NAME>
#define GTK_STYLE_CLASS_UNDERSHOOT "undershoot"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PAPER</NAME>
#define GTK_STYLE_CLASS_PAPER "paper"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MONOSPACE</NAME>
#define GTK_STYLE_CLASS_MONOSPACE "monospace"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_WIDE</NAME>
#define GTK_STYLE_CLASS_WIDE "wide"
</MACRO>
<FUNCTION>
<NAME>gtk_style_context_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_add_provider_for_display</NAME>
<RETURNS>void</RETURNS>
GdkDisplay       *display, GtkStyleProvider *provider, guint             priority
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_remove_provider_for_display</NAME>
<RETURNS>void</RETURNS>
GdkDisplay       *display, GtkStyleProvider *provider
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_add_provider</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext  *context, GtkStyleProvider *provider, guint             priority
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_remove_provider</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext  *context, GtkStyleProvider *provider
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_save</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_restore</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_state</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, GtkStateFlags    flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_state</NAME>
<RETURNS>GtkStateFlags</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_scale</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, gint             scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_scale</NAME>
<RETURNS>gint</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_add_class</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, const gchar     *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_remove_class</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, const gchar     *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_has_class</NAME>
<RETURNS>gboolean</RETURNS>
GtkStyleContext *context, const gchar     *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_display</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, GdkDisplay      *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_lookup_color</NAME>
<RETURNS>gboolean</RETURNS>
GtkStyleContext *context, const gchar     *color_name, GdkRGBA         *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_color</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, GdkRGBA         *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_border</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, GtkBorder       *border
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_padding</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, GtkBorder       *padding
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_margin</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, GtkBorder       *margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_insertion_cursor</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, PangoLayout         *layout, int                  index, PangoDirection       direction
</FUNCTION>
<ENUM>
<NAME>GtkStyleContextPrintFlags</NAME>
typedef enum {
  GTK_STYLE_CONTEXT_PRINT_NONE         = 0,
  GTK_STYLE_CONTEXT_PRINT_RECURSE      = 1 << 0,
  GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE   = 1 << 1,
  GTK_STYLE_CONTEXT_PRINT_SHOW_CHANGE  = 1 << 2
} GtkStyleContextPrintFlags;
</ENUM>
<FUNCTION>
<NAME>gtk_style_context_to_string</NAME>
<RETURNS>char *</RETURNS>
GtkStyleContext           *context, GtkStyleContextPrintFlags  flags
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_STYLE_PROVIDER</NAME>
#define GTK_TYPE_STYLE_PROVIDER          (gtk_style_provider_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROVIDER</NAME>
#define GTK_STYLE_PROVIDER(o)            (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_STYLE_PROVIDER, GtkStyleProvider))
</MACRO>
<MACRO>
<NAME>GTK_IS_STYLE_PROVIDER</NAME>
#define GTK_IS_STYLE_PROVIDER(o)         (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_STYLE_PROVIDER))
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROVIDER_PRIORITY_FALLBACK</NAME>
#define GTK_STYLE_PROVIDER_PRIORITY_FALLBACK      1
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROVIDER_PRIORITY_THEME</NAME>
#define GTK_STYLE_PROVIDER_PRIORITY_THEME     200
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROVIDER_PRIORITY_SETTINGS</NAME>
#define GTK_STYLE_PROVIDER_PRIORITY_SETTINGS    400
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROVIDER_PRIORITY_APPLICATION</NAME>
#define GTK_STYLE_PROVIDER_PRIORITY_APPLICATION 600
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROVIDER_PRIORITY_USER</NAME>
#define GTK_STYLE_PROVIDER_PRIORITY_USER        800
</MACRO>
<FUNCTION>
<NAME>gtk_style_provider_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkStyleProvider</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SWITCH</NAME>
#define GTK_TYPE_SWITCH                 (gtk_switch_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SWITCH</NAME>
#define GTK_SWITCH(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SWITCH, GtkSwitch))
</MACRO>
<MACRO>
<NAME>GTK_IS_SWITCH</NAME>
#define GTK_IS_SWITCH(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SWITCH))
</MACRO>
<FUNCTION>
<NAME>gtk_switch_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_set_active</NAME>
<RETURNS>void</RETURNS>
GtkSwitch *self, gboolean   is_active
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_get_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkSwitch *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_set_state</NAME>
<RETURNS>void</RETURNS>
GtkSwitch *self, gboolean   state
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_get_state</NAME>
<RETURNS>gboolean</RETURNS>
GtkSwitch *self
</FUNCTION>
<STRUCT>
<NAME>GtkSwitch</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_test_init</NAME>
<RETURNS>void</RETURNS>
int            *argcp, char         ***argvp, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_register_all_types</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_list_all_types</NAME>
<RETURNS>const GType *</RETURNS>
guint          *n_types
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_widget_wait_for_draw</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT</NAME>
#define GTK_TYPE_TEXT                  (gtk_text_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT</NAME>
#define GTK_TEXT(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT, GtkText))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT</NAME>
#define GTK_IS_TEXT(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT))
</MACRO>
<STRUCT>
<NAME>GtkText</NAME>
struct _GtkText
{
  /*< private >*/
  GtkWidget  parent_instance;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_new_with_buffer</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_buffer</NAME>
<RETURNS>GtkEntryBuffer *</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_buffer</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_visibility</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, gboolean         visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_visibility</NAME>
<RETURNS>gboolean</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_invisible_char</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, gunichar         ch
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_invisible_char</NAME>
<RETURNS>gunichar</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_unset_invisible_char</NAME>
<RETURNS>void</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_overwrite_mode</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, gboolean         overwrite
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_overwrite_mode</NAME>
<RETURNS>gboolean</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_max_length</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, int              length
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_max_length</NAME>
<RETURNS>gint</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_text_length</NAME>
<RETURNS>guint16</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_activates_default</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, gboolean         activates
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_activates_default</NAME>
<RETURNS>gboolean</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_placeholder_text</NAME>
<RETURNS>const char *</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_placeholder_text</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, const char      *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_input_purpose</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, GtkInputPurpose  purpose
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_input_purpose</NAME>
<RETURNS>GtkInputPurpose</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_input_hints</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, GtkInputHints    hints
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_input_hints</NAME>
<RETURNS>GtkInputHints</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_attributes</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, PangoAttrList   *attrs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_attributes</NAME>
<RETURNS>PangoAttrList *</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_tabs</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, PangoTabArray   *tabs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_tabs</NAME>
<RETURNS>PangoTabArray *</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_grab_focus_without_selecting</NAME>
<RETURNS>gboolean</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_extra_menu</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, GMenuModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_extra_menu</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkText         *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT_ATTRIBUTES</NAME>
#define GTK_TYPE_TEXT_ATTRIBUTES     (gtk_text_attributes_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkTextAppearance</NAME>
struct _GtkTextAppearance
{
  GdkRGBA *bg_rgba;
  GdkRGBA *fg_rgba;
  GdkRGBA *underline_rgba;
  GdkRGBA *overline_rgba;
  GdkRGBA *strikethrough_rgba;

  /* super/subscript rise, can be negative */
  gint rise;

  guint underline : 4;          /* PangoUnderline */
  guint overline  : 2;          /* PangoOverline */
  guint strikethrough : 1;

  /* Whether to use background-related values; this is irrelevant for
   * the values struct when in a tag, but is used for the composite
   * values struct; it's true if any of the tags being composited
   * had background stuff set.
   */
  guint draw_bg : 1;

  /* These are only used when we are actually laying out and rendering
   * a paragraph; not when a GtkTextAppearance is part of a
   * GtkTextAttributes.
   */
  guint inside_selection : 1;
  guint is_text : 1;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextAttributes</NAME>
struct _GtkTextAttributes
{
  guint refcount;

  GtkTextAppearance appearance;

  GtkJustification justification;
  GtkTextDirection direction;

  PangoFontDescription *font;

  gdouble font_scale;

  gint left_margin;
  gint right_margin;
  gint indent;

  gint pixels_above_lines;
  gint pixels_below_lines;
  gint pixels_inside_wrap;

  PangoTabArray *tabs;

  GtkWrapMode wrap_mode;

  PangoLanguage *language;

  guint invisible : 1;
  guint bg_full_height : 1;
  guint editable : 1;
  guint no_fallback: 1;
  guint no_breaks : 1;
  guint show_spaces : 3; /* PangoShowFlags */
  gint  no_hyphens : 1;


  GdkRGBA *pg_bg_rgba;

  gint letter_spacing;

  gchar *font_features;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_attributes_new</NAME>
<RETURNS>GtkTextAttributes *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_attributes_copy</NAME>
<RETURNS>GtkTextAttributes *</RETURNS>
GtkTextAttributes *src
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_attributes_copy_values</NAME>
<RETURNS>void</RETURNS>
GtkTextAttributes *src, GtkTextAttributes *dest
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_attributes_unref</NAME>
<RETURNS>void</RETURNS>
GtkTextAttributes *values
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_attributes_ref</NAME>
<RETURNS>GtkTextAttributes *</RETURNS>
GtkTextAttributes *values
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_attributes_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>DEBUG_VALIDATION_AND_SCROLLING</NAME>
#define DEBUG_VALIDATION_AND_SCROLLING
</MACRO>
<MACRO>
<NAME>DV</NAME>
#define DV(x) (x)
</MACRO>
<STRUCT>
<NAME>GtkTextLineData</NAME>
struct _GtkTextLineData {
  gpointer view_id;
  GtkTextLineData *next;
  gint height;
  gint top_ink : 16;
  gint bottom_ink : 16;
  signed int width : 24;
  guint valid : 8;		/* Actually a boolean */
};
</STRUCT>
<STRUCT>
<NAME>GtkTextLine</NAME>
struct _GtkTextLine {
  GtkTextBTreeNode *parent;             /* Pointer to parent node containing
                                         * line. */
  GtkTextLine *next;            /* Next in linked list of lines with
                                 * same parent node in B-tree.  NULL
                                 * means end of list. */
  GtkTextLineSegment *segments; /* First in ordered list of segments
                                 * that make up the line. */
  GtkTextLineData *views;      /* data stored here by views */
  guchar dir_strong;                /* BiDi algo dir of line */
  guchar dir_propagated_back;       /* BiDi algo dir of next line */
  guchar dir_propagated_forward;    /* BiDi algo dir of prev line */
};
</STRUCT>
<ENUM>
<NAME>GtkTextBufferTargetInfo</NAME>
typedef enum
{
  GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS = - 1,
  GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT       = - 2,
  GTK_TEXT_BUFFER_TARGET_INFO_TEXT            = - 3
} GtkTextBufferTargetInfo;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_TEXT_BUFFER</NAME>
#define GTK_TYPE_TEXT_BUFFER            (gtk_text_buffer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_BUFFER</NAME>
#define GTK_TEXT_BUFFER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_BUFFER, GtkTextBuffer))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_BUFFER_CLASS</NAME>
#define GTK_TEXT_BUFFER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_BUFFER, GtkTextBufferClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_BUFFER</NAME>
#define GTK_IS_TEXT_BUFFER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_BUFFER))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_BUFFER_CLASS</NAME>
#define GTK_IS_TEXT_BUFFER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_BUFFER))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_BUFFER_GET_CLASS</NAME>
#define GTK_TEXT_BUFFER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_BUFFER, GtkTextBufferClass))
</MACRO>
<STRUCT>
<NAME>GtkTextBuffer</NAME>
struct _GtkTextBuffer
{
  GObject parent_instance;

  GtkTextBufferPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextBufferClass</NAME>
struct _GtkTextBufferClass
{
  GObjectClass parent_class;

  void (* insert_text)            (GtkTextBuffer      *buffer,
                                   GtkTextIter        *pos,
                                   const gchar        *new_text,
                                   gint                new_text_length);

  void (* insert_paintable)       (GtkTextBuffer      *buffer,
                                   GtkTextIter        *iter,
                                   GdkPaintable       *paintable);

  void (* insert_child_anchor)    (GtkTextBuffer      *buffer,
                                   GtkTextIter        *iter,
                                   GtkTextChildAnchor *anchor);

  void (* delete_range)           (GtkTextBuffer      *buffer,
                                   GtkTextIter        *start,
                                   GtkTextIter        *end);

  void (* changed)                (GtkTextBuffer      *buffer);

  void (* modified_changed)       (GtkTextBuffer      *buffer);

  void (* mark_set)               (GtkTextBuffer      *buffer,
                                   const GtkTextIter  *location,
                                   GtkTextMark        *mark);

  void (* mark_deleted)           (GtkTextBuffer      *buffer,
                                   GtkTextMark        *mark);

  void (* apply_tag)              (GtkTextBuffer      *buffer,
                                   GtkTextTag         *tag,
                                   const GtkTextIter  *start,
                                   const GtkTextIter  *end);

  void (* remove_tag)             (GtkTextBuffer      *buffer,
                                   GtkTextTag         *tag,
                                   const GtkTextIter  *start,
                                   const GtkTextIter  *end);

  void (* begin_user_action)      (GtkTextBuffer      *buffer);

  void (* end_user_action)        (GtkTextBuffer      *buffer);

  void (* paste_done)             (GtkTextBuffer      *buffer,
                                   GdkClipboard       *clipboard);
  void (* undo)                   (GtkTextBuffer      *buffer);
  void (* redo)                   (GtkTextBuffer      *buffer);

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_buffer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_new</NAME>
<RETURNS>GtkTextBuffer *</RETURNS>
GtkTextTagTable *table
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_line_count</NAME>
<RETURNS>gint</RETURNS>
GtkTextBuffer   *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_char_count</NAME>
<RETURNS>gint</RETURNS>
GtkTextBuffer   *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_tag_table</NAME>
<RETURNS>GtkTextTagTable *</RETURNS>
GtkTextBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_set_text</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, const gchar   *text, gint           len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, const gchar   *text, gint           len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_at_cursor</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, const gchar   *text, gint           len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_interactive</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, const gchar   *text, gint           len, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_interactive_at_cursor</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, const gchar   *text, gint           len, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_range</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_range_interactive</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const GtkTextIter *start, const GtkTextIter *end, gboolean           default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_with_tags</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const gchar       *text, gint               len, GtkTextTag        *first_tag, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_with_tags_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const gchar       *text, gint               len, const gchar       *first_tag_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_markup</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const gchar       *markup, gint               len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_interactive</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start_iter, GtkTextIter   *end_iter, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_backspace</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gboolean       interactive, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_text</NAME>
<RETURNS>gchar *</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *start, const GtkTextIter *end, gboolean           include_hidden_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_slice</NAME>
<RETURNS>gchar *</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *start, const GtkTextIter *end, gboolean           include_hidden_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_paintable</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, GdkPaintable  *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_child_anchor</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer      *buffer, GtkTextIter        *iter, GtkTextChildAnchor *anchor
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_create_child_anchor</NAME>
<RETURNS>GtkTextChildAnchor *</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_add_mark</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextMark       *mark, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_create_mark</NAME>
<RETURNS>GtkTextMark *</RETURNS>
GtkTextBuffer     *buffer, const gchar       *mark_name, const GtkTextIter *where, gboolean           left_gravity
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_move_mark</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextMark       *mark, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_mark</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextMark       *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_mark</NAME>
<RETURNS>GtkTextMark *</RETURNS>
GtkTextBuffer     *buffer, const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_move_mark_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const gchar       *name, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_mark_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_insert</NAME>
<RETURNS>GtkTextMark *</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_selection_bound</NAME>
<RETURNS>GtkTextMark *</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_place_cursor</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_select_range</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *ins, const GtkTextIter *bound
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_apply_tag</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextTag        *tag, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_tag</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextTag        *tag, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_apply_tag_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const gchar       *name, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_tag_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const gchar       *name, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_all_tags</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_create_tag</NAME>
<RETURNS>GtkTextTag *</RETURNS>
GtkTextBuffer *buffer, const gchar   *tag_name, const gchar   *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           line_number, gint           char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line_index</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           line_number, gint           byte_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           line_number
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_start_iter</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_end_iter</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_bounds</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_mark</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, GtkTextMark   *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_child_anchor</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer      *buffer, GtkTextIter        *iter, GtkTextChildAnchor *anchor
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_modified</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_set_modified</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_has_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_add_selection_clipboard</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GdkClipboard      *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_selection_clipboard</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GdkClipboard      *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_cut_clipboard</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GdkClipboard  *clipboard, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_copy_clipboard</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GdkClipboard  *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_paste_clipboard</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GdkClipboard  *clipboard, GtkTextIter   *override_location, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_selection_bounds</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, gboolean       interactive, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_selection_content</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_can_undo</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_can_redo</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_enable_undo</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_set_enable_undo</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, gboolean       enable_undo
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_max_undo_levels</NAME>
<RETURNS>guint</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_set_max_undo_levels</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, guint          max_undo_levels
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_undo</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_redo</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_begin_irreversible_action</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_end_irreversible_action</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_begin_user_action</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_end_user_action</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<STRUCT>
<NAME>GtkTextBTree</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextBufferPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TEXT_CHILD_ANCHOR</NAME>
#define GTK_TYPE_TEXT_CHILD_ANCHOR              (gtk_text_child_anchor_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_CHILD_ANCHOR</NAME>
#define GTK_TEXT_CHILD_ANCHOR(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_TEXT_CHILD_ANCHOR, GtkTextChildAnchor))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_CHILD_ANCHOR_CLASS</NAME>
#define GTK_TEXT_CHILD_ANCHOR_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_CHILD_ANCHOR, GtkTextChildAnchorClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_CHILD_ANCHOR</NAME>
#define GTK_IS_TEXT_CHILD_ANCHOR(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_TEXT_CHILD_ANCHOR))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_CHILD_ANCHOR_CLASS</NAME>
#define GTK_IS_TEXT_CHILD_ANCHOR_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_CHILD_ANCHOR))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_CHILD_ANCHOR_GET_CLASS</NAME>
#define GTK_TEXT_CHILD_ANCHOR_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_CHILD_ANCHOR, GtkTextChildAnchorClass))
</MACRO>
<STRUCT>
<NAME>GtkTextChildAnchor</NAME>
struct _GtkTextChildAnchor
{
  GObject parent_instance;

  /*< private >*/
  gpointer segment;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextChildAnchorClass</NAME>
struct _GtkTextChildAnchorClass
{
  GObjectClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_child_anchor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_child_anchor_new</NAME>
<RETURNS>GtkTextChildAnchor *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_child_anchor_get_widgets</NAME>
<RETURNS>GtkWidget **</RETURNS>
GtkTextChildAnchor *anchor, guint              *out_len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_child_anchor_get_deleted</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextChildAnchor *anchor
</FUNCTION>
<ENUM>
<NAME>GtkTextSearchFlags</NAME>
typedef enum {
  GTK_TEXT_SEARCH_VISIBLE_ONLY     = 1 << 0,
  GTK_TEXT_SEARCH_TEXT_ONLY        = 1 << 1,
  GTK_TEXT_SEARCH_CASE_INSENSITIVE = 1 << 2
  /* Possible future plans: SEARCH_REGEXP */
} GtkTextSearchFlags;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_TEXT_ITER</NAME>
#define GTK_TYPE_TEXT_ITER     (gtk_text_iter_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkTextIter</NAME>
struct _GtkTextIter {
  /* GtkTextIter is an opaque datatype; ignore all these fields.
   * Initialize the iter with gtk_text_buffer_get_iter_*
   * functions
   */
  /*< private >*/
  gpointer dummy1;
  gpointer dummy2;
  gint dummy3;
  gint dummy4;
  gint dummy5;
  gint dummy6;
  gint dummy7;
  gint dummy8;
  gpointer dummy9;
  gpointer dummy10;
  gint dummy11;
  gint dummy12;
  /* padding */
  gint dummy13;
  gpointer dummy14;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_iter_get_buffer</NAME>
<RETURNS>GtkTextBuffer *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_copy</NAME>
<RETURNS>GtkTextIter *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_free</NAME>
<RETURNS>void</RETURNS>
GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_assign</NAME>
<RETURNS>void</RETURNS>
GtkTextIter       *iter, const GtkTextIter *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_offset</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line_offset</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line_index</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_line_offset</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_line_index</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_char</NAME>
<RETURNS>gunichar</RETURNS>
const GtkTextIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_slice</NAME>
<RETURNS>gchar *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_text</NAME>
<RETURNS>gchar *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_slice</NAME>
<RETURNS>gchar *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_text</NAME>
<RETURNS>gchar *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_paintable</NAME>
<RETURNS>GdkPaintable *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_marks</NAME>
<RETURNS>GSList *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_child_anchor</NAME>
<RETURNS>GtkTextChildAnchor *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_toggled_tags</NAME>
<RETURNS>GSList *</RETURNS>
const GtkTextIter  *iter, gboolean            toggled_on
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_tag</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter  *iter, GtkTextTag         *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_tag</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter  *iter, GtkTextTag         *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_toggles_tag</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter  *iter, GtkTextTag         *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_has_tag</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter, GtkTextTag          *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_tags</NAME>
<RETURNS>GSList *</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_editable</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter, gboolean             default_setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_can_insert</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter, gboolean             default_editability
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_word</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_word</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_inside_word</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_sentence</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_sentence</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_inside_sentence</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_line</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_line</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_is_cursor_position</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_chars_in_line</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_bytes_in_line</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_language</NAME>
<RETURNS>PangoLanguage *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_is_end</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_is_start</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_char</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_char</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_chars</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_chars</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_lines</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_lines</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_word_end</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_word_start</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_word_ends</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_word_starts</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_lines</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_lines</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_word_end</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_word_start</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_word_ends</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_word_starts</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_sentence_end</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_sentence_start</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_sentence_ends</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_sentence_starts</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_cursor_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_cursor_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_cursor_positions</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_cursor_positions</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_cursor_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_cursor_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_cursor_positions</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_cursor_positions</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, gint         char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, gint         line_number
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, gint         char_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line_index</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, gint         byte_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_to_end</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_to_line_end</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_visible_line_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, gint         char_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_visible_line_index</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, gint         byte_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_to_tag_toggle</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, GtkTextTag  *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_to_tag_toggle</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, GtkTextTag  *tag
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkTextCharPredicate</NAME>
<RETURNS>gboolean</RETURNS>
gunichar ch, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_find_char</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter          *iter, GtkTextCharPredicate  pred, gpointer              user_data, const GtkTextIter    *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_find_char</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter          *iter, GtkTextCharPredicate  pred, gpointer              user_data, const GtkTextIter    *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_search</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter *iter, const gchar       *str, GtkTextSearchFlags flags, GtkTextIter       *match_start, GtkTextIter       *match_end, const GtkTextIter *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_search</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter *iter, const gchar       *str, GtkTextSearchFlags flags, GtkTextIter       *match_start, GtkTextIter       *match_end, const GtkTextIter *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_equal</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter *lhs, const GtkTextIter *rhs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_compare</NAME>
<RETURNS>gint</RETURNS>
const GtkTextIter *lhs, const GtkTextIter *rhs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_in_range</NAME>
<RETURNS>gboolean</RETURNS>
const GtkTextIter *iter, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_order</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *first, GtkTextIter *second
</FUNCTION>
<STRUCT>
<NAME>GtkTextBuffer</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TEXT_MARK</NAME>
#define GTK_TYPE_TEXT_MARK              (gtk_text_mark_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_MARK</NAME>
#define GTK_TEXT_MARK(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_TEXT_MARK, GtkTextMark))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_MARK_CLASS</NAME>
#define GTK_TEXT_MARK_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_MARK, GtkTextMarkClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_MARK</NAME>
#define GTK_IS_TEXT_MARK(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_TEXT_MARK))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_MARK_CLASS</NAME>
#define GTK_IS_TEXT_MARK_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_MARK))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_MARK_GET_CLASS</NAME>
#define GTK_TEXT_MARK_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_MARK, GtkTextMarkClass))
</MACRO>
<STRUCT>
<NAME>GtkTextMark</NAME>
struct _GtkTextMark
{
  GObject parent_instance;

  /*< private >*/
  gpointer segment;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextMarkClass</NAME>
struct _GtkTextMarkClass
{
  GObjectClass parent_class;

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_mark_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_new</NAME>
<RETURNS>GtkTextMark *</RETURNS>
const gchar *name, gboolean     left_gravity
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_set_visible</NAME>
<RETURNS>void</RETURNS>
GtkTextMark *mark, gboolean     setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_deleted</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_buffer</NAME>
<RETURNS>GtkTextBuffer *</RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_left_gravity</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextMark *mark
</FUNCTION>
<MACRO>
<NAME>GTK_TEXT_CLASS</NAME>
#define GTK_TEXT_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT, GtkTextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_CLASS</NAME>
#define GTK_IS_TEXT_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_GET_CLASS</NAME>
#define GTK_TEXT_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT, GtkTextClass))
</MACRO>
<STRUCT>
<NAME>GtkTextClass</NAME>
struct _GtkTextClass
{
  GtkWidgetClass parent_class;

  /* Action signals
   */
  void (* activate)           (GtkText         *self);
  void (* move_cursor)        (GtkText         *self,
                               GtkMovementStep  step,
                               gint             count,
                               gboolean         extend);
  void (* insert_at_cursor)   (GtkText         *self,
                               const gchar     *str);
  void (* delete_from_cursor) (GtkText         *self,
                               GtkDeleteType    type,
                               gint             count);
  void (* backspace)          (GtkText         *self);
  void (* cut_clipboard)      (GtkText         *self);
  void (* copy_clipboard)     (GtkText         *self);
  void (* paste_clipboard)    (GtkText         *self);
  void (* toggle_overwrite)   (GtkText         *self);
  void (* insert_emoji)       (GtkText         *self);
  void (* undo)               (GtkText         *self);
  void (* redo)               (GtkText         *self);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_get_display_text</NAME>
<RETURNS>char *</RETURNS>
GtkText    *entry, int         start_pos, int         end_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_enter_text</NAME>
<RETURNS>void</RETURNS>
GtkText    *entry, const char *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_positions</NAME>
<RETURNS>void</RETURNS>
GtkText    *entry, int         current_pos, int         selection_bound
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
GtkText    *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_layout_offsets</NAME>
<RETURNS>void</RETURNS>
GtkText    *entry, int        *x, int        *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_reset_im_context</NAME>
<RETURNS>void</RETURNS>
GtkText    *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_key_controller</NAME>
<RETURNS>GtkEventController *</RETURNS>
GtkText    *entry
</FUNCTION>
<STRUCT>
<NAME>GtkTextTagInfo</NAME>
struct _GtkTextTagInfo {
  GtkTextTag *tag;
  GtkTextBTreeNode *tag_root; /* highest-level node containing the tag */
  gint toggle_count;      /* total toggles of this tag below tag_root */
};
</STRUCT>
<STRUCT>
<NAME>GtkTextToggleBody</NAME>
struct _GtkTextToggleBody {
  GtkTextTagInfo *info;             /* Tag that starts or ends here. */
  gboolean inNodeCounts;             /* TRUE means this toggle has been
                                      * accounted for in node toggle
                                      * counts; FALSE means it hasn't, yet. */
};
</STRUCT>
<USER_FUNCTION>
<NAME>GtkTextSegSplitFunc</NAME>
<RETURNS>GtkTextLineSegment *</RETURNS>
GtkTextLineSegment *seg, gint                index
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTextSegDeleteFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextLineSegment *seg, GtkTextLine        *line, gboolean            tree_gone
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTextSegCleanupFunc</NAME>
<RETURNS>GtkTextLineSegment *</RETURNS>
GtkTextLineSegment *seg, GtkTextLine        *line
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTextSegLineChangeFunc</NAME>
<RETURNS>void</RETURNS>
GtkTextLineSegment *seg, GtkTextLine        *line
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTextSegCheckFunc</NAME>
<RETURNS>void</RETURNS>
GtkTextLineSegment *seg, GtkTextLine        *line
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTextLineSegmentClass</NAME>
struct _GtkTextLineSegmentClass {
  const char *name;                     /* Name of this kind of segment. */
  gboolean leftGravity;                 /* If a segment has zero size (e.g. a
                                         * mark or tag toggle), does it
                                         * attach to character to its left
                                         * or right?  1 means left, 0 means
                                         * right. */
  GtkTextSegSplitFunc splitFunc;        /* Procedure to split large segment
                                         * into two smaller ones. */
  GtkTextSegDeleteFunc deleteFunc;      /* Procedure to call to delete
                                         * segment. */
  GtkTextSegCleanupFunc cleanupFunc;   /* After any change to a line, this
                                        * procedure is invoked for all
                                        * segments left in the line to
                                        * perform any cleanup they wish
                                        * (e.g. joining neighboring
                                        * segments). */
  GtkTextSegLineChangeFunc lineChangeFunc;
  /* Invoked when a segment is about
   * to be moved from its current line
   * to an earlier line because of
   * a deletion.  The line is that
   * for the segment's old line.
   * CleanupFunc will be invoked after
   * the deletion is finished. */

  GtkTextSegCheckFunc checkFunc;       /* Called during consistency checks
                                        * to check internal consistency of
                                        * segment. */
};
</STRUCT>
<STRUCT>
<NAME>GtkTextLineSegment</NAME>
struct _GtkTextLineSegment {
  const GtkTextLineSegmentClass *type;  /* Pointer to record describing
                                         * segment's type. */
  GtkTextLineSegment *next;             /* Next in list of segments for this
                                         * line, or NULL for end of list. */

  int char_count;                       /* # of chars of index space occupied */

  int byte_count;                       /* Size of this segment (# of bytes
                                         * of index space it occupies). */
  union {
    char chars[4];                      /* Characters that make up character
                                         * info.  Actual length varies to
                                         * hold as many characters as needed.*/
    GtkTextToggleBody toggle;           /* Information about tag toggle. */
    GtkTextMarkBody mark;               /* Information about mark. */
    GtkTextPaintable paintable;         /* Child texture */
    GtkTextChildBody child;             /* Child widget */
  } body;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_line_segment_split</NAME>
<RETURNS>GtkTextLineSegment *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT_TAG</NAME>
#define GTK_TYPE_TEXT_TAG            (gtk_text_tag_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_TAG</NAME>
#define GTK_TEXT_TAG(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_TAG, GtkTextTag))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_TAG_CLASS</NAME>
#define GTK_TEXT_TAG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_TAG, GtkTextTagClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_TAG</NAME>
#define GTK_IS_TEXT_TAG(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_TAG))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_TAG_CLASS</NAME>
#define GTK_IS_TEXT_TAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_TAG))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_TAG_GET_CLASS</NAME>
#define GTK_TEXT_TAG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_TAG, GtkTextTagClass))
</MACRO>
<STRUCT>
<NAME>GtkTextTag</NAME>
struct _GtkTextTag
{
  GObject parent_instance;

  GtkTextTagPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextTagClass</NAME>
struct _GtkTextTagClass
{
  GObjectClass parent_class;

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_tag_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_new</NAME>
<RETURNS>GtkTextTag *</RETURNS>
const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_get_priority</NAME>
<RETURNS>gint</RETURNS>
GtkTextTag        *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_set_priority</NAME>
<RETURNS>void</RETURNS>
GtkTextTag        *tag, gint               priority
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_changed</NAME>
<RETURNS>void</RETURNS>
GtkTextTag        *tag, gboolean           size_changed
</FUNCTION>
<STRUCT>
<NAME>GtkTextIter</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextTagPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextTagTable</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkTextTagTableForeach</NAME>
<RETURNS>void</RETURNS>
GtkTextTag *tag, gpointer data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT_TAG_TABLE</NAME>
#define GTK_TYPE_TEXT_TAG_TABLE            (gtk_text_tag_table_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_TAG_TABLE</NAME>
#define GTK_TEXT_TAG_TABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTable))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_TAG_TABLE</NAME>
#define GTK_IS_TEXT_TAG_TABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_TAG_TABLE))
</MACRO>
<FUNCTION>
<NAME>gtk_text_tag_table_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_new</NAME>
<RETURNS>GtkTextTagTable *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_add</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextTagTable        *table, GtkTextTag             *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_remove</NAME>
<RETURNS>void</RETURNS>
GtkTextTagTable        *table, GtkTextTag             *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_lookup</NAME>
<RETURNS>GtkTextTag *</RETURNS>
GtkTextTagTable        *table, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_foreach</NAME>
<RETURNS>void</RETURNS>
GtkTextTagTable        *table, GtkTextTagTableForeach  func, gpointer                data
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_get_size</NAME>
<RETURNS>gint</RETURNS>
GtkTextTagTable        *table
</FUNCTION>
<MACRO>
<NAME>GTK_TEXT_UNKNOWN_CHAR</NAME>
#define GTK_TEXT_UNKNOWN_CHAR 0xFFFC
</MACRO>
<MACRO>
<NAME>GTK_TEXT_UNKNOWN_CHAR_UTF8_LEN</NAME>
#define GTK_TEXT_UNKNOWN_CHAR_UTF8_LEN 3
</MACRO>
<FUNCTION>
<NAME>gtk_text_unknown_char_utf8_gtk_tests_only</NAME>
<RETURNS>const gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_byte_begins_utf8_char</NAME>
<RETURNS>gboolean</RETURNS>
const gchar *byte
</FUNCTION>
<STRUCT>
<NAME>GtkTextCounter</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextLineSegment</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextLineSegmentClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextMarkBody</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextToggleBody</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_text_util_create_drag_icon</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkWidget     *widget, gchar         *text, gssize         len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_util_create_rich_drag_icon</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkWidget     *widget, GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT_VIEW</NAME>
#define GTK_TYPE_TEXT_VIEW             (gtk_text_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW</NAME>
#define GTK_TEXT_VIEW(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_VIEW, GtkTextView))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW_CLASS</NAME>
#define GTK_TEXT_VIEW_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW, GtkTextViewClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_VIEW</NAME>
#define GTK_IS_TEXT_VIEW(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_VIEW_CLASS</NAME>
#define GTK_IS_TEXT_VIEW_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW_GET_CLASS</NAME>
#define GTK_TEXT_VIEW_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_VIEW, GtkTextViewClass))
</MACRO>
<ENUM>
<NAME>GtkTextWindowType</NAME>
typedef enum
{
  GTK_TEXT_WINDOW_WIDGET = 1,
  GTK_TEXT_WINDOW_TEXT,
  GTK_TEXT_WINDOW_LEFT,
  GTK_TEXT_WINDOW_RIGHT,
  GTK_TEXT_WINDOW_TOP,
  GTK_TEXT_WINDOW_BOTTOM
} GtkTextWindowType;
</ENUM>
<ENUM>
<NAME>GtkTextViewLayer</NAME>
typedef enum
{
  GTK_TEXT_VIEW_LAYER_BELOW_TEXT,
  GTK_TEXT_VIEW_LAYER_ABOVE_TEXT
} GtkTextViewLayer;
</ENUM>
<ENUM>
<NAME>GtkTextExtendSelection</NAME>
typedef enum
{
  GTK_TEXT_EXTEND_SELECTION_WORD,
  GTK_TEXT_EXTEND_SELECTION_LINE
} GtkTextExtendSelection;
</ENUM>
<MACRO>
<NAME>GTK_TEXT_VIEW_PRIORITY_VALIDATE</NAME>
#define GTK_TEXT_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5)
</MACRO>
<STRUCT>
<NAME>GtkTextView</NAME>
struct _GtkTextView
{
  GtkWidget parent_instance;

  /*< private >*/

  GtkTextViewPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextViewClass</NAME>
struct _GtkTextViewClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  void (* move_cursor)           (GtkTextView      *text_view,
                                  GtkMovementStep   step,
                                  gint              count,
                                  gboolean          extend_selection);
  void (* set_anchor)            (GtkTextView      *text_view);
  void (* insert_at_cursor)      (GtkTextView      *text_view,
                                  const gchar      *str);
  void (* delete_from_cursor)    (GtkTextView      *text_view,
                                  GtkDeleteType     type,
                                  gint              count);
  void (* backspace)             (GtkTextView      *text_view);
  void (* cut_clipboard)         (GtkTextView      *text_view);
  void (* copy_clipboard)        (GtkTextView      *text_view);
  void (* paste_clipboard)       (GtkTextView      *text_view);
  void (* toggle_overwrite)      (GtkTextView      *text_view);
  GtkTextBuffer * (* create_buffer) (GtkTextView   *text_view);
  void (* snapshot_layer)        (GtkTextView      *text_view,
			          GtkTextViewLayer  layer,
			          GtkSnapshot      *snapshot);
  gboolean (* extend_selection)  (GtkTextView            *text_view,
                                  GtkTextExtendSelection  granularity,
                                  const GtkTextIter      *location,
                                  GtkTextIter            *start,
                                  GtkTextIter            *end);
  void (* insert_emoji)          (GtkTextView      *text_view);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_view_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_new_with_buffer</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_buffer</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view, GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_buffer</NAME>
<RETURNS>GtkTextBuffer *</RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_scroll_to_iter</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView   *text_view, GtkTextIter   *iter, gdouble        within_margin, gboolean       use_align, gdouble        xalign, gdouble        yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_scroll_to_mark</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view, GtkTextMark   *mark, gdouble        within_margin, gboolean       use_align, gdouble        xalign, gdouble        yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_scroll_mark_onscreen</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view, GtkTextMark   *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_move_mark_onscreen</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView   *text_view, GtkTextMark   *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_place_cursor_onscreen</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_visible_rect</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view, GdkRectangle  *visible_rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_cursor_visible</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_cursor_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_reset_cursor_blink</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_cursor_locations</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, const GtkTextIter *iter, GdkRectangle      *strong, GdkRectangle      *weak
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_iter_location</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view, const GtkTextIter *iter, GdkRectangle  *location
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_iter_at_location</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView   *text_view, GtkTextIter   *iter, gint           x, gint           y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_iter_at_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView   *text_view, GtkTextIter   *iter, gint          *trailing, gint           x, gint           y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_line_yrange</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, const GtkTextIter *iter, gint              *y, gint              *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_line_at_y</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, GtkTextIter       *target_iter, gint               y, gint              *line_top
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_buffer_to_window_coords</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, GtkTextWindowType  win, gint               buffer_x, gint               buffer_y, gint              *window_x, gint              *window_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_window_to_buffer_coords</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, GtkTextWindowType  win, gint               window_x, gint               window_y, gint              *buffer_x, gint              *buffer_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_forward_display_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_backward_display_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_forward_display_line_end</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_backward_display_line_start</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_starts_display_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView       *text_view, const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_move_visually</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter, gint               count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_im_context_filter_keypress</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView    *text_view, GdkEvent       *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_reset_im_context</NAME>
<RETURNS>void</RETURNS>
GtkTextView    *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_gutter</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTextView          *text_view, GtkTextWindowType     win
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_gutter</NAME>
<RETURNS>void</RETURNS>
GtkTextView          *text_view, GtkTextWindowType     win, GtkWidget            *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_add_child_at_anchor</NAME>
<RETURNS>void</RETURNS>
GtkTextView          *text_view, GtkWidget            *child, GtkTextChildAnchor   *anchor
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_add_overlay</NAME>
<RETURNS>void</RETURNS>
GtkTextView          *text_view, GtkWidget            *child, gint                  xpos, gint                  ypos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_move_overlay</NAME>
<RETURNS>void</RETURNS>
GtkTextView          *text_view, GtkWidget            *child, gint                  xpos, gint                  ypos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_remove</NAME>
<RETURNS>void</RETURNS>
GtkTextView          *text_view, GtkWidget            *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_wrap_mode</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, GtkWrapMode       wrap_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_wrap_mode</NAME>
<RETURNS>GtkWrapMode</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_editable</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gboolean          setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_editable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_overwrite</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gboolean          overwrite
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_overwrite</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_accepts_tab</NAME>
<RETURNS>void</RETURNS>
GtkTextView	*text_view, gboolean		 accepts_tab
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_accepts_tab</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView	*text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_above_lines</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              pixels_above_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_above_lines</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_below_lines</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              pixels_below_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_below_lines</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_inside_wrap</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              pixels_inside_wrap
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_inside_wrap</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_justification</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, GtkJustification  justification
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_justification</NAME>
<RETURNS>GtkJustification</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_left_margin</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              left_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_left_margin</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_right_margin</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              right_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_right_margin</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_top_margin</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              top_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_top_margin</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_bottom_margin</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              bottom_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_bottom_margin</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_indent</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gint              indent
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_indent</NAME>
<RETURNS>gint</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_tabs</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, PangoTabArray    *tabs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_tabs</NAME>
<RETURNS>PangoTabArray *</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_input_purpose</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, GtkInputPurpose   purpose
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_input_purpose</NAME>
<RETURNS>GtkInputPurpose</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_input_hints</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, GtkInputHints     hints
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_input_hints</NAME>
<RETURNS>GtkInputHints</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_monospace</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, gboolean          monospace
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_monospace</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_extra_menu</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, GMenuModel       *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_extra_menu</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<STRUCT>
<NAME>GtkTextViewPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TEXT_VIEW_CHILD</NAME>
#define GTK_TYPE_TEXT_VIEW_CHILD (gtk_text_view_child_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_text_view_child_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTextWindowType  window_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_child_get_window_type</NAME>
<RETURNS>GtkTextWindowType</RETURNS>
GtkTextViewChild  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_child_add</NAME>
<RETURNS>void</RETURNS>
GtkTextViewChild  *self, GtkWidget         *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_child_remove</NAME>
<RETURNS>void</RETURNS>
GtkTextViewChild  *self, GtkWidget         *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_child_add_overlay</NAME>
<RETURNS>void</RETURNS>
GtkTextViewChild  *self, GtkWidget         *widget, int                xpos, int                ypos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_child_move_overlay</NAME>
<RETURNS>void</RETURNS>
GtkTextViewChild  *self, GtkWidget         *widget, int                xpos, int                ypos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_child_set_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextViewChild  *child, int                xoffset, int                yoffset
</FUNCTION>
<STRUCT>
<NAME>GtkTextViewChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOGGLE_BUTTON</NAME>
#define GTK_TYPE_TOGGLE_BUTTON                  (gtk_toggle_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_BUTTON</NAME>
#define GTK_TOGGLE_BUTTON(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButton))
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_BUTTON_CLASS</NAME>
#define GTK_TOGGLE_BUTTON_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOGGLE_BUTTON</NAME>
#define GTK_IS_TOGGLE_BUTTON(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOGGLE_BUTTON_CLASS</NAME>
#define GTK_IS_TOGGLE_BUTTON_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_BUTTON_GET_CLASS</NAME>
#define GTK_TOGGLE_BUTTON_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOGGLE_BUTTON, GtkToggleButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkToggleButton</NAME>
struct _GtkToggleButton
{
  /*< private >*/
  GtkButton button;
};
</STRUCT>
<STRUCT>
<NAME>GtkToggleButtonClass</NAME>
struct _GtkToggleButtonClass
{
  GtkButtonClass parent_class;

  void (* toggled) (GtkToggleButton *toggle_button);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_toggle_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_new_with_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const gchar     *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_set_active</NAME>
<RETURNS>void</RETURNS>
GtkToggleButton *toggle_button, gboolean         is_active
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_get_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkToggleButton *toggle_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_toggled</NAME>
<RETURNS>void</RETURNS>
GtkToggleButton *toggle_button
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TOOLTIP</NAME>
#define GTK_TYPE_TOOLTIP                 (gtk_tooltip_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOOLTIP</NAME>
#define GTK_TOOLTIP(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOLTIP, GtkTooltip))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOLTIP</NAME>
#define GTK_IS_TOOLTIP(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOLTIP))
</MACRO>
<FUNCTION>
<NAME>gtk_tooltip_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_markup</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, const gchar        *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_text</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, const gchar        *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_icon</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, GdkPaintable       *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_icon_from_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, const gchar        *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_icon_from_gicon</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, GIcon              *gicon
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_custom</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, GtkWidget          *custom_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_tip_area</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, const GdkRectangle *rect
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TRASH_MONITOR</NAME>
#define GTK_TYPE_TRASH_MONITOR			(_gtk_trash_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TRASH_MONITOR</NAME>
#define GTK_TRASH_MONITOR(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TRASH_MONITOR, GtkTrashMonitor))
</MACRO>
<MACRO>
<NAME>GTK_TRASH_MONITOR_CLASS</NAME>
#define GTK_TRASH_MONITOR_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TRASH_MONITOR, GtkTrashMonitorClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TRASH_MONITOR</NAME>
#define GTK_IS_TRASH_MONITOR(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TRASH_MONITOR))
</MACRO>
<MACRO>
<NAME>GTK_IS_TRASH_MONITOR_CLASS</NAME>
#define GTK_IS_TRASH_MONITOR_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TRASH_MONITOR))
</MACRO>
<MACRO>
<NAME>GTK_TRASH_MONITOR_GET_CLASS</NAME>
#define GTK_TRASH_MONITOR_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TRASH_MONITOR, GtkTrashMonitorClass))
</MACRO>
<STRUCT>
<NAME>GtkTrashMonitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTrashMonitorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeDataList</NAME>
struct _GtkTreeDataList
{
  GtkTreeDataList *next;

  union {
    gint	   v_int;
    gint8          v_char;
    guint8         v_uchar;
    guint	   v_uint;
    glong	   v_long;
    gulong	   v_ulong;
    gint64	   v_int64;
    guint64        v_uint64;
    gfloat	   v_float;
    gdouble        v_double;
    gpointer	   v_pointer;
  } data;
};
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_ROW_DATA</NAME>
#define GTK_TYPE_TREE_ROW_DATA (gtk_tree_row_data_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_tree_row_data_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TREE_DRAG_SOURCE</NAME>
#define GTK_TYPE_TREE_DRAG_SOURCE            (gtk_tree_drag_source_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_DRAG_SOURCE</NAME>
#define GTK_TREE_DRAG_SOURCE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_DRAG_SOURCE, GtkTreeDragSource))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_DRAG_SOURCE</NAME>
#define GTK_IS_TREE_DRAG_SOURCE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_DRAG_SOURCE))
</MACRO>
<MACRO>
<NAME>GTK_TREE_DRAG_SOURCE_GET_IFACE</NAME>
#define GTK_TREE_DRAG_SOURCE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_DRAG_SOURCE, GtkTreeDragSourceIface))
</MACRO>
<STRUCT>
<NAME>GtkTreeDragSourceIface</NAME>
struct _GtkTreeDragSourceIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

  /* VTable - not signals */

  gboolean     (* row_draggable)        (GtkTreeDragSource   *drag_source,
                                         GtkTreePath         *path);

  GdkContentProvider * (* drag_data_get)(GtkTreeDragSource   *drag_source,
                                         GtkTreePath         *path);

  gboolean     (* drag_data_delete)     (GtkTreeDragSource *drag_source,
                                         GtkTreePath       *path);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_drag_source_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_drag_source_row_draggable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeDragSource *drag_source, GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_drag_source_drag_data_delete</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeDragSource *drag_source, GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_drag_source_drag_data_get</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GtkTreeDragSource *drag_source, GtkTreePath       *path
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TREE_DRAG_DEST</NAME>
#define GTK_TYPE_TREE_DRAG_DEST            (gtk_tree_drag_dest_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_DRAG_DEST</NAME>
#define GTK_TREE_DRAG_DEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_DRAG_DEST, GtkTreeDragDest))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_DRAG_DEST</NAME>
#define GTK_IS_TREE_DRAG_DEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_DRAG_DEST))
</MACRO>
<MACRO>
<NAME>GTK_TREE_DRAG_DEST_GET_IFACE</NAME>
#define GTK_TREE_DRAG_DEST_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_DRAG_DEST, GtkTreeDragDestIface))
</MACRO>
<STRUCT>
<NAME>GtkTreeDragDestIface</NAME>
struct _GtkTreeDragDestIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

  /* VTable - not signals */

  gboolean     (* drag_data_received) (GtkTreeDragDest   *drag_dest,
                                       GtkTreePath       *dest,
                                       const GValue      *value);

  gboolean     (* row_drop_possible)  (GtkTreeDragDest   *drag_dest,
                                       GtkTreePath       *dest_path,
                                       const GValue      *value);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_drag_dest_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_drag_dest_drag_data_received</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeDragDest   *drag_dest, GtkTreePath       *dest, const GValue      *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_drag_dest_row_drop_possible</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeDragDest   *drag_dest, GtkTreePath       *dest_path, const GValue      *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_create_row_drag_content</NAME>
<RETURNS>GdkContentProvider *</RETURNS>
GtkTreeModel      *tree_model, GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_get_row_drag_data</NAME>
<RETURNS>gboolean</RETURNS>
const GValue      *value, GtkTreeModel     **tree_model, GtkTreePath      **path
</FUNCTION>
<STRUCT>
<NAME>GtkTreeDragDest</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeDragSource</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_LIST_MODEL</NAME>
#define GTK_TYPE_TREE_LIST_MODEL (gtk_tree_list_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_LIST_ROW</NAME>
#define GTK_TYPE_TREE_LIST_ROW (gtk_tree_list_row_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeListModelCreateModelFunc</NAME>
<RETURNS>GListModel *</RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_new</NAME>
<RETURNS>GtkTreeListModel *</RETURNS>
gboolean                passthrough, GListModel             *root, gboolean                autoexpand, GtkTreeListModelCreateModelFunc create_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkTreeListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_passthrough</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_set_autoexpand</NAME>
<RETURNS>void</RETURNS>
GtkTreeListModel       *self, gboolean                autoexpand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_autoexpand</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_child_row</NAME>
<RETURNS>GtkTreeListRow *</RETURNS>
GtkTreeListModel       *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_row</NAME>
<RETURNS>GtkTreeListRow *</RETURNS>
GtkTreeListModel       *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_item</NAME>
<RETURNS>gpointer</RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_set_expanded</NAME>
<RETURNS>void</RETURNS>
GtkTreeListRow         *self, gboolean                expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_expanded</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_is_expandable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_position</NAME>
<RETURNS>guint</RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_depth</NAME>
<RETURNS>guint</RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_children</NAME>
<RETURNS>GListModel *</RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_parent</NAME>
<RETURNS>GtkTreeListRow *</RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_child_row</NAME>
<RETURNS>GtkTreeListRow *</RETURNS>
GtkTreeListRow         *self, guint                   position
</FUNCTION>
<STRUCT>
<NAME>GtkTreeListModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeListRow</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_MODEL</NAME>
#define GTK_TYPE_TREE_MODEL            (gtk_tree_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL</NAME>
#define GTK_TREE_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL, GtkTreeModel))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL</NAME>
#define GTK_IS_TREE_MODEL(obj)	       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_GET_IFACE</NAME>
#define GTK_TREE_MODEL_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_MODEL, GtkTreeModelIface))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_ITER</NAME>
#define GTK_TYPE_TREE_ITER             (gtk_tree_iter_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_PATH</NAME>
#define GTK_TYPE_TREE_PATH             (gtk_tree_path_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_ROW_REFERENCE</NAME>
#define GTK_TYPE_TREE_ROW_REFERENCE    (gtk_tree_row_reference_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeModelForeachFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data
</USER_FUNCTION>
<ENUM>
<NAME>GtkTreeModelFlags</NAME>
typedef enum
{
  GTK_TREE_MODEL_ITERS_PERSIST = 1 << 0,
  GTK_TREE_MODEL_LIST_ONLY = 1 << 1
} GtkTreeModelFlags;
</ENUM>
<STRUCT>
<NAME>GtkTreeIter</NAME>
struct _GtkTreeIter
{
  gint stamp;
  gpointer user_data;
  gpointer user_data2;
  gpointer user_data3;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeModelIface</NAME>
struct _GtkTreeModelIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

  /* Signals */
  void         (* row_changed)           (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter);
  void         (* row_inserted)          (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter);
  void         (* row_has_child_toggled) (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter);
  void         (* row_deleted)           (GtkTreeModel *tree_model,
					  GtkTreePath  *path);
  void         (* rows_reordered)        (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter,
					  gint         *new_order);

  /* Virtual Table */
  GtkTreeModelFlags (* get_flags)  (GtkTreeModel *tree_model);

  gint         (* get_n_columns)   (GtkTreeModel *tree_model);
  GType        (* get_column_type) (GtkTreeModel *tree_model,
				    gint          index_);
  gboolean     (* get_iter)        (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreePath  *path);
  GtkTreePath *(* get_path)        (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  void         (* get_value)       (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    gint          column,
				    GValue       *value);
  gboolean     (* iter_next)       (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gboolean     (* iter_previous)   (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gboolean     (* iter_children)   (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreeIter  *parent);
  gboolean     (* iter_has_child)  (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gint         (* iter_n_children) (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gboolean     (* iter_nth_child)  (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreeIter  *parent,
				    gint          n);
  gboolean     (* iter_parent)     (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreeIter  *child);
  void         (* ref_node)        (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  void         (* unref_node)      (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_path_new</NAME>
<RETURNS>GtkTreePath *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_new_from_string</NAME>
<RETURNS>GtkTreePath *</RETURNS>
const gchar       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_new_from_indices</NAME>
<RETURNS>GtkTreePath *</RETURNS>
gint               first_index, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_new_from_indicesv</NAME>
<RETURNS>GtkTreePath *</RETURNS>
gint             *indices, gsize             length
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_to_string</NAME>
<RETURNS>gchar *</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_new_first</NAME>
<RETURNS>GtkTreePath *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_append_index</NAME>
<RETURNS>void</RETURNS>
GtkTreePath       *path, gint               index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_prepend_index</NAME>
<RETURNS>void</RETURNS>
GtkTreePath       *path, gint               index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_get_depth</NAME>
<RETURNS>gint</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_get_indices</NAME>
<RETURNS>gint *</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_get_indices_with_depth</NAME>
<RETURNS>gint *</RETURNS>
GtkTreePath *path, gint        *depth
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_free</NAME>
<RETURNS>void</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_copy</NAME>
<RETURNS>GtkTreePath *</RETURNS>
const GtkTreePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_compare</NAME>
<RETURNS>gint</RETURNS>
const GtkTreePath *a, const GtkTreePath *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_next</NAME>
<RETURNS>void</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_prev</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_up</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_down</NAME>
<RETURNS>void</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_is_ancestor</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreePath       *path, GtkTreePath       *descendant
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_is_descendant</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreePath       *path, GtkTreePath       *ancestor
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_new</NAME>
<RETURNS>GtkTreeRowReference *</RETURNS>
GtkTreeModel        *model, GtkTreePath         *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_new_proxy</NAME>
<RETURNS>GtkTreeRowReference *</RETURNS>
GObject             *proxy, GtkTreeModel        *model, GtkTreePath         *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_get_path</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkTreeRowReference *reference
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeRowReference *reference
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_valid</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeRowReference *reference
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_copy</NAME>
<RETURNS>GtkTreeRowReference *</RETURNS>
GtkTreeRowReference *reference
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_free</NAME>
<RETURNS>void</RETURNS>
GtkTreeRowReference *reference
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_inserted</NAME>
<RETURNS>void</RETURNS>
GObject     *proxy, GtkTreePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_deleted</NAME>
<RETURNS>void</RETURNS>
GObject     *proxy, GtkTreePath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_row_reference_reordered</NAME>
<RETURNS>void</RETURNS>
GObject     *proxy, GtkTreePath *path, GtkTreeIter *iter, gint        *new_order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_iter_copy</NAME>
<RETURNS>GtkTreeIter *</RETURNS>
GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_iter_free</NAME>
<RETURNS>void</RETURNS>
GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_iter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_flags</NAME>
<RETURNS>GtkTreeModelFlags</RETURNS>
GtkTreeModel *tree_model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_n_columns</NAME>
<RETURNS>gint</RETURNS>
GtkTreeModel *tree_model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_column_type</NAME>
<RETURNS>GType</RETURNS>
GtkTreeModel *tree_model, gint          index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_iter</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, GtkTreePath  *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_iter_from_string</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, const gchar  *path_string
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_string_from_iter</NAME>
<RETURNS>gchar *</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_iter_first</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_path</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_value</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, gint          column, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_iter_previous</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_iter_next</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_iter_children</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, GtkTreeIter  *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_iter_has_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_iter_n_children</NAME>
<RETURNS>gint</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_iter_nth_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, GtkTreeIter  *parent, gint          n
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_iter_parent</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, GtkTreeIter  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_ref_node</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_unref_node</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_valist</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreeIter  *iter, va_list       var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_foreach</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel            *model, GtkTreeModelForeachFunc  func, gpointer                 user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_row_changed</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreePath  *path, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_row_inserted</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreePath  *path, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_row_has_child_toggled</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreePath  *path, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_row_deleted</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreePath  *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_rows_reordered</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreePath  *path, GtkTreeIter  *iter, gint         *new_order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_rows_reordered_with_length</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreePath  *path, GtkTreeIter  *iter, gint         *new_order, gint          length
</FUNCTION>
<STRUCT>
<NAME>GtkTreeModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreePath</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeRowReference</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_MODEL_FILTER</NAME>
#define GTK_TYPE_TREE_MODEL_FILTER              (gtk_tree_model_filter_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_FILTER</NAME>
#define GTK_TREE_MODEL_FILTER(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL_FILTER, GtkTreeModelFilter))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_FILTER_CLASS</NAME>
#define GTK_TREE_MODEL_FILTER_CLASS(vtable)     (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_TREE_MODEL_FILTER, GtkTreeModelFilterClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL_FILTER</NAME>
#define GTK_IS_TREE_MODEL_FILTER(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL_FILTER))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL_FILTER_CLASS</NAME>
#define GTK_IS_TREE_MODEL_FILTER_CLASS(vtable)  (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_TREE_MODEL_FILTER))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_FILTER_GET_CLASS</NAME>
#define GTK_TREE_MODEL_FILTER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_MODEL_FILTER, GtkTreeModelFilterClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeModelFilterVisibleFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *model, GtkTreeIter  *iter, gpointer      data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeModelFilterModifyFunc</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *model, GtkTreeIter  *iter, GValue       *value, gint          column, gpointer      data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTreeModelFilter</NAME>
struct _GtkTreeModelFilter
{
  GObject parent;

  /*< private >*/
  GtkTreeModelFilterPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeModelFilterClass</NAME>
struct _GtkTreeModelFilterClass
{
  GObjectClass parent_class;

  gboolean (* visible) (GtkTreeModelFilter *self,
                        GtkTreeModel       *child_model,
                        GtkTreeIter        *iter);
  void (* modify) (GtkTreeModelFilter *self,
                   GtkTreeModel       *child_model,
                   GtkTreeIter        *iter,
                   GValue             *value,
                   gint                column);

  /*< private >*/

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_model_filter_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_new</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeModel                 *child_model, GtkTreePath                  *root
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_set_visible_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelFilter           *filter, GtkTreeModelFilterVisibleFunc func, gpointer                      data, GDestroyNotify                destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_set_modify_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelFilter           *filter, gint                          n_columns, GType                        *types, GtkTreeModelFilterModifyFunc  func, gpointer                      data, GDestroyNotify                destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_set_visible_column</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelFilter           *filter, gint                          column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeModelFilter           *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_convert_child_iter_to_iter</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModelFilter           *filter, GtkTreeIter                  *filter_iter, GtkTreeIter                  *child_iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_convert_iter_to_child_iter</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelFilter           *filter, GtkTreeIter                  *child_iter, GtkTreeIter                  *filter_iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_convert_child_path_to_path</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkTreeModelFilter           *filter, GtkTreePath                  *child_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_convert_path_to_child_path</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkTreeModelFilter           *filter, GtkTreePath                  *filter_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_refilter</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelFilter           *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_filter_clear_cache</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelFilter           *filter
</FUNCTION>
<STRUCT>
<NAME>GtkTreeModelFilterPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_MODEL_SORT</NAME>
#define GTK_TYPE_TREE_MODEL_SORT			(gtk_tree_model_sort_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_SORT</NAME>
#define GTK_TREE_MODEL_SORT(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL_SORT, GtkTreeModelSort))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_SORT_CLASS</NAME>
#define GTK_TREE_MODEL_SORT_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_MODEL_SORT, GtkTreeModelSortClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL_SORT</NAME>
#define GTK_IS_TREE_MODEL_SORT(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL_SORT))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL_SORT_CLASS</NAME>
#define GTK_IS_TREE_MODEL_SORT_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_MODEL_SORT))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_SORT_GET_CLASS</NAME>
#define GTK_TREE_MODEL_SORT_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_MODEL_SORT, GtkTreeModelSortClass))
</MACRO>
<STRUCT>
<NAME>GtkTreeModelSort</NAME>
struct _GtkTreeModelSort
{
  GObject parent;

  /* < private > */
  GtkTreeModelSortPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeModelSortClass</NAME>
struct _GtkTreeModelSortClass
{
  GObjectClass parent_class;

  /* < private > */
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_model_sort_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_new_with_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeModel     *child_model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeModelSort *tree_model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_convert_child_path_to_path</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkTreeModelSort *tree_model_sort, GtkTreePath      *child_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_convert_child_iter_to_iter</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModelSort *tree_model_sort, GtkTreeIter      *sort_iter, GtkTreeIter      *child_iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_convert_path_to_child_path</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkTreeModelSort *tree_model_sort, GtkTreePath      *sorted_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_convert_iter_to_child_iter</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelSort *tree_model_sort, GtkTreeIter      *child_iter, GtkTreeIter      *sorted_iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_reset_default_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelSort *tree_model_sort
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_clear_cache</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelSort *tree_model_sort
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_sort_iter_is_valid</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModelSort *tree_model_sort, GtkTreeIter      *iter
</FUNCTION>
<STRUCT>
<NAME>GtkTreeModelSortPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_POPOVER</NAME>
#define GTK_TYPE_TREE_POPOVER         (gtk_tree_popover_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_tree_popover_set_model</NAME>
<RETURNS>void</RETURNS>
GtkTreePopover              *popover, GtkTreeModel                *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_popover_set_row_separator_func</NAME>
<RETURNS>void</RETURNS>
GtkTreePopover              *popover, GtkTreeViewRowSeparatorFunc  func, gpointer                     data, GDestroyNotify               destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_popover_set_active</NAME>
<RETURNS>void</RETURNS>
GtkTreePopover              *popover, int                          item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_popover_open_submenu</NAME>
<RETURNS>void</RETURNS>
GtkTreePopover              *popover, const char                  *name
</FUNCTION>
<STRUCT>
<NAME>GtkTreePopover</NAME>
</STRUCT>
<ENUM>
<NAME>GtkTreeRBNodeColor</NAME>
typedef enum
{
  GTK_TREE_RBNODE_BLACK = 1 << 0,
  GTK_TREE_RBNODE_RED = 1 << 1,
  GTK_TREE_RBNODE_IS_PARENT = 1 << 2,
  GTK_TREE_RBNODE_IS_SELECTED = 1 << 3,
  GTK_TREE_RBNODE_IS_PRELIT = 1 << 4,
  GTK_TREE_RBNODE_INVALID = 1 << 7,
  GTK_TREE_RBNODE_COLUMN_INVALID = 1 << 8,
  GTK_TREE_RBNODE_DESCENDANTS_INVALID = 1 << 9,
  GTK_TREE_RBNODE_NON_COLORS = GTK_TREE_RBNODE_IS_PARENT |
                            GTK_TREE_RBNODE_IS_SELECTED |
                            GTK_TREE_RBNODE_IS_PRELIT |
                          GTK_TREE_RBNODE_INVALID |
                          GTK_TREE_RBNODE_COLUMN_INVALID |
                          GTK_TREE_RBNODE_DESCENDANTS_INVALID
} GtkTreeRBNodeColor;
</ENUM>
<USER_FUNCTION>
<NAME>GtkTreeRBTreeTraverseFunc</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree  *tree, GtkTreeRBNode  *node, gpointer  data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTreeRBTree</NAME>
struct _GtkTreeRBTree
{
  GtkTreeRBNode *root;
  GtkTreeRBTree *parent_tree;
  GtkTreeRBNode *parent_node;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeRBNode</NAME>
struct _GtkTreeRBNode
{
  guint flags : 14;

  /* count is the number of nodes beneath us, plus 1 for ourselves.
   * i.e. node->left->count + node->right->count + 1
   */
  gint count;

  GtkTreeRBNode *left;
  GtkTreeRBNode *right;
  GtkTreeRBNode *parent;

  /* count the number of total nodes beneath us, including nodes
   * of children trees.
   * i.e. node->left->count + node->right->count + node->children->root->count + 1
   */
  guint total_count;
  
  /* this is the total of sizes of
   * node->left, node->right, our own height, and the height
   * of all trees in ->children, iff children exists because
   * the thing is expanded.
   */
  gint offset;

  /* Child trees */
  GtkTreeRBTree *children;
};
</STRUCT>
<MACRO>
<NAME>GTK_TREE_RBNODE_GET_COLOR</NAME>
#define GTK_TREE_RBNODE_GET_COLOR(node)                (node?(((node->flags&GTK_TREE_RBNODE_RED)==GTK_TREE_RBNODE_RED)?GTK_TREE_RBNODE_RED:GTK_TREE_RBNODE_BLACK):GTK_TREE_RBNODE_BLACK)
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_SET_COLOR</NAME>
#define GTK_TREE_RBNODE_SET_COLOR(node,color)         if((node->flags&color)!=color)node->flags=node->flags^(GTK_TREE_RBNODE_RED|GTK_TREE_RBNODE_BLACK)
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_GET_HEIGHT</NAME>
#define GTK_TREE_RBNODE_GET_HEIGHT(node)                 (node->offset-(node->left->offset+node->right->offset+(node->children?node->children->root->offset:0)))
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_SET_FLAG</NAME>
#define GTK_TREE_RBNODE_SET_FLAG(node, flag)           G_STMT_START{ (node->flags|=flag); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_UNSET_FLAG</NAME>
#define GTK_TREE_RBNODE_UNSET_FLAG(node, flag)         G_STMT_START{ (node->flags&=~(flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_FLAG_SET</NAME>
#define GTK_TREE_RBNODE_FLAG_SET(node, flag)         (node?(((node->flags&flag)==flag)?TRUE:FALSE):FALSE)
</MACRO>
<FUNCTION>
<NAME>gtk_tree_rbtree_new</NAME>
<RETURNS>GtkTreeRBTree *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_free</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_remove</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_destroy</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_insert_before</NAME>
<RETURNS>GtkTreeRBNode *</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, gint                           height, gboolean                       valid
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_insert_after</NAME>
<RETURNS>GtkTreeRBNode *</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, gint                           height, gboolean                       valid
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_remove_node</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_is_nil</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_reorder</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, gint                          *new_order, gint                           length
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_contains</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBTree                 *potential_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_find_count</NAME>
<RETURNS>GtkTreeRBNode *</RETURNS>
GtkTreeRBTree                 *tree, gint                           count
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_set_height</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, gint                           height
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_mark_invalid</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_mark_valid</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_column_invalid</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_mark_invalid</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_set_fixed_height</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, gint                           height, gboolean                       mark_valid
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_find_offset</NAME>
<RETURNS>gint</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_get_index</NAME>
<RETURNS>guint</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_find_index</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeRBTree                 *tree, guint                          index, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_find_offset</NAME>
<RETURNS>gint</RETURNS>
GtkTreeRBTree                 *tree, gint                           offset, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_traverse</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, GTraverseType                  order, GtkTreeRBTreeTraverseFunc      func, gpointer                       data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_first</NAME>
<RETURNS>GtkTreeRBNode *</RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_next</NAME>
<RETURNS>GtkTreeRBNode *</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_prev</NAME>
<RETURNS>GtkTreeRBNode *</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_next_full</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_prev_full</NAME>
<RETURNS>void</RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_get_depth</NAME>
<RETURNS>gint</RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<STRUCT>
<NAME>GtkTreeRBTreeView</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_SELECTION</NAME>
#define GTK_TYPE_TREE_SELECTION			(gtk_tree_selection_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_SELECTION</NAME>
#define GTK_TREE_SELECTION(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_SELECTION, GtkTreeSelection))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_SELECTION</NAME>
#define GTK_IS_TREE_SELECTION(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_SELECTION))
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeSelectionFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeSelection  *selection, GtkTreeModel      *model, GtkTreePath       *path, gboolean           path_currently_selected, gpointer           data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeSelectionForeachFunc</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel      *model, GtkTreePath       *path, GtkTreeIter       *iter, gpointer           data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_set_mode</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkSelectionMode             type
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_mode</NAME>
<RETURNS>GtkSelectionMode</RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_set_select_function</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreeSelectionFunc         func, gpointer                     data, GDestroyNotify               destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_user_data</NAME>
<RETURNS>gpointer</RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_tree_view</NAME>
<RETURNS>GtkTreeView *</RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_select_function</NAME>
<RETURNS>GtkTreeSelectionFunc</RETURNS>
GtkTreeSelection        *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeSelection            *selection, GtkTreeModel               **model, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_selected_rows</NAME>
<RETURNS>GList *</RETURNS>
GtkTreeSelection            *selection, GtkTreeModel               **model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_count_selected_rows</NAME>
<RETURNS>gint</RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_selected_foreach</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreeSelectionForeachFunc  func, gpointer                     data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_path</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_path</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_iter</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_iter</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_path_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_iter_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeSelection            *selection, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_all</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_all</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_range</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *start_path, GtkTreePath                 *end_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_range</NAME>
<RETURNS>void</RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *start_path, GtkTreePath                 *end_path
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TREE_SORTABLE</NAME>
#define GTK_TYPE_TREE_SORTABLE            (gtk_tree_sortable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE</NAME>
#define GTK_TREE_SORTABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_SORTABLE, GtkTreeSortable))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_CLASS</NAME>
#define GTK_TREE_SORTABLE_CLASS(obj)      (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_TREE_SORTABLE, GtkTreeSortableIface))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_SORTABLE</NAME>
#define GTK_IS_TREE_SORTABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_SORTABLE))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_GET_IFACE</NAME>
#define GTK_TREE_SORTABLE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_SORTABLE, GtkTreeSortableIface))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</NAME>
#define GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID (-1)
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID</NAME>
#define GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID (-2)
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeIterCompareFunc</NAME>
<RETURNS>gint</RETURNS>
GtkTreeModel *model, GtkTreeIter  *a, GtkTreeIter  *b, gpointer      user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTreeSortableIface</NAME>
struct _GtkTreeSortableIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

  /* signals */
  void     (* sort_column_changed)   (GtkTreeSortable        *sortable);

  /* virtual table */
  gboolean (* get_sort_column_id)    (GtkTreeSortable        *sortable,
				      gint                   *sort_column_id,
				      GtkSortType            *order);
  void     (* set_sort_column_id)    (GtkTreeSortable        *sortable,
				      gint                    sort_column_id,
				      GtkSortType             order);
  void     (* set_sort_func)         (GtkTreeSortable        *sortable,
				      gint                    sort_column_id,
				      GtkTreeIterCompareFunc  sort_func,
				      gpointer                user_data,
				      GDestroyNotify          destroy);
  void     (* set_default_sort_func) (GtkTreeSortable        *sortable,
				      GtkTreeIterCompareFunc  sort_func,
				      gpointer                user_data,
				      GDestroyNotify          destroy);
  gboolean (* has_default_sort_func) (GtkTreeSortable        *sortable);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_sortable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_sort_column_changed</NAME>
<RETURNS>void</RETURNS>
GtkTreeSortable        *sortable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_get_sort_column_id</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeSortable        *sortable, gint                   *sort_column_id, GtkSortType            *order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_set_sort_column_id</NAME>
<RETURNS>void</RETURNS>
GtkTreeSortable        *sortable, gint                    sort_column_id, GtkSortType             order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_set_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeSortable        *sortable, gint                    sort_column_id, GtkTreeIterCompareFunc  sort_func, gpointer                user_data, GDestroyNotify          destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_set_default_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeSortable        *sortable, GtkTreeIterCompareFunc  sort_func, gpointer                user_data, GDestroyNotify          destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_has_default_sort_func</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeSortable        *sortable
</FUNCTION>
<STRUCT>
<NAME>GtkTreeSortable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_STORE</NAME>
#define GTK_TYPE_TREE_STORE			(gtk_tree_store_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_STORE</NAME>
#define GTK_TREE_STORE(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_STORE, GtkTreeStore))
</MACRO>
<MACRO>
<NAME>GTK_TREE_STORE_CLASS</NAME>
#define GTK_TREE_STORE_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_STORE, GtkTreeStoreClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_STORE</NAME>
#define GTK_IS_TREE_STORE(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_STORE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_STORE_CLASS</NAME>
#define GTK_IS_TREE_STORE_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_STORE))
</MACRO>
<MACRO>
<NAME>GTK_TREE_STORE_GET_CLASS</NAME>
#define GTK_TREE_STORE_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_STORE, GtkTreeStoreClass))
</MACRO>
<STRUCT>
<NAME>GtkTreeStore</NAME>
struct _GtkTreeStore
{
  GObject parent;

  GtkTreeStorePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeStoreClass</NAME>
struct _GtkTreeStoreClass
{
  GObjectClass parent_class;

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_store_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_new</NAME>
<RETURNS>GtkTreeStore *</RETURNS>
gint          n_columns, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_newv</NAME>
<RETURNS>GtkTreeStore *</RETURNS>
gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_column_types</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_value</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, gint          column, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_valuesv</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_valist</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, va_list       var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_remove</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, gint          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_before</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_after</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_with_values</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, gint          position, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_with_valuesv</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, gint          position, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_prepend</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_append</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_is_ancestor</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *descendant
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_iter_depth</NAME>
<RETURNS>gint</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_clear</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_iter_is_valid</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_reorder</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *parent, gint         *new_order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_swap</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *a, GtkTreeIter  *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_move_before</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_move_after</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<STRUCT>
<NAME>GtkTreeStorePrivate</NAME>
</STRUCT>
<ENUM>
<NAME>GtkTreeViewDropPosition</NAME>
typedef enum
{
  /* drop before/after this row */
  GTK_TREE_VIEW_DROP_BEFORE,
  GTK_TREE_VIEW_DROP_AFTER,
  /* drop as a child of this row (with fallback to before or after
   * if into is not possible)
   */
  GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
  GTK_TREE_VIEW_DROP_INTO_OR_AFTER
} GtkTreeViewDropPosition;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW</NAME>
#define GTK_TYPE_TREE_VIEW		(gtk_tree_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW</NAME>
#define GTK_TREE_VIEW(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW, GtkTreeView))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_VIEW</NAME>
#define GTK_IS_TREE_VIEW(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW))
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeViewColumnDropFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView             *tree_view, GtkTreeViewColumn       *column, GtkTreeViewColumn       *prev_column, GtkTreeViewColumn       *next_column, gpointer                 data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewMappingFunc</NAME>
<RETURNS>void</RETURNS>
GtkTreeView             *tree_view, GtkTreePath             *path, gpointer                 user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewSearchEqualFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel            *model, gint                     column, const gchar             *key, GtkTreeIter             *iter, gpointer                 search_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewRowSeparatorFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel      *model, GtkTreeIter       *iter, gpointer           data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_new_with_model</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeModel              *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_model</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_model</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreeModel              *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_selection</NAME>
<RETURNS>GtkTreeSelection *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_headers_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_headers_visible</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, gboolean                   headers_visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_columns_autosize</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_headers_clickable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_headers_clickable</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, gboolean                   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_activate_on_single_click</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_activate_on_single_click</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, gboolean                   single
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_append_column</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_remove_column</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column, gint                       position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column_with_attributes</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView               *tree_view, gint                       position, const gchar               *title, GtkCellRenderer           *cell, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column_with_data_func</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView               *tree_view, gint                       position, const gchar               *title, GtkCellRenderer           *cell, GtkTreeCellDataFunc        func, gpointer                   data, GDestroyNotify             dnotify
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_n_columns</NAME>
<RETURNS>guint</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_column</NAME>
<RETURNS>GtkTreeViewColumn *</RETURNS>
GtkTreeView               *tree_view, gint                       n
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_columns</NAME>
<RETURNS>GList *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_move_column_after</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column, GtkTreeViewColumn         *base_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_expander_column</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_expander_column</NAME>
<RETURNS>GtkTreeViewColumn *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_column_drag_function</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumnDropFunc  func, gpointer                   user_data, GDestroyNotify             destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_scroll_to_point</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, gint                       tree_x, gint                       tree_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_scroll_to_cell</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column, gboolean                   use_align, gfloat                     row_align, gfloat                     col_align
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_row_activated</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_expand_all</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_collapse_all</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_expand_to_path</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_expand_row</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, gboolean                   open_all
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_collapse_row</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_map_expanded_rows</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewMappingFunc     func, gpointer                   data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_row_expanded</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_reorderable</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, gboolean                   reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_reorderable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_cursor</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *focus_column, gboolean                   start_editing
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_cursor_on_cell</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *focus_column, GtkCellRenderer           *focus_cell, gboolean                   start_editing
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_cursor</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath              **path, GtkTreeViewColumn        **focus_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_path_at_pos</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view, gint                       x, gint                       y, GtkTreePath              **path, GtkTreeViewColumn        **column, gint                      *cell_x, gint                      *cell_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_cell_area</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column, GdkRectangle              *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_background_area</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column, GdkRectangle              *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_visible_rect</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GdkRectangle              *visible_rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_visible_range</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view, GtkTreePath              **start_path, GtkTreePath              **end_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_is_blank_at_pos</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view, gint                       x, gint                       y, GtkTreePath              **path, GtkTreeViewColumn        **column, gint                      *cell_x, gint                      *cell_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_enable_model_drag_source</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GdkModifierType            start_button_mask, GdkContentFormats         *formats, GdkDragAction              actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_enable_model_drag_dest</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GdkContentFormats         *formats, GdkDragAction              actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_unset_rows_drag_source</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_unset_rows_drag_dest</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_drag_dest_row</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewDropPosition    pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_drag_dest_row</NAME>
<RETURNS>void</RETURNS>
GtkTreeView               *tree_view, GtkTreePath              **path, GtkTreeViewDropPosition   *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_dest_row_at_pos</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView               *tree_view, gint                       drag_x, gint                       drag_y, GtkTreePath              **path, GtkTreeViewDropPosition   *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_create_row_drag_icon</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_enable_search</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, gboolean                    enable_search
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_enable_search</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_search_column</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_column</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, gint                        column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_search_equal_func</NAME>
<RETURNS>GtkTreeViewSearchEqualFunc</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_equal_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, GtkTreeViewSearchEqualFunc  search_equal_func, gpointer                    search_user_data, GDestroyNotify              search_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_search_entry</NAME>
<RETURNS>GtkEditable *</RETURNS>
GtkTreeView                   *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_entry</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                   *tree_view, GtkEditable                   *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_widget_to_tree_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, gint         wx, gint         wy, gint        *tx, gint        *ty
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_tree_to_widget_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, gint         tx, gint         ty, gint        *wx, gint        *wy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_widget_to_bin_window_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, gint         wx, gint         wy, gint        *bx, gint        *by
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_bin_window_to_widget_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, gint         bx, gint         by, gint        *wx, gint        *wy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_tree_to_bin_window_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, gint         tx, gint         ty, gint        *bx, gint        *by
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_bin_window_to_tree_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, gint         bx, gint         by, gint        *tx, gint        *ty
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_fixed_height_mode</NAME>
<RETURNS>void</RETURNS>
GtkTreeView          *tree_view, gboolean              enable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_fixed_height_mode</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_hover_selection</NAME>
<RETURNS>void</RETURNS>
GtkTreeView          *tree_view, gboolean              hover
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_hover_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_hover_expand</NAME>
<RETURNS>void</RETURNS>
GtkTreeView          *tree_view, gboolean              expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_hover_expand</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_rubber_banding</NAME>
<RETURNS>void</RETURNS>
GtkTreeView          *tree_view, gboolean              enable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_rubber_banding</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_is_rubber_banding_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView       *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_row_separator_func</NAME>
<RETURNS>GtkTreeViewRowSeparatorFunc</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_row_separator_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, GtkTreeViewRowSeparatorFunc func, gpointer                    data, GDestroyNotify              destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_grid_lines</NAME>
<RETURNS>GtkTreeViewGridLines</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_grid_lines</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, GtkTreeViewGridLines        grid_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_enable_tree_lines</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_enable_tree_lines</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, gboolean                    enabled
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_show_expanders</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, gboolean                    enabled
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_show_expanders</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_level_indentation</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, gint                        indentation
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_level_indentation</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_tooltip_row</NAME>
<RETURNS>void</RETURNS>
GtkTreeView       *tree_view, GtkTooltip        *tooltip, GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_tooltip_cell</NAME>
<RETURNS>void</RETURNS>
GtkTreeView       *tree_view, GtkTooltip        *tooltip, GtkTreePath       *path, GtkTreeViewColumn *column, GtkCellRenderer   *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_tooltip_context</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeView       *tree_view, gint              *x, gint              *y, gboolean           keyboard_tip, GtkTreeModel     **model, GtkTreePath      **path, GtkTreeIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_tooltip_column</NAME>
<RETURNS>void</RETURNS>
GtkTreeView       *tree_view, gint               column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_tooltip_column</NAME>
<RETURNS>gint</RETURNS>
GtkTreeView       *tree_view
</FUNCTION>
<STRUCT>
<NAME>GtkTreeSelection</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeView</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_COLUMN</NAME>
#define GTK_TYPE_TREE_VIEW_COLUMN	     (gtk_tree_view_column_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW_COLUMN</NAME>
#define GTK_TREE_VIEW_COLUMN(obj)	     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW_COLUMN, GtkTreeViewColumn))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_VIEW_COLUMN</NAME>
#define GTK_IS_TREE_VIEW_COLUMN(obj)	     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW_COLUMN))
</MACRO>
<ENUM>
<NAME>GtkTreeViewColumnSizing</NAME>
typedef enum
{
  GTK_TREE_VIEW_COLUMN_GROW_ONLY,
  GTK_TREE_VIEW_COLUMN_AUTOSIZE,
  GTK_TREE_VIEW_COLUMN_FIXED
} GtkTreeViewColumnSizing;
</ENUM>
<USER_FUNCTION>
<NAME>GtkTreeCellDataFunc</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn *tree_column, GtkCellRenderer   *cell, GtkTreeModel      *tree_model, GtkTreeIter       *iter, gpointer           data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_new</NAME>
<RETURNS>GtkTreeViewColumn *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_new_with_area</NAME>
<RETURNS>GtkTreeViewColumn *</RETURNS>
GtkCellArea             *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_new_with_attributes</NAME>
<RETURNS>GtkTreeViewColumn *</RETURNS>
const gchar             *title, GtkCellRenderer         *cell, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_pack_start</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell, gboolean                 expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_pack_end</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell, gboolean                 expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_clear</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_add_attribute</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, const gchar             *attribute, gint                     column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_attributes</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_cell_data_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, GtkTreeCellDataFunc      func, gpointer                 func_data, GDestroyNotify           destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_clear_attributes</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_spacing</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gint                     spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_spacing</NAME>
<RETURNS>gint</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_visible</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_resizable</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 resizable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_resizable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sizing</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkTreeViewColumnSizing  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sizing</NAME>
<RETURNS>GtkTreeViewColumnSizing</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_x_offset</NAME>
<RETURNS>gint</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_width</NAME>
<RETURNS>gint</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_fixed_width</NAME>
<RETURNS>gint</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_fixed_width</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gint                     fixed_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_min_width</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gint                     min_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_min_width</NAME>
<RETURNS>gint</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_max_width</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gint                     max_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_max_width</NAME>
<RETURNS>gint</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_clicked</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_title</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, const gchar             *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_title</NAME>
<RETURNS>const gchar *</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_expand</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_expand</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_clickable</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 clickable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_clickable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_widget</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkWidget               *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_alignment</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gfloat                   xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_alignment</NAME>
<RETURNS>gfloat</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_reorderable</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_reorderable</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sort_column_id</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gint                     sort_column_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sort_column_id</NAME>
<RETURNS>gint</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sort_indicator</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sort_indicator</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sort_order</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkSortType              order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sort_order</NAME>
<RETURNS>GtkSortType</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_set_cell_data</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkTreeModel            *tree_model, GtkTreeIter             *iter, gboolean                 is_expander, gboolean                 is_expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_get_size</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, int                     *x_offset, int                     *y_offset, int                     *width, int                     *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_is_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_focus_cell</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_get_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, gint                    *x_offset, gint                    *width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_queue_resize</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_tree_view</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<STRUCT>
<NAME>GtkTreeViewColumn</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GtkSnapshot</NAME>
typedef GdkSnapshot                    GtkSnapshot;
</TYPEDEF>
<MACRO>
<NAME>GTK_INVALID_LIST_POSITION</NAME>
#define GTK_INVALID_LIST_POSITION (G_MAXUINT)
</MACRO>
<STRUCT>
<NAME>GtkAdjustment</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilder</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilderScope</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkClipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCssStyleChange</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventController</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGesture</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkLayoutManager</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkNative</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRequisition</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRoot</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSettings</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcut</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutAction</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutTrigger</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkStyleContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTooltip</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWidget</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWindow</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_VIDEO</NAME>
#define GTK_TYPE_VIDEO         (gtk_video_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_video_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_new_for_media_stream</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkMediaStream         *stream
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_new_for_file</NAME>
<RETURNS>GtkWidget *</RETURNS>
GFile                  *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_new_for_filename</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char             *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_new_for_resource</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char             *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_get_media_stream</NAME>
<RETURNS>GtkMediaStream *</RETURNS>
GtkVideo               *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_set_media_stream</NAME>
<RETURNS>void</RETURNS>
GtkVideo               *self, GtkMediaStream         *stream
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_get_file</NAME>
<RETURNS>GFile *</RETURNS>
GtkVideo               *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_set_file</NAME>
<RETURNS>void</RETURNS>
GtkVideo               *self, GFile                  *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_set_filename</NAME>
<RETURNS>void</RETURNS>
GtkVideo               *self, const char             *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_set_resource</NAME>
<RETURNS>void</RETURNS>
GtkVideo               *self, const char             *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_get_autoplay</NAME>
<RETURNS>gboolean</RETURNS>
GtkVideo               *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_set_autoplay</NAME>
<RETURNS>void</RETURNS>
GtkVideo               *self, gboolean                autoplay
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_get_loop</NAME>
<RETURNS>gboolean</RETURNS>
GtkVideo               *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_video_set_loop</NAME>
<RETURNS>void</RETURNS>
GtkVideo               *self, gboolean                loop
</FUNCTION>
<STRUCT>
<NAME>GtkVideo</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_VIEWPORT</NAME>
#define GTK_TYPE_VIEWPORT            (gtk_viewport_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_VIEWPORT</NAME>
#define GTK_VIEWPORT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VIEWPORT, GtkViewport))
</MACRO>
<MACRO>
<NAME>GTK_IS_VIEWPORT</NAME>
#define GTK_IS_VIEWPORT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VIEWPORT))
</MACRO>
<FUNCTION>
<NAME>gtk_viewport_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_viewport_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAdjustment *hadjustment, GtkAdjustment *vadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_viewport_get_scroll_to_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkViewport *viewport
</FUNCTION>
<FUNCTION>
<NAME>gtk_viewport_set_scroll_to_focus</NAME>
<RETURNS>void</RETURNS>
GtkViewport *viewport, gboolean     scroll_to_focus
</FUNCTION>
<FUNCTION>
<NAME>gtk_viewport_set_child</NAME>
<RETURNS>void</RETURNS>
GtkViewport *viewport, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_viewport_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkViewport *viewport
</FUNCTION>
<STRUCT>
<NAME>GtkViewport</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_VOLUME_BUTTON</NAME>
#define GTK_TYPE_VOLUME_BUTTON                 (gtk_volume_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_VOLUME_BUTTON</NAME>
#define GTK_VOLUME_BUTTON(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_VOLUME_BUTTON, GtkVolumeButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_VOLUME_BUTTON</NAME>
#define GTK_IS_VOLUME_BUTTON(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VOLUME_BUTTON))
</MACRO>
<STRUCT>
<NAME>GtkVolumeButton</NAME>
struct _GtkVolumeButton
{
  GtkScaleButton  parent;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_volume_button_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_volume_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_WIDGET</NAME>
#define GTK_TYPE_WIDGET                   (gtk_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_WIDGET</NAME>
#define GTK_WIDGET(widget)                (G_TYPE_CHECK_INSTANCE_CAST ((widget), GTK_TYPE_WIDGET, GtkWidget))
</MACRO>
<MACRO>
<NAME>GTK_WIDGET_CLASS</NAME>
#define GTK_WIDGET_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET, GtkWidgetClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_WIDGET</NAME>
#define GTK_IS_WIDGET(widget)             (G_TYPE_CHECK_INSTANCE_TYPE ((widget), GTK_TYPE_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_IS_WIDGET_CLASS</NAME>
#define GTK_IS_WIDGET_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_WIDGET_GET_CLASS</NAME>
#define GTK_WIDGET_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WIDGET, GtkWidgetClass))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_REQUISITION</NAME>
#define GTK_TYPE_REQUISITION              (gtk_requisition_get_type ())
</MACRO>
<TYPEDEF>
<NAME>GtkAllocation</NAME>
typedef         GdkRectangle       GtkAllocation;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GtkCallback</NAME>
<RETURNS>void</RETURNS>
GtkWidget        *widget, gpointer          data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTickCallback</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget     *widget, GdkFrameClock *frame_clock, gpointer       user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkRequisition</NAME>
struct _GtkRequisition
{
  gint width;
  gint height;
};
</STRUCT>
<STRUCT>
<NAME>GtkWidget</NAME>
struct _GtkWidget
{
  GInitiallyUnowned parent_instance;

  /*< private >*/

  GtkWidgetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkWidgetClass</NAME>
struct _GtkWidgetClass
{
  GInitiallyUnownedClass parent_class;

  /*< public >*/

  guint activate_signal;

  /* basics */
  void (* show)                (GtkWidget        *widget);
  void (* hide)                (GtkWidget        *widget);
  void (* map)                 (GtkWidget        *widget);
  void (* unmap)               (GtkWidget        *widget);
  void (* realize)             (GtkWidget        *widget);
  void (* unrealize)           (GtkWidget        *widget);
  void (* root)                (GtkWidget        *widget);
  void (* unroot)              (GtkWidget        *widget);
  void (* size_allocate)       (GtkWidget           *widget,
                                int                  width,
                                int                  height,
                                int                  baseline);
  void (* state_flags_changed) (GtkWidget        *widget,
                                GtkStateFlags     previous_state_flags);
  void (* direction_changed)   (GtkWidget        *widget,
                                GtkTextDirection  previous_direction);
  void (* grab_notify)         (GtkWidget        *widget,
                                gboolean          was_grabbed);

  /* size requests */
  GtkSizeRequestMode (* get_request_mode)               (GtkWidget      *widget);
  void              (* measure) (GtkWidget      *widget,
                                 GtkOrientation  orientation,
                                 int             for_size,
                                 int            *minimum,
                                 int            *natural,
                                 int            *minimum_baseline,
                                 int            *natural_baseline);

  /* Mnemonics */
  gboolean (* mnemonic_activate)        (GtkWidget           *widget,
                                         gboolean             group_cycling);

  /* explicit focus */
  gboolean (* grab_focus)               (GtkWidget           *widget);
  gboolean (* focus)                    (GtkWidget           *widget,
                                         GtkDirectionType     direction);
  void     (* set_focus_child)          (GtkWidget           *widget,
                                         GtkWidget           *child);

  /* keyboard navigation */
  void     (* move_focus)               (GtkWidget           *widget,
                                         GtkDirectionType     direction);
  gboolean (* keynav_failed)            (GtkWidget           *widget,
                                         GtkDirectionType     direction);

  /* accessibility support
   */
  AtkObject *  (* get_accessible)     (GtkWidget       *widget);

  gboolean     (* query_tooltip)      (GtkWidget  *widget,
                                       gint        x,
                                       gint        y,
                                       gboolean    keyboard_tooltip,
                                       GtkTooltip *tooltip);

  void         (* compute_expand)     (GtkWidget  *widget,
                                       gboolean   *hexpand_p,
                                       gboolean   *vexpand_p);

  void         (* css_changed)                 (GtkWidget            *widget,
                                                GtkCssStyleChange    *change);

  void         (* system_setting_changed)      (GtkWidget            *widget,
                                                GtkSystemSetting      settings);

  void         (* snapshot)                    (GtkWidget            *widget,
                                                GtkSnapshot          *snapshot);

  gboolean     (* contains)                    (GtkWidget *widget,
                                                gdouble    x,
                                                gdouble    y);

  /*< private >*/

  GtkWidgetClassPrivate *priv;

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_widget_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GType                type, const gchar         *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_unparent</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_show</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_hide</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_map</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_unmap</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_realize</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_unrealize</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_queue_draw</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_queue_resize</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_queue_allocate</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_frame_clock</NAME>
<RETURNS>GdkFrameClock *</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_size_allocate</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, const GtkAllocation *allocation, int                  baseline
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_allocate</NAME>
<RETURNS>void</RETURNS>
GtkWidget               *widget, int                      width, int                      height, int                      baseline, GskTransform            *transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_request_mode</NAME>
<RETURNS>GtkSizeRequestMode</RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_measure</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, GtkOrientation  orientation, int             for_size, int            *minimum, int            *natural, int            *minimum_baseline, int            *natural_baseline
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_preferred_size</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, GtkRequisition *minimum_size, GtkRequisition *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_layout_manager</NAME>
<RETURNS>void</RETURNS>
GtkWidget        *widget, GtkLayoutManager *layout_manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_layout_manager</NAME>
<RETURNS>GtkLayoutManager *</RETURNS>
GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_layout_manager_type</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass *widget_class, GType           type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_get_layout_manager_type</NAME>
<RETURNS>GType</RETURNS>
GtkWidgetClass *widget_class
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_add_binding</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass      *widget_class, guint                keyval, GdkModifierType      mods, GtkShortcutFunc      callback, const gchar         *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_add_binding_signal</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass      *widget_class, guint                keyval, GdkModifierType      mods, const gchar         *signal, const gchar         *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_add_binding_action</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass      *widget_class, guint                keyval, GdkModifierType      mods, const gchar         *action_name, const gchar         *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_add_shortcut</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass      *widget_class, GtkShortcut         *shortcut
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_mnemonic_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget, gboolean             group_cycling
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_can_focus</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, gboolean             can_focus
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_can_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_focusable</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, gboolean             focusable
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_focusable</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_has_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_has_visible_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_grab_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_focus_on_click</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, gboolean             focus_on_click
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_focus_on_click</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_can_target</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, gboolean             can_target
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_can_target</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_has_default</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_receives_default</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, gboolean             receives_default
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_receives_default</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_device_is_shadowed</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget, GdkDevice           *device
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_name</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, const gchar  *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_state_flags</NAME>
<RETURNS>void</RETURNS>
GtkWidget     *widget, GtkStateFlags  flags, gboolean       clear
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_unset_state_flags</NAME>
<RETURNS>void</RETURNS>
GtkWidget     *widget, GtkStateFlags  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_state_flags</NAME>
<RETURNS>GtkStateFlags</RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_sensitive</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, gboolean      sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_sensitive</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_sensitive</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_visible</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, gboolean      visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_drawable</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_realized</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_mapped</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_parent</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, GtkWidget    *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_parent</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_root</NAME>
<RETURNS>GtkRoot *</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_native</NAME>
<RETURNS>GtkNative *</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_child_visible</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, gboolean      child_visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_child_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocated_width</NAME>
<RETURNS>int</RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocated_height</NAME>
<RETURNS>int</RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocated_baseline</NAME>
<RETURNS>int</RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocation</NAME>
<RETURNS>void</RETURNS>
GtkWidget     *widget, GtkAllocation *allocation
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_transform</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget              *widget, GtkWidget              *target, graphene_matrix_t      *out_transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_bounds</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget              *widget, GtkWidget              *target, graphene_rect_t        *out_bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_point</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget              *widget, GtkWidget              *target, const graphene_point_t *point, graphene_point_t       *out_point
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_width</NAME>
<RETURNS>int</RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_height</NAME>
<RETURNS>int</RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_child_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget, GtkDirectionType     direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_keynav_failed</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget           *widget, GtkDirectionType     direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_error_bell</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_size_request</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, gint                 width, gint                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_size_request</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, gint                *width, gint                *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_opacity</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, double               opacity
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_opacity</NAME>
<RETURNS>double</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_overflow</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, GtkOverflow          overflow
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_overflow</NAME>
<RETURNS>GtkOverflow</RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_ancestor</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget      *widget, GType           widget_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_scale_factor</NAME>
<RETURNS>gint</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_settings</NAME>
<RETURNS>GtkSettings *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_primary_clipboard</NAME>
<RETURNS>GdkClipboard *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_hexpand</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_hexpand</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, gboolean        expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_hexpand_set</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_hexpand_set</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, gboolean        set
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_vexpand</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_vexpand</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, gboolean        expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_vexpand_set</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_vexpand_set</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, gboolean        set
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_expand</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget      *widget, GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_support_multidevice</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_support_multidevice</NAME>
<RETURNS>void</RETURNS>
GtkWidget      *widget, gboolean        support_multidevice
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_accessible_type</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass     *widget_class, GType               type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_accessible_role</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass     *widget_class, AtkRole             role
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_accessible</NAME>
<RETURNS>AtkObject *</RETURNS>
GtkWidget          *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_halign</NAME>
<RETURNS>GtkAlign</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_halign</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, GtkAlign   align
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_valign</NAME>
<RETURNS>GtkAlign</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_valign</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, GtkAlign   align
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_start</NAME>
<RETURNS>gint</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_start</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_end</NAME>
<RETURNS>gint</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_end</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_top</NAME>
<RETURNS>gint</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_top</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_bottom</NAME>
<RETURNS>gint</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_bottom</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_ancestor</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget      *widget, GtkWidget      *ancestor
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_translate_coordinates</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget  *src_widget, GtkWidget  *dest_widget, double      src_x, double      src_y, double     *dest_x, double     *dest_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_contains</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget  *widget, gdouble     x, gdouble     y
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_pick</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget   *widget, gdouble      x, gdouble      y, GtkPickFlags flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_add_controller</NAME>
<RETURNS>void</RETURNS>
GtkWidget          *widget, GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_remove_controller</NAME>
<RETURNS>void</RETURNS>
GtkWidget          *widget, GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_create_pango_context</NAME>
<RETURNS>PangoContext *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_pango_context</NAME>
<RETURNS>PangoContext *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_font_options</NAME>
<RETURNS>void</RETURNS>
GtkWidget                  *widget, const cairo_font_options_t *options
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_font_options</NAME>
<RETURNS>const cairo_font_options_t *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_create_pango_layout</NAME>
<RETURNS>PangoLayout *</RETURNS>
GtkWidget   *widget, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_direction</NAME>
<RETURNS>void</RETURNS>
GtkWidget        *widget, GtkTextDirection  dir
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_direction</NAME>
<RETURNS>GtkTextDirection</RETURNS>
GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_default_direction</NAME>
<RETURNS>void</RETURNS>
GtkTextDirection  dir
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_default_direction</NAME>
<RETURNS>GtkTextDirection</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_cursor</NAME>
<RETURNS>void</RETURNS>
GtkWidget              *widget, GdkCursor              *cursor
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_cursor_from_name</NAME>
<RETURNS>void</RETURNS>
GtkWidget              *widget, const char             *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_cursor</NAME>
<RETURNS>GdkCursor *</RETURNS>
GtkWidget              *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_list_mnemonic_labels</NAME>
<RETURNS>GList *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_add_mnemonic_label</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, GtkWidget *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_remove_mnemonic_label</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, GtkWidget *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_trigger_tooltip_query</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_tooltip_text</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_tooltip_text</NAME>
<RETURNS>gchar *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_tooltip_markup</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, const gchar *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_tooltip_markup</NAME>
<RETURNS>gchar *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_has_tooltip</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, gboolean     has_tooltip
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_has_tooltip</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_new</NAME>
<RETURNS>GtkRequisition *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_copy</NAME>
<RETURNS>GtkRequisition *</RETURNS>
const GtkRequisition *requisition
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_free</NAME>
<RETURNS>void</RETURNS>
GtkRequisition       *requisition
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_in_destruction</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_style_context</NAME>
<RETURNS>GtkStyleContext *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_css_name</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass *widget_class, const char     *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_get_css_name</NAME>
<RETURNS>const char *</RETURNS>
GtkWidgetClass *widget_class
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_add_tick_callback</NAME>
<RETURNS>guint</RETURNS>
GtkWidget       *widget, GtkTickCallback  callback, gpointer         user_data, GDestroyNotify   notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_remove_tick_callback</NAME>
<RETURNS>void</RETURNS>
GtkWidget       *widget, guint            id
</FUNCTION>
<MACRO>
<NAME>gtk_widget_class_bind_template_callback</NAME>
#define gtk_widget_class_bind_template_callback(widget_class, callback) \
  gtk_widget_class_bind_template_callback_full (GTK_WIDGET_CLASS (widget_class), \
                                                #callback, \
                                                G_CALLBACK (callback))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child</NAME>
#define gtk_widget_class_bind_template_child(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             FALSE, \
                                             G_STRUCT_OFFSET (TypeName, member_name))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child_internal</NAME>
#define gtk_widget_class_bind_template_child_internal(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             TRUE, \
                                             G_STRUCT_OFFSET (TypeName, member_name))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child_private</NAME>
#define gtk_widget_class_bind_template_child_private(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             FALSE, \
                                             G_PRIVATE_OFFSET (TypeName, member_name))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child_internal_private</NAME>
#define gtk_widget_class_bind_template_child_internal_private(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             TRUE, \
                                             G_PRIVATE_OFFSET (TypeName, member_name))
</MACRO>
<FUNCTION>
<NAME>gtk_widget_init_template</NAME>
<RETURNS>void</RETURNS>
GtkWidget             *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_template_child</NAME>
<RETURNS>GObject *</RETURNS>
GtkWidget             *widget, GType                  widget_type, const gchar           *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_template</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass        *widget_class, GBytes                *template_bytes
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_template_from_resource</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass        *widget_class, const gchar           *resource_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_bind_template_callback_full</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass        *widget_class, const gchar           *callback_name, GCallback              callback_symbol
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_template_scope</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass        *widget_class, GtkBuilderScope       *scope
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_bind_template_child_full</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass        *widget_class, const gchar           *name, gboolean               internal_child, gssize                 struct_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_insert_action_group</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, const gchar  *name, GActionGroup *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_activate_action</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget  *widget, const char *name, const char *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_activate_action_variant</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget  *widget, const char *name, GVariant   *args
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_activate_default</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_font_map</NAME>
<RETURNS>void</RETURNS>
GtkWidget             *widget, PangoFontMap          *font_map
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_font_map</NAME>
<RETURNS>PangoFontMap *</RETURNS>
GtkWidget             *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_first_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_last_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_next_sibling</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_prev_sibling</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_observe_children</NAME>
<RETURNS>GListModel *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_observe_controllers</NAME>
<RETURNS>GListModel *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_insert_after</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, GtkWidget *parent, GtkWidget *previous_sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_insert_before</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, GtkWidget *parent, GtkWidget *next_sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_focus_child</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, GtkWidget *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_focus_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_snapshot_child</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, GtkWidget   *child, GtkSnapshot *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_should_layout</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_css_name</NAME>
<RETURNS>const char *</RETURNS>
GtkWidget   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_add_css_class</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, const char  *css_class
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_remove_css_class</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, const char  *css_class
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_has_css_class</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget   *widget, const char  *css_class
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_css_classes</NAME>
<RETURNS>char **</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_css_classes</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, const char **classes
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkWidgetActionActivateFunc</NAME>
<RETURNS>void</RETURNS>
GtkWidget  *widget, const char *action_name, GVariant   *parameter
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_install_action</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass              *widget_class, const char                  *action_name, const char                  *parameter_type, GtkWidgetActionActivateFunc  activate
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_install_property_action</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass *widget_class, const char     *action_name, const char     *property_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_query_action</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidgetClass      *widget_class, guint                index_, GType               *owner, const char         **action_name, const GVariantType **parameter_type, const char         **property_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_action_set_enabled</NAME>
<RETURNS>void</RETURNS>
GtkWidget  *widget, const char *action_name, gboolean    enabled
</FUNCTION>
<STRUCT>
<NAME>GtkWidgetClassPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWidgetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_WIDGET_PAINTABLE</NAME>
#define GTK_TYPE_WIDGET_PAINTABLE (gtk_widget_paintable_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_widget_paintable_new</NAME>
<RETURNS>GdkPaintable *</RETURNS>
GtkWidget              *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_paintable_get_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidgetPaintable     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_paintable_set_widget</NAME>
<RETURNS>void</RETURNS>
GtkWidgetPaintable     *self, GtkWidget              *widget
</FUNCTION>
<STRUCT>
<NAME>GtkWidgetPaintable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_WINDOW</NAME>
#define GTK_TYPE_WINDOW			(gtk_window_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_WINDOW</NAME>
#define GTK_WINDOW(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WINDOW, GtkWindow))
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_CLASS</NAME>
#define GTK_WINDOW_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW, GtkWindowClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_WINDOW</NAME>
#define GTK_IS_WINDOW(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_IS_WINDOW_CLASS</NAME>
#define GTK_IS_WINDOW_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_GET_CLASS</NAME>
#define GTK_WINDOW_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WINDOW, GtkWindowClass))
</MACRO>
<STRUCT>
<NAME>GtkWindow</NAME>
struct _GtkWindow
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkWindowClass</NAME>
struct _GtkWindowClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  /* G_SIGNAL_ACTION signals for keybindings */

  void     (* activate_focus)   (GtkWindow *window);
  void     (* activate_default) (GtkWindow *window);
  void	   (* keys_changed)     (GtkWindow *window);
  gboolean (* enable_debugging) (GtkWindow *window,
                                 gboolean   toggle);
  gboolean (* close_request)    (GtkWindow *window);

  /*< private >*/
  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_window_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_title</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, const gchar         *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_title</NAME>
<RETURNS>const gchar *</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_startup_id</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, const gchar         *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_focus</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, GtkWidget           *focus
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_focus</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_default_widget</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, GtkWidget           *default_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_default_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_transient_for</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, GtkWindow           *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_transient_for</NAME>
<RETURNS>GtkWindow *</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_destroy_with_parent</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_destroy_with_parent</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_hide_on_close</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_hide_on_close</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_mnemonics_visible</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_mnemonics_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_focus_visible</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_focus_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_resizable</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, gboolean             resizable
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_resizable</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_display</NAME>
<RETURNS>void</RETURNS>
GtkWindow	    *window, GdkDisplay          *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_is_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_decorated</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_decorated</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_deletable</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_deletable</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkWindow   *window, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_icon_name</NAME>
<RETURNS>const gchar *</RETURNS>
GtkWindow  *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_default_icon_name</NAME>
<RETURNS>void</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_default_icon_name</NAME>
<RETURNS>const gchar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_auto_startup_notification</NAME>
<RETURNS>void</RETURNS>
gboolean setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_modal</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window, gboolean   modal
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_modal</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_toplevels</NAME>
<RETURNS>GListModel *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_list_toplevels</NAME>
<RETURNS>GList *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_present</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_present_with_time</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window, guint32    timestamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_minimize</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_unminimize</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_maximize</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_unmaximize</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_fullscreen</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_unfullscreen</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_fullscreen_on_monitor</NAME>
<RETURNS>void</RETURNS>
GtkWindow  *window, GdkMonitor *monitor
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_close</NAME>
<RETURNS>void</RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_default_size</NAME>
<RETURNS>void</RETURNS>
GtkWindow   *window, gint         width, gint         height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_default_size</NAME>
<RETURNS>void</RETURNS>
GtkWindow   *window, gint        *width, gint        *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_resize</NAME>
<RETURNS>void</RETURNS>
GtkWindow   *window, gint         width, gint         height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_size</NAME>
<RETURNS>void</RETURNS>
GtkWindow   *window, gint        *width, gint        *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_group</NAME>
<RETURNS>GtkWindowGroup *</RETURNS>
GtkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_has_group</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_application</NAME>
<RETURNS>GtkApplication *</RETURNS>
GtkWindow          *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_application</NAME>
<RETURNS>void</RETURNS>
GtkWindow          *window, GtkApplication     *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_child</NAME>
<RETURNS>void</RETURNS>
GtkWindow    *window, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow    *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_titlebar</NAME>
<RETURNS>void</RETURNS>
GtkWindow    *window, GtkWidget    *titlebar
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_titlebar</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow    *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_is_maximized</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindow    *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_destroy</NAME>
<RETURNS>void</RETURNS>
GtkWindow    *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_interactive_debugging</NAME>
<RETURNS>void</RETURNS>
gboolean enable
</FUNCTION>
<STRUCT>
<NAME>GtkWindowGeometryInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWindowGroup</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWindowGroupClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWindowGroupPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_WINDOW_CONTROLS</NAME>
#define GTK_TYPE_WINDOW_CONTROLS (gtk_window_controls_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_window_controls_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkPackType        side
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_controls_get_side</NAME>
<RETURNS>GtkPackType</RETURNS>
GtkWindowControls *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_controls_set_side</NAME>
<RETURNS>void</RETURNS>
GtkWindowControls *self, GtkPackType        side
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_controls_get_decoration_layout</NAME>
<RETURNS>const char *</RETURNS>
GtkWindowControls *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_controls_set_decoration_layout</NAME>
<RETURNS>void</RETURNS>
GtkWindowControls *self, const char        *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_controls_get_empty</NAME>
<RETURNS>gboolean</RETURNS>
GtkWindowControls *self
</FUNCTION>
<STRUCT>
<NAME>GtkWindowControls</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_WINDOW_GROUP</NAME>
#define GTK_TYPE_WINDOW_GROUP             (gtk_window_group_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_GROUP</NAME>
#define GTK_WINDOW_GROUP(object)          (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_WINDOW_GROUP, GtkWindowGroup))
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_GROUP_CLASS</NAME>
#define GTK_WINDOW_GROUP_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW_GROUP, GtkWindowGroupClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_WINDOW_GROUP</NAME>
#define GTK_IS_WINDOW_GROUP(object)       (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_WINDOW_GROUP))
</MACRO>
<MACRO>
<NAME>GTK_IS_WINDOW_GROUP_CLASS</NAME>
#define GTK_IS_WINDOW_GROUP_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WINDOW_GROUP))
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_GROUP_GET_CLASS</NAME>
#define GTK_WINDOW_GROUP_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WINDOW_GROUP, GtkWindowGroupClass))
</MACRO>
<STRUCT>
<NAME>GtkWindowGroup</NAME>
struct _GtkWindowGroup
{
  GObject parent_instance;

  GtkWindowGroupPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkWindowGroupClass</NAME>
struct _GtkWindowGroupClass
{
  GObjectClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_window_group_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_group_new</NAME>
<RETURNS>GtkWindowGroup *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_group_add_window</NAME>
<RETURNS>void</RETURNS>
GtkWindowGroup     *window_group, GtkWindow          *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_group_remove_window</NAME>
<RETURNS>void</RETURNS>
GtkWindowGroup     *window_group, GtkWindow          *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_group_list_windows</NAME>
<RETURNS>GList *</RETURNS>
GtkWindowGroup     *window_group
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_WINDOW_HANDLE</NAME>
#define GTK_TYPE_WINDOW_HANDLE (gtk_window_handle_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_window_handle_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_handle_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindowHandle *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_handle_set_child</NAME>
<RETURNS>void</RETURNS>
GtkWindowHandle *self, GtkWidget       *child
</FUNCTION>
<STRUCT>
<NAME>GtkWindowHandle</NAME>
</STRUCT>
<FUNCTION>
<NAME>get_language_name</NAME>
<RETURNS>const char *</RETURNS>
PangoLanguage *language
</FUNCTION>
<FUNCTION>
<NAME>get_language_name_for_tag</NAME>
<RETURNS>const char *</RETURNS>
guint32 tag
</FUNCTION>
<STRUCT>
<NAME>NamedTag</NAME>
typedef struct {
  unsigned int tag;
  const char *name;
} NamedTag;
</STRUCT>
<MACRO>
<NAME>MAKE_TAG</NAME>
#define MAKE_TAG(a,b,c,d) (unsigned int)(((a) << 24) | ((b) << 16) | ((c) <<  8) | (d))
</MACRO>
<FUNCTION>
<NAME>get_script_name</NAME>
<RETURNS>const char *</RETURNS>
GUnicodeScript script
</FUNCTION>
<FUNCTION>
<NAME>get_script_name_for_tag</NAME>
<RETURNS>const char *</RETURNS>
guint32 tag
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE            (gtk_boolean_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BOOLEAN_CELL_ACCESSIBLE</NAME>
#define GTK_BOOLEAN_CELL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE, GtkBooleanCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_BOOLEAN_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_BOOLEAN_CELL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GAIL_BOOLEAN_CELL, GtkBooleanCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOOLEAN_CELL_ACCESSIBLE</NAME>
#define GTK_IS_BOOLEAN_CELL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOOLEAN_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_BOOLEAN_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_BOOLEAN_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_BOOLEAN_CELL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE, GtkBooleanCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkBooleanCellAccessible</NAME>
struct _GtkBooleanCellAccessible
{
  GtkRendererCellAccessible parent;

  GtkBooleanCellAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkBooleanCellAccessibleClass</NAME>
struct _GtkBooleanCellAccessibleClass
{
  GtkRendererCellAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_boolean_cell_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkBooleanCellAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_BUTTON_ACCESSIBLE                     (gtk_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BUTTON_ACCESSIBLE</NAME>
#define GTK_BUTTON_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BUTTON_ACCESSIBLE, GtkButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_BUTTON_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BUTTON_ACCESSIBLE, GtkButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_BUTTON_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_BUTTON_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_BUTTON_ACCESSIBLE_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BUTTON_ACCESSIBLE, GtkButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkButtonAccessible</NAME>
struct _GtkButtonAccessible
{
  GtkWidgetAccessible parent;

  GtkButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkButtonAccessibleClass</NAME>
struct _GtkButtonAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_CELL_ACCESSIBLE                           (gtk_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_ACCESSIBLE</NAME>
#define GTK_CELL_ACCESSIBLE(obj)                           (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_ACCESSIBLE, GtkCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_CELL_ACCESSIBLE_CLASS(klass)                   (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_ACCESSIBLE, GtkCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_ACCESSIBLE</NAME>
#define GTK_IS_CELL_ACCESSIBLE(obj)                        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_CELL_ACCESSIBLE_CLASS(klass)                (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_CELL_ACCESSIBLE_GET_CLASS(obj)                 (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_ACCESSIBLE, GtkCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkCellAccessible</NAME>
struct _GtkCellAccessible
{
  GtkAccessible parent;

  GtkCellAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellAccessibleClass</NAME>
struct _GtkCellAccessibleClass
{
  GtkAccessibleClass parent_class;
  void (*update_cache) (GtkCellAccessible *cell,
                        gboolean           emit_signal);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_ACCESSIBLE_PARENT</NAME>
#define GTK_TYPE_CELL_ACCESSIBLE_PARENT            (gtk_cell_accessible_parent_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_ACCESSIBLE_PARENT</NAME>
#define GTK_IS_CELL_ACCESSIBLE_PARENT(obj)         G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_ACCESSIBLE_PARENT)
</MACRO>
<MACRO>
<NAME>GTK_CELL_ACCESSIBLE_PARENT</NAME>
#define GTK_CELL_ACCESSIBLE_PARENT(obj)            G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_ACCESSIBLE_PARENT, GtkCellAccessibleParent)
</MACRO>
<MACRO>
<NAME>GTK_CELL_ACCESSIBLE_PARENT_GET_IFACE</NAME>
#define GTK_CELL_ACCESSIBLE_PARENT_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_CELL_ACCESSIBLE_PARENT, GtkCellAccessibleParentIface))
</MACRO>
<STRUCT>
<NAME>GtkCellAccessibleParentIface</NAME>
struct _GtkCellAccessibleParentIface
{
  GTypeInterface parent;
  void     ( *get_cell_extents) (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell,
                                 gint                    *x,
                                 gint                    *y,
                                 gint                    *width,
                                 gint                    *height,
                                 AtkCoordType             coord_type);
  void     ( *get_cell_area)    (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell,
                                 GdkRectangle            *cell_rect);
  gboolean ( *grab_focus)       (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell);
  int      ( *get_child_index)  (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell);
  GtkCellRendererState
           ( *get_renderer_state) (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell);
  /* actions */
  void     ( *expand_collapse)  (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell);
  void     ( *activate)         (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell);
  void     ( *edit)             (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell);
  /* end of actions */
  void     ( *update_relationset) (GtkCellAccessibleParent *parent,
                                 GtkCellAccessible       *cell,
                                 AtkRelationSet          *relationset);
  void     ( *get_cell_position) (GtkCellAccessibleParent *parent,
                                  GtkCellAccessible       *cell,
                                  gint                    *row,
                                  gint                    *column);
  GPtrArray *   ( *get_column_header_cells) (GtkCellAccessibleParent *parent,
                                             GtkCellAccessible       *cell);
  GPtrArray *   ( *get_row_header_cells)    (GtkCellAccessibleParent *parent,
                                             GtkCellAccessible       *cell);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_cell_extents</NAME>
<RETURNS>void</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell, gint                    *x, gint                    *y, gint                    *width, gint                    *height, AtkCoordType             coord_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_cell_area</NAME>
<RETURNS>void</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell, GdkRectangle            *cell_rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_grab_focus</NAME>
<RETURNS>gboolean</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_child_index</NAME>
<RETURNS>int</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_renderer_state</NAME>
<RETURNS>GtkCellRendererState</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_expand_collapse</NAME>
<RETURNS>void</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_activate</NAME>
<RETURNS>void</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_edit</NAME>
<RETURNS>void</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_update_relationset</NAME>
<RETURNS>void</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell, AtkRelationSet          *relationset
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_cell_position</NAME>
<RETURNS>void</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell, gint                    *row, gint                    *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_column_header_cells</NAME>
<RETURNS>GPtrArray *</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_accessible_parent_get_row_header_cells</NAME>
<RETURNS>GPtrArray *</RETURNS>
GtkCellAccessibleParent *parent, GtkCellAccessible       *cell
</FUNCTION>
<STRUCT>
<NAME>GtkCellAccessibleParent</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_SWATCH_ACCESSIBLE</NAME>
#define GTK_TYPE_COLOR_SWATCH_ACCESSIBLE                         (_gtk_color_swatch_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_SWATCH_ACCESSIBLE</NAME>
#define GTK_COLOR_SWATCH_ACCESSIBLE(obj)                         (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE, GtkColorSwatchAccessible))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_SWATCH_ACCESSIBLE_CLASS</NAME>
#define GTK_COLOR_SWATCH_ACCESSIBLE_CLASS(klass)                       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE, GtkColorSwatchAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_SWATCH_ACCESSIBLE</NAME>
#define GTK_IS_COLOR_SWATCH_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_SWATCH_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_COLOR_SWATCH_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_SWATCH_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_COLOR_SWATCH_ACCESSIBLE_GET_CLASS(obj)             (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE, GtkColorSwatchAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkColorSwatchAccessible</NAME>
struct _GtkColorSwatchAccessible
{
  GtkWidgetAccessible parent;

  GtkColorSwatchAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkColorSwatchAccessibleClass</NAME>
struct _GtkColorSwatchAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GtkColorSwatchAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COMBO_BOX_ACCESSIBLE</NAME>
#define GTK_TYPE_COMBO_BOX_ACCESSIBLE                      (gtk_combo_box_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX_ACCESSIBLE</NAME>
#define GTK_COMBO_BOX_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMBO_BOX_ACCESSIBLE, GtkComboBoxAccessible))
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX_ACCESSIBLE_CLASS</NAME>
#define GTK_COMBO_BOX_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COMBO_BOX_ACCESSIBLE, GtkComboBoxAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_COMBO_BOX_ACCESSIBLE</NAME>
#define GTK_IS_COMBO_BOX_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMBO_BOX_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_COMBO_BOX_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_COMBO_BOX_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COMBO_BOX_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_COMBO_BOX_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COMBO_BOX_ACCESSIBLE, GtkComboBoxAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkComboBoxAccessible</NAME>
struct _GtkComboBoxAccessible
{
  GtkWidgetAccessible parent;

  GtkComboBoxAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkComboBoxAccessibleClass</NAME>
struct _GtkComboBoxAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_combo_box_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkComboBoxAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COMPOSITE_ACCESSIBLE</NAME>
#define GTK_TYPE_COMPOSITE_ACCESSIBLE                  (gtk_composite_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COMPOSITE_ACCESSIBLE</NAME>
#define GTK_COMPOSITE_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COMPOSITE_ACCESSIBLE, GtkCompositeAccessible))
</MACRO>
<MACRO>
<NAME>GTK_COMPOSITE_ACCESSIBLE_CLASS</NAME>
#define GTK_COMPOSITE_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COMPOSITE_ACCESSIBLE, GtkCompositeAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_COMPOSITE_ACCESSIBLE</NAME>
#define GTK_IS_COMPOSITE_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COMPOSITE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_COMPOSITE_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_COMPOSITE_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COMPOSITE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_COMPOSITE_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_COMPOSITE_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COMPOSITE_ACCESSIBLE, GtkCompositeAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkCompositeAccessible</NAME>
struct _GtkCompositeAccessible
{
  GtkWidgetAccessible parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkCompositeAccessibleClass</NAME>
struct _GtkCompositeAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_composite_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CONTAINER_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_CONTAINER_CELL_ACCESSIBLE            (gtk_container_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_CELL_ACCESSIBLE</NAME>
#define GTK_CONTAINER_CELL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_CONTAINER_CELL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER_CELL_ACCESSIBLE</NAME>
#define GTK_IS_CONTAINER_CELL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_CONTAINER_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_CONTAINER_CELL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkContainerCellAccessible</NAME>
struct _GtkContainerCellAccessible
{
  GtkCellAccessible parent;

  GtkContainerCellAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkContainerCellAccessibleClass</NAME>
struct _GtkContainerCellAccessibleClass
{
  GtkCellAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_container_cell_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_cell_accessible_new</NAME>
<RETURNS>GtkContainerCellAccessible *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_cell_accessible_add_child</NAME>
<RETURNS>void</RETURNS>
GtkContainerCellAccessible *container, GtkCellAccessible          *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_cell_accessible_remove_child</NAME>
<RETURNS>void</RETURNS>
GtkContainerCellAccessible *container, GtkCellAccessible          *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_cell_accessible_get_children</NAME>
<RETURNS>GList *</RETURNS>
GtkContainerCellAccessible *container
</FUNCTION>
<STRUCT>
<NAME>GtkContainerCellAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ENTRY_ACCESSIBLE</NAME>
#define GTK_TYPE_ENTRY_ACCESSIBLE                      (gtk_entry_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_ACCESSIBLE</NAME>
#define GTK_ENTRY_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_ACCESSIBLE, GtkEntryAccessible))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_ACCESSIBLE_CLASS</NAME>
#define GTK_ENTRY_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY_ACCESSIBLE, GtkEntryAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ENTRY_ACCESSIBLE</NAME>
#define GTK_IS_ENTRY_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ENTRY_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_ENTRY_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_ENTRY_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_ENTRY_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ENTRY_ACCESSIBLE, GtkEntryAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkEntryAccessible</NAME>
struct _GtkEntryAccessible
{
  GtkWidgetAccessible parent;

  GtkEntryAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkEntryAccessibleClass</NAME>
struct _GtkEntryAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_entry_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_icon_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkEntryAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_EXPANDER_ACCESSIBLE</NAME>
#define GTK_TYPE_EXPANDER_ACCESSIBLE              (gtk_expander_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EXPANDER_ACCESSIBLE</NAME>
#define GTK_EXPANDER_ACCESSIBLE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EXPANDER_ACCESSIBLE, GtkExpanderAccessible))
</MACRO>
<MACRO>
<NAME>GTK_EXPANDER_ACCESSIBLE_CLASS</NAME>
#define GTK_EXPANDER_ACCESSIBLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EXPANDER_ACCESSIBLE, GtkExpanderAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EXPANDER_ACCESSIBLE</NAME>
#define GTK_IS_EXPANDER_ACCESSIBLE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EXPANDER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_EXPANDER_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_EXPANDER_ACCESSIBLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EXPANDER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_EXPANDER_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_EXPANDER_ACCESSIBLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_EXPANDER_ACCESSIBLE, GtkExpanderAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkExpanderAccessible</NAME>
struct _GtkExpanderAccessible
{
  GtkWidgetAccessible parent;

  GtkExpanderAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkExpanderAccessibleClass</NAME>
struct _GtkExpanderAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_expander_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkExpanderAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FLOW_BOX_ACCESSIBLE</NAME>
#define GTK_TYPE_FLOW_BOX_ACCESSIBLE                   (gtk_flow_box_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_ACCESSIBLE</NAME>
#define GTK_FLOW_BOX_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FLOW_BOX_ACCESSIBLE, GtkFlowBoxAccessible))
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_ACCESSIBLE_CLASS</NAME>
#define GTK_FLOW_BOX_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FLOW_BOX_ACCESSIBLE, GtkFlowBoxAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FLOW_BOX_ACCESSIBLE</NAME>
#define GTK_IS_FLOW_BOX_ACCESSIBLE(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FLOW_BOX_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_FLOW_BOX_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_FLOW_BOX_ACCESSIBLE_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FLOW_BOX_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_FLOW_BOX_ACCESSIBLE_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FLOW_BOX_ACCESSIBLE, GtkFlowBoxAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkFlowBoxAccessible</NAME>
struct _GtkFlowBoxAccessible
{
  GtkWidgetAccessible parent;

  GtkFlowBoxAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkFlowBoxAccessibleClass</NAME>
struct _GtkFlowBoxAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_flow_box_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkFlowBoxAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE</NAME>
#define GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE               (gtk_flow_box_child_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_CHILD_ACCESSIBLE</NAME>
#define GTK_FLOW_BOX_CHILD_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE, GtkFlowBoxChildAccessible))
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_CHILD_ACCESSIBLE_CLASS</NAME>
#define GTK_FLOW_BOX_CHILD_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE, GtkFlowBoxChildAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FLOW_BOX_CHILD_ACCESSIBLE</NAME>
#define GTK_IS_FLOW_BOX_CHILD_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_FLOW_BOX_CHILD_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_FLOW_BOX_CHILD_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_CHILD_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_FLOW_BOX_CHILD_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FLOW_BOX_CHILD_ACCESSIBLE, GtkFlowBoxChildAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkFlowBoxChildAccessible</NAME>
struct _GtkFlowBoxChildAccessible
{
  GtkWidgetAccessible parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkFlowBoxChildAccessibleClass</NAME>
struct _GtkFlowBoxChildAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_flow_box_child_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FRAME_ACCESSIBLE</NAME>
#define GTK_TYPE_FRAME_ACCESSIBLE                      (gtk_frame_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FRAME_ACCESSIBLE</NAME>
#define GTK_FRAME_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FRAME_ACCESSIBLE, GtkFrameAccessible))
</MACRO>
<MACRO>
<NAME>GTK_FRAME_ACCESSIBLE_CLASS</NAME>
#define GTK_FRAME_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FRAME_ACCESSIBLE, GtkFrameAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FRAME_ACCESSIBLE</NAME>
#define GTK_IS_FRAME_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FRAME_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_FRAME_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_FRAME_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FRAME_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_FRAME_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_FRAME_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FRAME_ACCESSIBLE, GtkFrameAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkFrameAccessible</NAME>
struct _GtkFrameAccessible
{
  GtkWidgetAccessible parent;

  GtkFrameAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkFrameAccessibleClass</NAME>
struct _GtkFrameAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_frame_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkFrameAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ICON_VIEW_ACCESSIBLE</NAME>
#define GTK_TYPE_ICON_VIEW_ACCESSIBLE                  (gtk_icon_view_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ICON_VIEW_ACCESSIBLE</NAME>
#define GTK_ICON_VIEW_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ICON_VIEW_ACCESSIBLE, GtkIconViewAccessible))
</MACRO>
<MACRO>
<NAME>GTK_ICON_VIEW_ACCESSIBLE_CLASS</NAME>
#define GTK_ICON_VIEW_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_VIEW_ACCESSIBLE, GtkIconViewAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ICON_VIEW_ACCESSIBLE</NAME>
#define GTK_IS_ICON_VIEW_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ICON_VIEW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_ICON_VIEW_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_ICON_VIEW_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ICON_VIEW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_ICON_VIEW_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_ICON_VIEW_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ICON_VIEW_ACCESSIBLE, GtkIconViewAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkIconViewAccessible</NAME>
struct _GtkIconViewAccessible
{
  GtkWidgetAccessible parent;

  GtkIconViewAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkIconViewAccessibleClass</NAME>
struct _GtkIconViewAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_icon_view_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkIconViewAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_IMAGE_ACCESSIBLE</NAME>
#define GTK_TYPE_IMAGE_ACCESSIBLE                      (gtk_image_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IMAGE_ACCESSIBLE</NAME>
#define GTK_IMAGE_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE_ACCESSIBLE, GtkImageAccessible))
</MACRO>
<MACRO>
<NAME>GTK_IMAGE_ACCESSIBLE_CLASS</NAME>
#define GTK_IMAGE_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IMAGE_ACCESSIBLE, GtkImageAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IMAGE_ACCESSIBLE</NAME>
#define GTK_IS_IMAGE_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_IMAGE_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_IMAGE_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IMAGE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IMAGE_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_IMAGE_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IMAGE_ACCESSIBLE, GtkImageAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkImageAccessible</NAME>
struct _GtkImageAccessible
{
  GtkWidgetAccessible parent;

  GtkImageAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkImageAccessibleClass</NAME>
struct _GtkImageAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_image_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkImageAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_IMAGE_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_IMAGE_CELL_ACCESSIBLE            (gtk_image_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IMAGE_CELL_ACCESSIBLE</NAME>
#define GTK_IMAGE_CELL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IMAGE_CELL_ACCESSIBLE, GtkImageCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_IMAGE_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IMAGE_CELL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_IMAGE_CELL_ACCESSIBLE, GtkImageCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IMAGE_CELL_ACCESSIBLE</NAME>
#define GTK_IS_IMAGE_CELL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_IMAGE_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_IMAGE_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IMAGE_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IMAGE_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_IMAGE_CELL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IMAGE_CELL_ACCESSIBLE, GtkImageCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkImageCellAccessible</NAME>
struct _GtkImageCellAccessible
{
  GtkRendererCellAccessible parent;

  GtkImageCellAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkImageCellAccessibleClass</NAME>
struct _GtkImageCellAccessibleClass
{
  GtkRendererCellAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_image_cell_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkImageCellAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LABEL_ACCESSIBLE</NAME>
#define GTK_TYPE_LABEL_ACCESSIBLE            (gtk_label_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LABEL_ACCESSIBLE</NAME>
#define GTK_LABEL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LABEL_ACCESSIBLE, GtkLabelAccessible))
</MACRO>
<MACRO>
<NAME>GTK_LABEL_ACCESSIBLE_CLASS</NAME>
#define GTK_LABEL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LABEL_ACCESSIBLE, GtkLabelAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LABEL_ACCESSIBLE</NAME>
#define GTK_IS_LABEL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LABEL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LABEL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_LABEL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LABEL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_LABEL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_LABEL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LABEL_ACCESSIBLE, GtkLabelAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkLabelAccessible</NAME>
struct _GtkLabelAccessible
{
  GtkWidgetAccessible parent;

  GtkLabelAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkLabelAccessibleClass</NAME>
struct _GtkLabelAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_label_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkLabelAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LEVEL_BAR_ACCESSIBLE</NAME>
#define GTK_TYPE_LEVEL_BAR_ACCESSIBLE                      (gtk_level_bar_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR_ACCESSIBLE</NAME>
#define GTK_LEVEL_BAR_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LEVEL_BAR_ACCESSIBLE, GtkLevelBarAccessible))
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR_ACCESSIBLE_CLASS</NAME>
#define GTK_LEVEL_BAR_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LEVEL_BAR_ACCESSIBLE, GtkLevelBarAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LEVEL_BAR_ACCESSIBLE</NAME>
#define GTK_IS_LEVEL_BAR_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LEVEL_BAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LEVEL_BAR_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_LEVEL_BAR_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LEVEL_BAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_LEVEL_BAR_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LEVEL_BAR_ACCESSIBLE, GtkLevelBarAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkLevelBarAccessible</NAME>
struct _GtkLevelBarAccessible
{
  GtkWidgetAccessible parent;

  GtkLevelBarAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkLevelBarAccessibleClass</NAME>
struct _GtkLevelBarAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_level_bar_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkLevelBarAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LINK_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_LINK_BUTTON_ACCESSIBLE                (gtk_link_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LINK_BUTTON_ACCESSIBLE</NAME>
#define GTK_LINK_BUTTON_ACCESSIBLE(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LINK_BUTTON_ACCESSIBLE, GtkLinkButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_LINK_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_LINK_BUTTON_ACCESSIBLE_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LINK_BUTTON_ACCESSIBLE, GtkLinkButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LINK_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_LINK_BUTTON_ACCESSIBLE(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LINK_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LINK_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_LINK_BUTTON_ACCESSIBLE_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LINK_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_LINK_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_LINK_BUTTON_ACCESSIBLE_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LINK_BUTTON_ACCESSIBLE, GtkLinkButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkLinkButtonAccessible</NAME>
struct _GtkLinkButtonAccessible
{
  GtkButtonAccessible parent;

  GtkLinkButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkLinkButtonAccessibleClass</NAME>
struct _GtkLinkButtonAccessibleClass
{
  GtkButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_link_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkLinkButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LIST_BOX_ACCESSIBLE</NAME>
#define GTK_TYPE_LIST_BOX_ACCESSIBLE                   (gtk_list_box_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ACCESSIBLE</NAME>
#define GTK_LIST_BOX_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LIST_BOX_ACCESSIBLE, GtkListBoxAccessible))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ACCESSIBLE_CLASS</NAME>
#define GTK_LIST_BOX_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LIST_BOX_ACCESSIBLE, GtkListBoxAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BOX_ACCESSIBLE</NAME>
#define GTK_IS_LIST_BOX_ACCESSIBLE(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LIST_BOX_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BOX_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_LIST_BOX_ACCESSIBLE_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST_BOX_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_LIST_BOX_ACCESSIBLE_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LIST_BOX_ACCESSIBLE, GtkListBoxAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkListBoxAccessible</NAME>
struct _GtkListBoxAccessible
{
  GtkWidgetAccessible parent;

  GtkListBoxAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkListBoxAccessibleClass</NAME>
struct _GtkListBoxAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_list_box_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkListBoxAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE</NAME>
#define GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE               (gtk_list_box_row_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ROW_ACCESSIBLE</NAME>
#define GTK_LIST_BOX_ROW_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE, GtkListBoxRowAccessible))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ROW_ACCESSIBLE_CLASS</NAME>
#define GTK_LIST_BOX_ROW_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE, GtkListBoxRowAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BOX_ROW_ACCESSIBLE</NAME>
#define GTK_IS_LIST_BOX_ROW_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BOX_ROW_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_LIST_BOX_ROW_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_ROW_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_LIST_BOX_ROW_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LIST_BOX_ROW_ACCESSIBLE, GtkListBoxRowAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkListBoxRowAccessible</NAME>
struct _GtkListBoxRowAccessible
{
  GtkWidgetAccessible parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkListBoxRowAccessibleClass</NAME>
struct _GtkListBoxRowAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_list_box_row_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_LOCK_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_LOCK_BUTTON_ACCESSIBLE                     (gtk_lock_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LOCK_BUTTON_ACCESSIBLE</NAME>
#define GTK_LOCK_BUTTON_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE, GtkLockButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_LOCK_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_LOCK_BUTTON_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE, GtkLockButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LOCK_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_LOCK_BUTTON_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LOCK_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_LOCK_BUTTON_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_LOCK_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_LOCK_BUTTON_ACCESSIBLE_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LOCK_BUTTON_ACCESSIBLE, GtkLockButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkLockButtonAccessible</NAME>
struct _GtkLockButtonAccessible
{
  GtkButtonAccessible parent;

  GtkLockButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkLockButtonAccessibleClass</NAME>
struct _GtkLockButtonAccessibleClass
{
  GtkButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_lock_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkLockButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_MENU_BUTTON_ACCESSIBLE               (gtk_menu_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON_ACCESSIBLE</NAME>
#define GTK_MENU_BUTTON_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_BUTTON_ACCESSIBLE, GtkMenuButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_MENU_BUTTON_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_BUTTON_ACCESSIBLE, GtkMenuButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_MENU_BUTTON_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_MENU_BUTTON_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_MENU_BUTTON_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_BUTTON_ACCESSIBLE, GtkMenuButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuButtonAccessible</NAME>
struct _GtkMenuButtonAccessible
{
  GtkWidgetAccessible parent;

  GtkMenuButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuButtonAccessibleClass</NAME>
struct _GtkMenuButtonAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_menu_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkMenuButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NOTEBOOK_ACCESSIBLE</NAME>
#define GTK_TYPE_NOTEBOOK_ACCESSIBLE                   (gtk_notebook_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_ACCESSIBLE</NAME>
#define GTK_NOTEBOOK_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessible))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_ACCESSIBLE_CLASS</NAME>
#define GTK_NOTEBOOK_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_ACCESSIBLE</NAME>
#define GTK_IS_NOTEBOOK_ACCESSIBLE(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_NOTEBOOK_ACCESSIBLE_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_NOTEBOOK_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_NOTEBOOK_ACCESSIBLE_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkNotebookAccessible</NAME>
struct _GtkNotebookAccessible
{
  GtkWidgetAccessible parent;

  GtkNotebookAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkNotebookAccessibleClass</NAME>
struct _GtkNotebookAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_notebook_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkNotebookAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE</NAME>
#define GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE            (gtk_notebook_page_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_PAGE_ACCESSIBLE</NAME>
#define GTK_NOTEBOOK_PAGE_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj),GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE, GtkNotebookPageAccessible))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_PAGE_ACCESSIBLE_CLASS</NAME>
#define GTK_NOTEBOOK_PAGE_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE, GtkNotebookPageAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_PAGE_ACCESSIBLE</NAME>
#define GTK_IS_NOTEBOOK_PAGE_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_PAGE_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_NOTEBOOK_PAGE_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_PAGE_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_NOTEBOOK_PAGE_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK_PAGE_ACCESSIBLE, GtkNotebookPageAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkNotebookPageAccessible</NAME>
struct _GtkNotebookPageAccessible
{
  AtkObject parent;

  GtkNotebookPageAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkNotebookPageAccessibleClass</NAME>
struct _GtkNotebookPageAccessibleClass
{
  AtkObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_notebook_page_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_accessible_new</NAME>
<RETURNS>AtkObject *</RETURNS>
GtkNotebookAccessible     *notebook, GtkWidget                 *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_accessible_invalidate</NAME>
<RETURNS>void</RETURNS>
GtkNotebookPageAccessible *page
</FUNCTION>
<STRUCT>
<NAME>GtkNotebookPageAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PANED_ACCESSIBLE</NAME>
#define GTK_TYPE_PANED_ACCESSIBLE                      (gtk_paned_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PANED_ACCESSIBLE</NAME>
#define GTK_PANED_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PANED_ACCESSIBLE, GtkPanedAccessible))
</MACRO>
<MACRO>
<NAME>GTK_PANED_ACCESSIBLE_CLASS</NAME>
#define GTK_PANED_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PANED_ACCESSIBLE, GtkPanedAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PANED_ACCESSIBLE</NAME>
#define GTK_IS_PANED_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PANED_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_PANED_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_PANED_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PANED_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_PANED_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_PANED_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PANED_ACCESSIBLE, GtkPanedAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkPanedAccessible</NAME>
struct _GtkPanedAccessible
{
  GtkWidgetAccessible parent;

  GtkPanedAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPanedAccessibleClass</NAME>
struct _GtkPanedAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_paned_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkPanedAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PICTURE_ACCESSIBLE</NAME>
#define GTK_TYPE_PICTURE_ACCESSIBLE (gtk_picture_accessible_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkPictureAccessible</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_POPOVER_ACCESSIBLE</NAME>
#define GTK_TYPE_POPOVER_ACCESSIBLE                      (gtk_popover_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_ACCESSIBLE</NAME>
#define GTK_POPOVER_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_POPOVER_ACCESSIBLE, GtkPopoverAccessible))
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_ACCESSIBLE_CLASS</NAME>
#define GTK_POPOVER_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_POPOVER_ACCESSIBLE, GtkPopoverAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER_ACCESSIBLE</NAME>
#define GTK_IS_POPOVER_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_POPOVER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_POPOVER_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_POPOVER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_POPOVER_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_POPOVER_ACCESSIBLE, GtkPopoverAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkPopoverAccessible</NAME>
struct _GtkPopoverAccessible
{
  GtkWidgetAccessible parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkPopoverAccessibleClass</NAME>
struct _GtkPopoverAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_popover_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PROGRESS_BAR_ACCESSIBLE</NAME>
#define GTK_TYPE_PROGRESS_BAR_ACCESSIBLE                      (gtk_progress_bar_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PROGRESS_BAR_ACCESSIBLE</NAME>
#define GTK_PROGRESS_BAR_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE, GtkProgressBarAccessible))
</MACRO>
<MACRO>
<NAME>GTK_PROGRESS_BAR_ACCESSIBLE_CLASS</NAME>
#define GTK_PROGRESS_BAR_ACCESSIBLE_CLASS(klass)                        (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE, GtkProgressBarAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PROGRESS_BAR_ACCESSIBLE</NAME>
#define GTK_IS_PROGRESS_BAR_ACCESSIBLE(obj)                       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_PROGRESS_BAR_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_PROGRESS_BAR_ACCESSIBLE_CLASS(klass)               (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_PROGRESS_BAR_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_PROGRESS_BAR_ACCESSIBLE_GET_CLASS(obj)              (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PROGRESS_BAR_ACCESSIBLE, GtkProgressBarAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkProgressBarAccessible</NAME>
struct _GtkProgressBarAccessible
{
  GtkWidgetAccessible parent;

  GtkProgressBarAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkProgressBarAccessibleClass</NAME>
struct _GtkProgressBarAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_progress_bar_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkProgressBarAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RADIO_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_RADIO_BUTTON_ACCESSIBLE               (gtk_radio_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RADIO_BUTTON_ACCESSIBLE</NAME>
#define GTK_RADIO_BUTTON_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE, GtkRadioButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_RADIO_BUTTON_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE, GtkRadioButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_RADIO_BUTTON_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_RADIO_BUTTON_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_RADIO_BUTTON_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_BUTTON_ACCESSIBLE, GtkRadioButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkRadioButtonAccessible</NAME>
struct _GtkRadioButtonAccessible
{
  GtkToggleButtonAccessible parent;

  GtkRadioButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkRadioButtonAccessibleClass</NAME>
struct _GtkRadioButtonAccessibleClass
{
  GtkToggleButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_radio_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkRadioButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RANGE_ACCESSIBLE</NAME>
#define GTK_TYPE_RANGE_ACCESSIBLE                       (gtk_range_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RANGE_ACCESSIBLE</NAME>
#define GTK_RANGE_ACCESSIBLE(obj)                       (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RANGE_ACCESSIBLE, GtkRangeAccessible))
</MACRO>
<MACRO>
<NAME>GTK_RANGE_ACCESSIBLE_CLASS</NAME>
#define GTK_RANGE_ACCESSIBLE_CLASS(klass)               (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RANGE_ACCESSIBLE, GtkRangeAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RANGE_ACCESSIBLE</NAME>
#define GTK_IS_RANGE_ACCESSIBLE(obj)                    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RANGE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_RANGE_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_RANGE_ACCESSIBLE_CLASS(klass)            (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RANGE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_RANGE_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_RANGE_ACCESSIBLE_GET_CLASS(obj)             (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RANGE_ACCESSIBLE, GtkRangeAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkRangeAccessible</NAME>
struct _GtkRangeAccessible
{
  GtkWidgetAccessible parent;

  GtkRangeAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkRangeAccessibleClass</NAME>
struct _GtkRangeAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_range_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkRangeAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RENDERER_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_RENDERER_CELL_ACCESSIBLE            (gtk_renderer_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RENDERER_CELL_ACCESSIBLE</NAME>
#define GTK_RENDERER_CELL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RENDERER_CELL_ACCESSIBLE, GtkRendererCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_RENDERER_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_RENDERER_CELL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RENDERER_CELL_ACCESSIBLE, GtkRendererCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RENDERER_CELL_ACCESSIBLE</NAME>
#define GTK_IS_RENDERER_CELL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RENDERER_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_RENDERER_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_RENDERER_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RENDERER_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_RENDERER_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_RENDERER_CELL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RENDERER_CELL_ACCESSIBLE, GtkRendererCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkRendererCellAccessible</NAME>
struct _GtkRendererCellAccessible
{
  GtkCellAccessible  parent;

  GtkRendererCellAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkRendererCellAccessibleClass</NAME>
struct _GtkRendererCellAccessibleClass
{
  GtkCellAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_renderer_cell_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_renderer_cell_accessible_new</NAME>
<RETURNS>AtkObject *</RETURNS>
GtkCellRenderer * renderer
</FUNCTION>
<STRUCT>
<NAME>GtkRendererCellAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCALE_ACCESSIBLE</NAME>
#define GTK_TYPE_SCALE_ACCESSIBLE                         (gtk_scale_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCALE_ACCESSIBLE</NAME>
#define GTK_SCALE_ACCESSIBLE(obj)                         (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_ACCESSIBLE, GtkScaleAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_ACCESSIBLE_CLASS</NAME>
#define GTK_SCALE_ACCESSIBLE_CLASS(klass)                       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_ACCESSIBLE, GtkScaleAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_ACCESSIBLE</NAME>
#define GTK_IS_SCALE_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SCALE_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SCALE_ACCESSIBLE_GET_CLASS(obj)             (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE_ACCESSIBLE, GtkScaleAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkScaleAccessible</NAME>
struct _GtkScaleAccessible
{
  GtkRangeAccessible parent;

  GtkScaleAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleAccessibleClass</NAME>
struct _GtkScaleAccessibleClass
{
  GtkRangeAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scale_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkScaleAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCALE_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_SCALE_BUTTON_ACCESSIBLE                     (gtk_scale_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON_ACCESSIBLE</NAME>
#define GTK_SCALE_BUTTON_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE, GtkScaleButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_SCALE_BUTTON_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE, GtkScaleButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_SCALE_BUTTON_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SCALE_BUTTON_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SCALE_BUTTON_ACCESSIBLE_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE_BUTTON_ACCESSIBLE, GtkScaleButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkScaleButtonAccessible</NAME>
struct _GtkScaleButtonAccessible
{
  GtkWidgetAccessible parent;

  GtkScaleButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleButtonAccessibleClass</NAME>
struct _GtkScaleButtonAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scale_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkScaleButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCROLLBAR_ACCESSIBLE</NAME>
#define GTK_TYPE_SCROLLBAR_ACCESSIBLE                       (gtk_scrollbar_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCROLLBAR_ACCESSIBLE</NAME>
#define GTK_SCROLLBAR_ACCESSIBLE(obj)                       (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLBAR_ACCESSIBLE_CLASS</NAME>
#define GTK_SCROLLBAR_ACCESSIBLE_CLASS(klass)               (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLBAR_ACCESSIBLE</NAME>
#define GTK_IS_SCROLLBAR_ACCESSIBLE(obj)                    (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLBAR_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SCROLLBAR_ACCESSIBLE_CLASS(klass)            (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLBAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLBAR_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SCROLLBAR_ACCESSIBLE_GET_CLASS(obj)             (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLBAR_ACCESSIBLE, GtkScrollbarAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkScrollbarAccessible</NAME>
struct _GtkScrollbarAccessible
{
  GtkWidgetAccessible parent;

  GtkScrollbarAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkScrollbarAccessibleClass</NAME>
struct _GtkScrollbarAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scrollbar_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkScrollbarAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE</NAME>
#define GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE            (gtk_scrolled_window_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW_ACCESSIBLE</NAME>
#define GTK_SCROLLED_WINDOW_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW_ACCESSIBLE_CLASS</NAME>
#define GTK_SCROLLED_WINDOW_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLED_WINDOW_ACCESSIBLE</NAME>
#define GTK_IS_SCROLLED_WINDOW_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLED_WINDOW_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SCROLLED_WINDOW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SCROLLED_WINDOW_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkScrolledWindowAccessible</NAME>
struct _GtkScrolledWindowAccessible
{
  GtkWidgetAccessible parent;

  GtkScrolledWindowAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkScrolledWindowAccessibleClass</NAME>
struct _GtkScrolledWindowAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scrolled_window_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkScrolledWindowAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SPIN_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_SPIN_BUTTON_ACCESSIBLE                      (gtk_spin_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SPIN_BUTTON_ACCESSIBLE</NAME>
#define GTK_SPIN_BUTTON_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE, GtkSpinButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SPIN_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_SPIN_BUTTON_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE, GtkSpinButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPIN_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_SPIN_BUTTON_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPIN_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SPIN_BUTTON_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SPIN_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SPIN_BUTTON_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SPIN_BUTTON_ACCESSIBLE, GtkSpinButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkSpinButtonAccessible</NAME>
struct _GtkSpinButtonAccessible
{
  GtkEntryAccessible parent;

  GtkSpinButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSpinButtonAccessibleClass</NAME>
struct _GtkSpinButtonAccessibleClass
{
  GtkEntryAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_spin_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkSpinButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SPINNER_ACCESSIBLE</NAME>
#define GTK_TYPE_SPINNER_ACCESSIBLE              (gtk_spinner_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SPINNER_ACCESSIBLE</NAME>
#define GTK_SPINNER_ACCESSIBLE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPINNER_ACCESSIBLE, GtkSpinnerAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SPINNER_ACCESSIBLE_CLASS</NAME>
#define GTK_SPINNER_ACCESSIBLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPINNER_ACCESSIBLE, GtkSpinnerAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPINNER_ACCESSIBLE</NAME>
#define GTK_IS_SPINNER_ACCESSIBLE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPINNER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPINNER_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SPINNER_ACCESSIBLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SPINNER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SPINNER_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SPINNER_ACCESSIBLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SPINNER_ACCESSIBLE, GtkSpinnerAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkSpinnerAccessible</NAME>
struct _GtkSpinnerAccessible
{
  GtkWidgetAccessible parent;

  GtkSpinnerAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSpinnerAccessibleClass</NAME>
struct _GtkSpinnerAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_spinner_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkSpinnerAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_STACK_ACCESSIBLE</NAME>
#define GTK_TYPE_STACK_ACCESSIBLE            (gtk_stack_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STACK_ACCESSIBLE</NAME>
#define GTK_STACK_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STACK_ACCESSIBLE, GtkStackAccessible))
</MACRO>
<MACRO>
<NAME>GTK_STACK_ACCESSIBLE_CLASS</NAME>
#define GTK_STACK_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STACK_ACCESSIBLE, GtkStackAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_STACK_ACCESSIBLE</NAME>
#define GTK_IS_STACK_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STACK_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_STACK_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_STACK_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STACK_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_STACK_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_STACK_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STACK_ACCESSIBLE, GtkStackAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkStackAccessible</NAME>
struct _GtkStackAccessible
{
  GtkWidgetAccessible parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkStackAccessibleClass</NAME>
struct _GtkStackAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_stack_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_accessible_update_visible_child</NAME>
<RETURNS>void</RETURNS>
GtkStack  *stack, GtkWidget *old_visible_child, GtkWidget *new_visible_child
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_STATUSBAR_ACCESSIBLE</NAME>
#define GTK_TYPE_STATUSBAR_ACCESSIBLE                  (gtk_statusbar_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STATUSBAR_ACCESSIBLE</NAME>
#define GTK_STATUSBAR_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_STATUSBAR_ACCESSIBLE, GtkStatusbarAccessible))
</MACRO>
<MACRO>
<NAME>GTK_STATUSBAR_ACCESSIBLE_CLASS</NAME>
#define GTK_STATUSBAR_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STATUSBAR_ACCESSIBLE, GtkStatusbarAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_STATUSBAR_ACCESSIBLE</NAME>
#define GTK_IS_STATUSBAR_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STATUSBAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_STATUSBAR_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_STATUSBAR_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STATUSBAR_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_STATUSBAR_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_STATUSBAR_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STATUSBAR_ACCESSIBLE, GtkStatusbarAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkStatusbarAccessible</NAME>
struct _GtkStatusbarAccessible
{
  GtkWidgetAccessible parent;

  GtkStatusbarAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkStatusbarAccessibleClass</NAME>
struct _GtkStatusbarAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_statusbar_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkStatusbarAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SWITCH_ACCESSIBLE</NAME>
#define GTK_TYPE_SWITCH_ACCESSIBLE              (gtk_switch_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SWITCH_ACCESSIBLE</NAME>
#define GTK_SWITCH_ACCESSIBLE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SWITCH_ACCESSIBLE, GtkSwitchAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SWITCH_ACCESSIBLE_CLASS</NAME>
#define GTK_SWITCH_ACCESSIBLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SWITCH_ACCESSIBLE, GtkSwitchAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SWITCH_ACCESSIBLE</NAME>
#define GTK_IS_SWITCH_ACCESSIBLE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SWITCH_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SWITCH_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SWITCH_ACCESSIBLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SWITCH_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SWITCH_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SWITCH_ACCESSIBLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SWITCH_ACCESSIBLE, GtkSwitchAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkSwitchAccessible</NAME>
struct _GtkSwitchAccessible
{
  GtkWidgetAccessible parent;

  GtkSwitchAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSwitchAccessibleClass</NAME>
struct _GtkSwitchAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_switch_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkSwitchAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TEXT_ACCESSIBLE</NAME>
#define GTK_TYPE_TEXT_ACCESSIBLE                      (gtk_text_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_ACCESSIBLE</NAME>
#define GTK_TEXT_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_ACCESSIBLE, GtkTextAccessible))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_ACCESSIBLE_CLASS</NAME>
#define GTK_TEXT_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_ACCESSIBLE, GtkTextAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_ACCESSIBLE</NAME>
#define GTK_IS_TEXT_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_TEXT_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_TEXT_ACCESSIBLE_GET_CLASS(obj)            (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_ACCESSIBLE, GtkTextAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkTextAccessible</NAME>
struct _GtkTextAccessible
{
  GtkWidgetAccessible parent;

  GtkTextAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextAccessibleClass</NAME>
struct _GtkTextAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkTextAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TEXT_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_TEXT_CELL_ACCESSIBLE            (gtk_text_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_CELL_ACCESSIBLE</NAME>
#define GTK_TEXT_CELL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_CELL_ACCESSIBLE, GtkTextCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_TEXT_CELL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TEXT_CELL_ACCESSIBLE, GtkTextCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_CELL_ACCESSIBLE</NAME>
#define GTK_IS_TEXT_CELL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_TEXT_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_TEXT_CELL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_CELL_ACCESSIBLE, GtkTextCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkTextCellAccessible</NAME>
struct _GtkTextCellAccessible
{
  GtkRendererCellAccessible parent;

  GtkTextCellAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextCellAccessibleClass</NAME>
struct _GtkTextCellAccessibleClass
{
  GtkRendererCellAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_cell_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkTextCellAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TEXT_VIEW_ACCESSIBLE</NAME>
#define GTK_TYPE_TEXT_VIEW_ACCESSIBLE                  (gtk_text_view_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW_ACCESSIBLE</NAME>
#define GTK_TEXT_VIEW_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_VIEW_ACCESSIBLE, GtkTextViewAccessible))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW_ACCESSIBLE_CLASS</NAME>
#define GTK_TEXT_VIEW_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW_ACCESSIBLE, GtkTextViewAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_VIEW_ACCESSIBLE</NAME>
#define GTK_IS_TEXT_VIEW_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_VIEW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_VIEW_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_TEXT_VIEW_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_VIEW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_TEXT_VIEW_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_VIEW_ACCESSIBLE, GtkTextViewAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkTextViewAccessible</NAME>
struct _GtkTextViewAccessible
{
  GtkWidgetAccessible parent;

  GtkTextViewAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextViewAccessibleClass</NAME>
struct _GtkTextViewAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_view_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkTextViewAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE              (gtk_toggle_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_BUTTON_ACCESSIBLE</NAME>
#define GTK_TOGGLE_BUTTON_ACCESSIBLE(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE, GtkToggleButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_TOGGLE_BUTTON_ACCESSIBLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE, GtkToggleButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOGGLE_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_TOGGLE_BUTTON_ACCESSIBLE(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOGGLE_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_TOGGLE_BUTTON_ACCESSIBLE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_TOGGLE_BUTTON_ACCESSIBLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOGGLE_BUTTON_ACCESSIBLE, GtkToggleButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkToggleButtonAccessible</NAME>
struct _GtkToggleButtonAccessible
{
  GtkButtonAccessible parent;

  GtkToggleButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkToggleButtonAccessibleClass</NAME>
struct _GtkToggleButtonAccessibleClass
{
  GtkButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_toggle_button_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkToggleButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOPLEVEL_ACCESSIBLE</NAME>
#define GTK_TYPE_TOPLEVEL_ACCESSIBLE               (gtk_toplevel_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOPLEVEL_ACCESSIBLE</NAME>
#define GTK_TOPLEVEL_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOPLEVEL_ACCESSIBLE, GtkToplevelAccessible))
</MACRO>
<MACRO>
<NAME>GTK_TOPLEVEL_ACCESSIBLE_CLASS</NAME>
#define GTK_TOPLEVEL_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOPLEVEL_ACCESSIBLE, GtkToplevelAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOPLEVEL_ACCESSIBLE</NAME>
#define GTK_IS_TOPLEVEL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOPLEVEL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOPLEVEL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_TOPLEVEL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOPLEVEL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_TOPLEVEL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_TOPLEVEL_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOPLEVEL_ACCESSIBLE, GtkToplevelAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkToplevelAccessible</NAME>
struct _GtkToplevelAccessible
{
  AtkObject parent;

  GtkToplevelAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkToplevelAccessibleClass</NAME>
struct _GtkToplevelAccessibleClass
{
  AtkObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_toplevel_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toplevel_accessible_get_children</NAME>
<RETURNS>GList *</RETURNS>
GtkToplevelAccessible *accessible
</FUNCTION>
<STRUCT>
<NAME>GtkToplevelAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_ACCESSIBLE</NAME>
#define GTK_TYPE_TREE_VIEW_ACCESSIBLE                  (gtk_tree_view_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW_ACCESSIBLE</NAME>
#define GTK_TREE_VIEW_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW_ACCESSIBLE, GtkTreeViewAccessible))
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW_ACCESSIBLE_CLASS</NAME>
#define GTK_TREE_VIEW_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW_ACCESSIBLE, GtkTreeViewAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_VIEW_ACCESSIBLE</NAME>
#define GTK_IS_TREE_VIEW_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_VIEW_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_TREE_VIEW_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_VIEW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_TREE_VIEW_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_VIEW_ACCESSIBLE, GtkTreeViewAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkTreeViewAccessible</NAME>
struct _GtkTreeViewAccessible
{
  GtkWidgetAccessible parent;

  GtkTreeViewAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeViewAccessibleClass</NAME>
struct _GtkTreeViewAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_view_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkTreeViewAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_WIDGET_ACCESSIBLE</NAME>
#define GTK_TYPE_WIDGET_ACCESSIBLE                     (gtk_widget_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_WIDGET_ACCESSIBLE</NAME>
#define GTK_WIDGET_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WIDGET_ACCESSIBLE, GtkWidgetAccessible))
</MACRO>
<MACRO>
<NAME>GTK_WIDGET_ACCESSIBLE_CLASS</NAME>
#define GTK_WIDGET_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET_ACCESSIBLE, GtkWidgetAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_WIDGET_ACCESSIBLE</NAME>
#define GTK_IS_WIDGET_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WIDGET_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_WIDGET_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_WIDGET_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_WIDGET_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_WIDGET_ACCESSIBLE_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WIDGET_ACCESSIBLE, GtkWidgetAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkWidgetAccessible</NAME>
struct _GtkWidgetAccessible
{
  GtkAccessible parent;

  GtkWidgetAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkWidgetAccessibleClass</NAME>
struct _GtkWidgetAccessibleClass
{
  GtkAccessibleClass parent_class;

  /*
   * Signal handler for notify signal on GTK widget
   */
  void (*notify_gtk)                   (GObject             *object,
                                        GParamSpec          *pspec);

};
</STRUCT>
<FUNCTION>
<NAME>gtk_widget_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkWidgetAccessiblePrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_widget_accessible_update_bounds</NAME>
<RETURNS>void</RETURNS>
GtkWidgetAccessible *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_WINDOW_ACCESSIBLE</NAME>
#define GTK_TYPE_WINDOW_ACCESSIBLE                        (gtk_window_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_ACCESSIBLE</NAME>
#define GTK_WINDOW_ACCESSIBLE(obj)                        (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_WINDOW_ACCESSIBLE, GtkWindowAccessible))
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_ACCESSIBLE_CLASS</NAME>
#define GTK_WINDOW_ACCESSIBLE_CLASS(klass)                (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WINDOW_ACCESSIBLE, GtkWindowAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_WINDOW_ACCESSIBLE</NAME>
#define GTK_IS_WINDOW_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_WINDOW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_WINDOW_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_WINDOW_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WINDOW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_WINDOW_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_WINDOW_ACCESSIBLE_GET_CLASS(obj)              (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WINDOW_ACCESSIBLE, GtkWindowAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkWindowAccessible</NAME>
struct _GtkWindowAccessible
{
  GtkWidgetAccessible parent;

  GtkWindowAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkWindowAccessibleClass</NAME>
struct _GtkWindowAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_window_accessible_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkWindowAccessiblePrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_css_data_url_parse</NAME>
<RETURNS>GBytes *</RETURNS>
const char             *url, char                  **out_mimetype, GError                **error
</FUNCTION>
<ENUM>
<NAME>GtkCssParserError</NAME>
typedef enum
{
  GTK_CSS_PARSER_ERROR_FAILED,
  GTK_CSS_PARSER_ERROR_SYNTAX,
  GTK_CSS_PARSER_ERROR_IMPORT,
  GTK_CSS_PARSER_ERROR_NAME,
  GTK_CSS_PARSER_ERROR_UNKNOWN_VALUE
} GtkCssParserError;
</ENUM>
<ENUM>
<NAME>GtkCssParserWarning</NAME>
typedef enum
{
  GTK_CSS_PARSER_WARNING_DEPRECATED,
  GTK_CSS_PARSER_WARNING_SYNTAX,
  GTK_CSS_PARSER_WARNING_UNIMPLEMENTED
} GtkCssParserWarning;
</ENUM>
<MACRO>
<NAME>GTK_CSS_PARSER_ERROR</NAME>
#define GTK_CSS_PARSER_ERROR (gtk_css_parser_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gtk_css_parser_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_CSS_PARSER_WARNING</NAME>
#define GTK_CSS_PARSER_WARNING (gtk_css_parser_warning_quark ())
</MACRO>
<FUNCTION>
<NAME>gtk_css_parser_warning_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCssLocation</NAME>
struct _GtkCssLocation
{
  gsize                  bytes;
  gsize                  chars;
  gsize                  lines;
  gsize                  line_bytes;
  gsize                  line_chars;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_css_location_init</NAME>
<RETURNS>void</RETURNS>
GtkCssLocation         *location
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_location_advance</NAME>
<RETURNS>void</RETURNS>
GtkCssLocation         *location, gsize                   bytes, gsize                   chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_location_advance_newline</NAME>
<RETURNS>void</RETURNS>
GtkCssLocation         *location, gboolean                is_windows
</FUNCTION>
<STRUCT>
<NAME>GtkCssParseOption</NAME>
struct _GtkCssParseOption
{
  gboolean (* can_parse)  (GtkCssParser *parser,
                           gpointer      option_data,
                           gpointer      user_data);
  gboolean (* parse)      (GtkCssParser *parser,
                           gpointer      option_data,
                           gpointer      user_data);
  gpointer data;
};
</STRUCT>
<USER_FUNCTION>
<NAME>GtkCssParserErrorFunc</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *parser, const GtkCssLocation           *start, const GtkCssLocation           *end, const GError                   *error, gpointer                        user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_new_for_file</NAME>
<RETURNS>GtkCssParser *</RETURNS>
GFile                          *file, GtkCssParserErrorFunc           error_func, gpointer                        user_data, GDestroyNotify                  user_destroy, GError                        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_new_for_bytes</NAME>
<RETURNS>GtkCssParser *</RETURNS>
GBytes                         *bytes, GFile                          *file, GFile                          *base_directory, GtkCssParserErrorFunc           error_func, gpointer                        user_data, GDestroyNotify                  user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_ref</NAME>
<RETURNS>GtkCssParser *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_unref</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_get_file</NAME>
<RETURNS>GFile *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_resolve_url</NAME>
<RETURNS>GFile *</RETURNS>
GtkCssParser                   *self, const char                     *url
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_get_start_location</NAME>
<RETURNS>const GtkCssLocation *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_get_end_location</NAME>
<RETURNS>const GtkCssLocation *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_get_block_location</NAME>
<RETURNS>const GtkCssLocation *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_peek_token</NAME>
<RETURNS>const GtkCssToken *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_get_token</NAME>
<RETURNS>const GtkCssToken *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_token</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_start_block</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_start_semicolon_block</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, GtkCssTokenType                 alternative_token
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_end_block_prelude</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_end_block</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_skip</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_skip_until</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, GtkCssTokenType                 token_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_emit_error</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, const GtkCssLocation           *start, const GtkCssLocation           *end, const GError                   *error
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_error</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, GtkCssParserError               code, const GtkCssLocation           *start, const GtkCssLocation           *end, const char                     *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_error_syntax</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, const char                     *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_error_value</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, const char                     *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_error_import</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, const char                     *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_warn</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, GtkCssParserWarning             code, const GtkCssLocation           *start, const GtkCssLocation           *end, const char                     *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_warn_syntax</NAME>
<RETURNS>void</RETURNS>
GtkCssParser                   *self, const char                     *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_has_token</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, GtkCssTokenType                 token_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_has_ident</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, const char                     *ident
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_has_number</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_has_integer</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_has_function</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, const char                     *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_try_delim</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, gunichar                        codepoint
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_try_ident</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, const char                     *ident
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_try_at_keyword</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, const char                     *keyword
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_try_token</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, GtkCssTokenType                 token_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_ident</NAME>
<RETURNS>char *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_string</NAME>
<RETURNS>char *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_url</NAME>
<RETURNS>char *</RETURNS>
GtkCssParser                   *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_number</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, double                         *number
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_integer</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, int                            *number
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_percentage</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, double                         *number
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_function</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssParser                   *self, guint                           min_args, guint                           max_args, guint (* parse_func) (GtkCssParser *, guint, gpointer), gpointer                        data
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_parser_consume_any</NAME>
<RETURNS>gsize</RETURNS>
GtkCssParser                   *parser, const GtkCssParseOption        *options, gsize                           n_options, gpointer                        user_data
</FUNCTION>
<STRUCT>
<NAME>GtkCssParser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CSS_SECTION</NAME>
#define GTK_TYPE_CSS_SECTION         (gtk_css_section_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_css_section_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_new</NAME>
<RETURNS>GtkCssSection *</RETURNS>
GFile                *file, const GtkCssLocation *start, const GtkCssLocation *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_ref</NAME>
<RETURNS>GtkCssSection *</RETURNS>
GtkCssSection        *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_unref</NAME>
<RETURNS>void</RETURNS>
GtkCssSection        *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_print</NAME>
<RETURNS>void</RETURNS>
const GtkCssSection  *section, GString              *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_to_string</NAME>
<RETURNS>char *</RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_parent</NAME>
<RETURNS>GtkCssSection *</RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_file</NAME>
<RETURNS>GFile *</RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_start_location</NAME>
<RETURNS>const GtkCssLocation *</RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_end_location</NAME>
<RETURNS>const GtkCssLocation *</RETURNS>
const GtkCssSection  *section
</FUNCTION>
<STRUCT>
<NAME>GtkCssSection</NAME>
</STRUCT>
<ENUM>
<NAME>GtkCssTokenType</NAME>
typedef enum {
  /* no content */
  GTK_CSS_TOKEN_EOF,
  GTK_CSS_TOKEN_WHITESPACE,
  GTK_CSS_TOKEN_OPEN_PARENS,
  GTK_CSS_TOKEN_CLOSE_PARENS,
  GTK_CSS_TOKEN_OPEN_SQUARE,
  GTK_CSS_TOKEN_CLOSE_SQUARE,
  GTK_CSS_TOKEN_OPEN_CURLY,
  GTK_CSS_TOKEN_CLOSE_CURLY,
  GTK_CSS_TOKEN_COMMA,
  GTK_CSS_TOKEN_COLON,
  GTK_CSS_TOKEN_SEMICOLON,
  GTK_CSS_TOKEN_CDO,
  GTK_CSS_TOKEN_CDC,
  GTK_CSS_TOKEN_INCLUDE_MATCH,
  GTK_CSS_TOKEN_DASH_MATCH,
  GTK_CSS_TOKEN_PREFIX_MATCH,
  GTK_CSS_TOKEN_SUFFIX_MATCH,
  GTK_CSS_TOKEN_SUBSTRING_MATCH,
  GTK_CSS_TOKEN_COLUMN,
  GTK_CSS_TOKEN_BAD_STRING,
  GTK_CSS_TOKEN_BAD_URL,
  GTK_CSS_TOKEN_COMMENT,
  /* delim */
  GTK_CSS_TOKEN_DELIM,
  /* string */
  GTK_CSS_TOKEN_STRING,
  GTK_CSS_TOKEN_IDENT,
  GTK_CSS_TOKEN_FUNCTION,
  GTK_CSS_TOKEN_AT_KEYWORD,
  GTK_CSS_TOKEN_HASH_UNRESTRICTED,
  GTK_CSS_TOKEN_HASH_ID,
  GTK_CSS_TOKEN_URL,
  /* number */
  GTK_CSS_TOKEN_SIGNED_INTEGER,
  GTK_CSS_TOKEN_SIGNLESS_INTEGER,
  GTK_CSS_TOKEN_SIGNED_NUMBER,
  GTK_CSS_TOKEN_SIGNLESS_NUMBER,
  GTK_CSS_TOKEN_PERCENTAGE,
  /* dimension */
  GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION,
  GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION,
  GTK_CSS_TOKEN_DIMENSION
} GtkCssTokenType;
</ENUM>
<STRUCT>
<NAME>GtkCssStringToken</NAME>
struct _GtkCssStringToken {
  GtkCssTokenType  type;
  char            *string;
};
</STRUCT>
<STRUCT>
<NAME>GtkCssDelimToken</NAME>
struct _GtkCssDelimToken {
  GtkCssTokenType  type;
  gunichar         delim;
};
</STRUCT>
<STRUCT>
<NAME>GtkCssNumberToken</NAME>
struct _GtkCssNumberToken {
  GtkCssTokenType  type;
  double           number;
};
</STRUCT>
<STRUCT>
<NAME>GtkCssDimensionToken</NAME>
struct _GtkCssDimensionToken {
  GtkCssTokenType  type;
  double           value;
  char            *dimension;
};
</STRUCT>
<UNION>
<NAME>GtkCssToken</NAME>
union _GtkCssToken {
  GtkCssTokenType type;
  GtkCssStringToken string;
  GtkCssDelimToken delim;
  GtkCssNumberToken number;
  GtkCssDimensionToken dimension;
};
</UNION>
<FUNCTION>
<NAME>gtk_css_token_clear</NAME>
<RETURNS>void</RETURNS>
GtkCssToken            *token
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_finite</NAME>
<RETURNS>gboolean</RETURNS>
const GtkCssToken      *token
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_preserved</NAME>
<RETURNS>gboolean</RETURNS>
const GtkCssToken      *token, GtkCssTokenType        *out_closing
</FUNCTION>
<MACRO>
<NAME>gtk_css_token_is</NAME>
#define gtk_css_token_is(token, _type) ((token)->type == (_type))
</MACRO>
<FUNCTION>
<NAME>gtk_css_token_is_ident</NAME>
<RETURNS>gboolean</RETURNS>
const GtkCssToken      *token, const char             *ident
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_function</NAME>
<RETURNS>gboolean</RETURNS>
const GtkCssToken      *token, const char             *ident
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_delim</NAME>
<RETURNS>gboolean</RETURNS>
const GtkCssToken      *token, gunichar                delim
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_print</NAME>
<RETURNS>void</RETURNS>
const GtkCssToken      *token, GString                *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_to_string</NAME>
<RETURNS>char *</RETURNS>
const GtkCssToken      *token
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_new</NAME>
<RETURNS>GtkCssTokenizer *</RETURNS>
GBytes                 *bytes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_ref</NAME>
<RETURNS>GtkCssTokenizer *</RETURNS>
GtkCssTokenizer        *tokenizer
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_unref</NAME>
<RETURNS>void</RETURNS>
GtkCssTokenizer        *tokenizer
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_get_location</NAME>
<RETURNS>const GtkCssLocation *</RETURNS>
GtkCssTokenizer        *tokenizer
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_read_token</NAME>
<RETURNS>gboolean</RETURNS>
GtkCssTokenizer        *tokenizer, GtkCssToken            *token, GError                **error
</FUNCTION>
<STRUCT>
<NAME>GtkCssTokenizer</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_ACTION_EDITOR</NAME>
#define GTK_TYPE_INSPECTOR_ACTION_EDITOR            (gtk_inspector_action_editor_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTION_EDITOR</NAME>
#define GTK_INSPECTOR_ACTION_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditor))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTION_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_ACTION_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditorClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTION_EDITOR</NAME>
#define GTK_INSPECTOR_IS_ACTION_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTION_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_IS_ACTION_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_ACTION_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTION_EDITOR_GET_CLASS</NAME>
#define GTK_INSPECTOR_ACTION_EDITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditorClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_action_editor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_action_editor_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GActionGroup *group, const gchar  *name, GtkSizeGroup *activate
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_action_editor_update</NAME>
<RETURNS>void</RETURNS>
GtkInspectorActionEditor *r, gboolean                  enabled, GVariant                 *state
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorActionEditorPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_ACTIONS</NAME>
#define GTK_TYPE_INSPECTOR_ACTIONS            (gtk_inspector_actions_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTIONS</NAME>
#define GTK_INSPECTOR_ACTIONS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActions))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTIONS_CLASS</NAME>
#define GTK_INSPECTOR_ACTIONS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActionsClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTIONS</NAME>
#define GTK_INSPECTOR_IS_ACTIONS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_ACTIONS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTIONS_CLASS</NAME>
#define GTK_INSPECTOR_IS_ACTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_ACTIONS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTIONS_GET_CLASS</NAME>
#define GTK_INSPECTOR_ACTIONS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActionsClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_actions_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_actions_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorActions *sl, GObject              *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorActionsPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BASELINE_OVERLAY</NAME>
#define GTK_TYPE_BASELINE_OVERLAY             (gtk_baseline_overlay_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_baseline_overlay_new</NAME>
<RETURNS>GtkInspectorOverlay *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkBaselineOverlay</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_GRAPH</NAME>
#define GTK_TYPE_CELL_RENDERER_GRAPH            (gtk_cell_renderer_graph_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_GRAPH</NAME>
#define GTK_CELL_RENDERER_GRAPH(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_GRAPH, GtkCellRendererGraph))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_GRAPH_CLASS</NAME>
#define GTK_CELL_RENDERER_GRAPH_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_GRAPH, GtkCellRendererGraphClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_GRAPH</NAME>
#define GTK_IS_CELL_RENDERER_GRAPH(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_GRAPH))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_GRAPH_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_GRAPH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_GRAPH))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_GRAPH_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_GRAPH_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_GRAPH, GtkCellRendererGraphClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererGraph</NAME>
struct _GtkCellRendererGraph
{
  GtkCellRenderer                parent;

  /*< private >*/
  GtkCellRendererGraphPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererGraphClass</NAME>
struct _GtkCellRendererGraphClass
{
  GtkCellRendererClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_graph_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_graph_new</NAME>
<RETURNS>GtkCellRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererGraphPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_CONTROLLERS</NAME>
#define GTK_TYPE_INSPECTOR_CONTROLLERS            (gtk_inspector_controllers_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CONTROLLERS</NAME>
#define GTK_INSPECTOR_CONTROLLERS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_CONTROLLERS, GtkInspectorControllers))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CONTROLLERS_CLASS</NAME>
#define GTK_INSPECTOR_CONTROLLERS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_CONTROLLERS, GtkInspectorControllersClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_GESTURES</NAME>
#define GTK_INSPECTOR_IS_GESTURES(obj)            (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_CONTROLLERS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_GESTURES_CLASS</NAME>
#define GTK_INSPECTOR_IS_GESTURES_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_CONTROLLERS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CONTROLLERS_GET_CLASS</NAME>
#define GTK_INSPECTOR_CONTROLLERS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_CONTROLLERS, GtkInspectorControllersClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_controllers_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_controllers_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorControllers        *sl, GObject                        *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorControllersPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_CSS_EDITOR</NAME>
#define GTK_TYPE_INSPECTOR_CSS_EDITOR            (gtk_inspector_css_editor_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CSS_EDITOR</NAME>
#define GTK_INSPECTOR_CSS_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_CSS_EDITOR, GtkInspectorCssEditor))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CSS_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_CSS_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_CSS_EDITOR, GtkInspectorCssEditorClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_CSS_EDITOR</NAME>
#define GTK_INSPECTOR_IS_CSS_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_CSS_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_CSS_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_IS_CSS_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_CSS_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CSS_EDITOR_GET_CLASS</NAME>
#define GTK_INSPECTOR_CSS_EDITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_CSS_EDITOR, GtkInspectorCssEditorClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_css_editor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_css_editor_set_display</NAME>
<RETURNS>void</RETURNS>
GtkInspectorCssEditor *ce, GdkDisplay            *display
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorCssEditorPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_CSS_NODE_TREE</NAME>
#define GTK_TYPE_INSPECTOR_CSS_NODE_TREE            (gtk_inspector_css_node_tree_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CSS_NODE_TREE</NAME>
#define GTK_INSPECTOR_CSS_NODE_TREE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_CSS_NODE_TREE, GtkInspectorCssNodeTree))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CSS_NODE_TREE_CLASS</NAME>
#define GTK_INSPECTOR_CSS_NODE_TREE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_CSS_NODE_TREE, GtkInspectorCssNodeTreeClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_CSS_NODE_TREE</NAME>
#define GTK_INSPECTOR_IS_CSS_NODE_TREE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_CSS_NODE_TREE))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_CSS_NODE_TREE_CLASS</NAME>
#define GTK_INSPECTOR_IS_CSS_NODE_TREE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_CSS_NODE_TREE))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_CSS_NODE_TREE_GET_CLASS</NAME>
#define GTK_INSPECTOR_CSS_NODE_TREE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_CSS_NODE_TREE, GtkInspectorCssNodeTreeClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_css_node_tree_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_css_node_tree_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorCssNodeTree        *cnt, GObject                        *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_css_node_tree_get_node</NAME>
<RETURNS>GtkCssNode *</RETURNS>
GtkInspectorCssNodeTree        *cnt
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_css_node_tree_set_display</NAME>
<RETURNS>void</RETURNS>
GtkInspectorCssNodeTree        *cnt, GdkDisplay                     *display
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorCssNodeTreePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_DATA_LIST</NAME>
#define GTK_TYPE_INSPECTOR_DATA_LIST            (gtk_inspector_data_list_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_DATA_LIST</NAME>
#define GTK_INSPECTOR_DATA_LIST(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_DATA_LIST, GtkInspectorDataList))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_DATA_LIST_CLASS</NAME>
#define GTK_INSPECTOR_DATA_LIST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_DATA_LIST, GtkInspectorDataListClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_DATA_LIST</NAME>
#define GTK_INSPECTOR_IS_DATA_LIST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_DATA_LIST))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_DATA_LIST_CLASS</NAME>
#define GTK_INSPECTOR_IS_DATA_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_DATA_LIST))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_DATA_LIST_GET_CLASS</NAME>
#define GTK_INSPECTOR_DATA_LIST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_DATA_LIST, GtkInspectorDataListClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_data_list_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_data_list_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorDataList *sl, GObject              *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorDataListPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FOCUS_OVERLAY</NAME>
#define GTK_TYPE_FOCUS_OVERLAY             (gtk_focus_overlay_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_focus_overlay_new</NAME>
<RETURNS>GtkInspectorOverlay *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_focus_overlay_set_color</NAME>
<RETURNS>void</RETURNS>
GtkFocusOverlay    *self, const GdkRGBA      *color
</FUNCTION>
<STRUCT>
<NAME>GtkFocusOverlay</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FPS_OVERLAY</NAME>
#define GTK_TYPE_FPS_OVERLAY (gtk_fps_overlay_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_fps_overlay_new</NAME>
<RETURNS>GtkInspectorOverlay *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkFpsOverlay</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_GENERAL</NAME>
#define GTK_TYPE_INSPECTOR_GENERAL            (gtk_inspector_general_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_GENERAL</NAME>
#define GTK_INSPECTOR_GENERAL(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_GENERAL, GtkInspectorGeneral))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_GENERAL_CLASS</NAME>
#define GTK_INSPECTOR_GENERAL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_GENERAL, GtkInspectorGeneralClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_GENERAL</NAME>
#define GTK_INSPECTOR_IS_GENERAL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_GENERAL))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_GENERAL_CLASS</NAME>
#define GTK_INSPECTOR_IS_GENERAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_GENERAL))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_GENERAL_GET_CLASS</NAME>
#define GTK_INSPECTOR_GENERAL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_GENERAL, GtkInspectorGeneralClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_general_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_general_set_display</NAME>
<RETURNS>void</RETURNS>
GtkInspectorGeneral *general, GdkDisplay          *display
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorGeneralPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GRAPH_DATA</NAME>
#define GTK_TYPE_GRAPH_DATA            (gtk_graph_data_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GRAPH_DATA</NAME>
#define GTK_GRAPH_DATA(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_GRAPH_DATA, GtkGraphData))
</MACRO>
<MACRO>
<NAME>GTK_GRAPH_DATA_CLASS</NAME>
#define GTK_GRAPH_DATA_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_GRAPH_DATA, GtkGraphDataClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GRAPH_DATA</NAME>
#define GTK_IS_GRAPH_DATA(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_GRAPH_DATA))
</MACRO>
<MACRO>
<NAME>GTK_IS_GRAPH_DATA_CLASS</NAME>
#define GTK_IS_GRAPH_DATA_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_GRAPH_DATA))
</MACRO>
<MACRO>
<NAME>GTK_GRAPH_DATA_GET_CLASS</NAME>
#define GTK_GRAPH_DATA_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GRAPH_DATA, GtkGraphDataClass))
</MACRO>
<STRUCT>
<NAME>GtkGraphData</NAME>
struct _GtkGraphData
{
  GObject              object;

  /*< private >*/
  GtkGraphDataPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkGraphDataClass</NAME>
struct _GtkGraphDataClass
{
  GObjectClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_graph_data_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_graph_data_new</NAME>
<RETURNS>GtkGraphData *</RETURNS>
guint           n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_graph_data_get_n_values</NAME>
<RETURNS>guint</RETURNS>
GtkGraphData   *data
</FUNCTION>
<FUNCTION>
<NAME>gtk_graph_data_get_value</NAME>
<RETURNS>double</RETURNS>
GtkGraphData   *data, guint           i
</FUNCTION>
<FUNCTION>
<NAME>gtk_graph_data_get_minimum</NAME>
<RETURNS>double</RETURNS>
GtkGraphData   *data
</FUNCTION>
<FUNCTION>
<NAME>gtk_graph_data_get_maximum</NAME>
<RETURNS>double</RETURNS>
GtkGraphData   *data
</FUNCTION>
<FUNCTION>
<NAME>gtk_graph_data_prepend_value</NAME>
<RETURNS>void</RETURNS>
GtkGraphData   *data, double          value
</FUNCTION>
<STRUCT>
<NAME>GtkGraphDataPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_MODEL_CSS_NODE</NAME>
#define GTK_TYPE_TREE_MODEL_CSS_NODE			(gtk_tree_model_css_node_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_CSS_NODE</NAME>
#define GTK_TREE_MODEL_CSS_NODE(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL_CSS_NODE, GtkTreeModelCssNode))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_CSS_NODE_CLASS</NAME>
#define GTK_TREE_MODEL_CSS_NODE_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_MODEL_CSS_NODE, GtkTreeModelCssNodeClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL_CSS_NODE</NAME>
#define GTK_IS_TREE_MODEL_CSS_NODE(obj)			(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL_CSS_NODE))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL_CSS_NODE_CLASS</NAME>
#define GTK_IS_TREE_MODEL_CSS_NODE_CLASS(klass)		(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_MODEL_CSS_NODE))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_CSS_NODE_GET_CLASS</NAME>
#define GTK_TREE_MODEL_CSS_NODE_GET_CLASS(obj)		(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_MODEL_CSS_NODE, GtkTreeModelCssNodeClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeModelCssNodeGetFunc</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelCssNode   *model, GtkCssNode            *node, int                    column, GValue                *value
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTreeModelCssNode</NAME>
struct _GtkTreeModelCssNode
{
  GObject parent;

  GtkTreeModelCssNodePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeModelCssNodeClass</NAME>
struct _GtkTreeModelCssNodeClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_model_css_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_css_node_new</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeModelCssNodeGetFunc get_func, gint            n_columns, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_css_node_newv</NAME>
<RETURNS>GtkTreeModel *</RETURNS>
GtkTreeModelCssNodeGetFunc get_func, gint            n_columns, GType          *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_css_node_set_root_node</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelCssNode    *model, GtkCssNode             *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_css_node_get_root_node</NAME>
<RETURNS>GtkCssNode *</RETURNS>
GtkTreeModelCssNode    *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_css_node_get_node_from_iter</NAME>
<RETURNS>GtkCssNode *</RETURNS>
GtkTreeModelCssNode    *model, GtkTreeIter            *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_css_node_get_iter_from_node</NAME>
<RETURNS>void</RETURNS>
GtkTreeModelCssNode    *model, GtkTreeIter            *iter, GtkCssNode             *node
</FUNCTION>
<STRUCT>
<NAME>GtkTreeModelCssNodePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_HIGHLIGHT_OVERLAY</NAME>
#define GTK_TYPE_HIGHLIGHT_OVERLAY             (gtk_highlight_overlay_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_highlight_overlay_new</NAME>
<RETURNS>GtkInspectorOverlay *</RETURNS>
GtkWidget              *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_highlight_overlay_get_widget</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkHighlightOverlay    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_highlight_overlay_set_color</NAME>
<RETURNS>void</RETURNS>
GtkHighlightOverlay    *self, const GdkRGBA          *color
</FUNCTION>
<STRUCT>
<NAME>GtkHighlightOverlay</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_inspector_init</NAME>
<RETURNS>void</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_OVERLAY</NAME>
#define GTK_TYPE_INSPECTOR_OVERLAY             (gtk_inspector_overlay_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkInspectorOverlayClass</NAME>
struct _GtkInspectorOverlayClass
{
  GObjectClass parent_class;

  void                  (* snapshot)                            (GtkInspectorOverlay    *self,
                                                                 GtkSnapshot            *snapshot,
                                                                 GskRenderNode          *node,
                                                                 GtkWidget              *widget);
  void                  (* queue_draw)                          (GtkInspectorOverlay    *self);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_inspector_overlay_snapshot</NAME>
<RETURNS>void</RETURNS>
GtkInspectorOverlay    *self, GtkSnapshot            *snapshot, GskRenderNode          *node, GtkWidget              *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_overlay_queue_draw</NAME>
<RETURNS>void</RETURNS>
GtkInspectorOverlay    *self
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorOverlay</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LAYOUT_OVERLAY</NAME>
#define GTK_TYPE_LAYOUT_OVERLAY             (gtk_layout_overlay_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_layout_overlay_new</NAME>
<RETURNS>GtkInspectorOverlay *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkLayoutOverlay</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_LOGS</NAME>
#define GTK_TYPE_INSPECTOR_LOGS            (gtk_inspector_logs_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_LOGS</NAME>
#define GTK_INSPECTOR_LOGS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_LOGS, GtkInspectorLogs))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_LOGS_CLASS</NAME>
#define GTK_INSPECTOR_LOGS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_LOGS, GtkInspectorLogsClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_LOGS</NAME>
#define GTK_INSPECTOR_IS_LOGS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_LOGS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_LOGS_CLASS</NAME>
#define GTK_INSPECTOR_IS_LOGS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_LOGS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_LOGS_GET_CLASS</NAME>
#define GTK_INSPECTOR_LOGS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_LOGS, GtkInspectorLogsClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_logs_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_logs_set_display</NAME>
<RETURNS>void</RETURNS>
GtkInspectorLogs *logs, GdkDisplay       *display
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorLogsPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_MAGNIFIER</NAME>
#define GTK_TYPE_INSPECTOR_MAGNIFIER            (gtk_inspector_magnifier_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MAGNIFIER</NAME>
#define GTK_INSPECTOR_MAGNIFIER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_MAGNIFIER, GtkInspectorMagnifier))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MAGNIFIER_CLASS</NAME>
#define GTK_INSPECTOR_MAGNIFIER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_MAGNIFIER, GtkInspectorMagnifierClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_MAGNIFIER</NAME>
#define GTK_INSPECTOR_IS_MAGNIFIER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_MAGNIFIER))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_MAGNIFIER_CLASS</NAME>
#define GTK_INSPECTOR_IS_MAGNIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_MAGNIFIER))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MAGNIFIER_GET_CLASS</NAME>
#define GTK_INSPECTOR_MAGNIFIER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_MAGNIFIER, GtkInspectorMagnifierClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_magnifier_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_magnifier_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorMagnifier *sl, GObject               *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorMagnifierPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_MENU</NAME>
#define GTK_TYPE_INSPECTOR_MENU            (gtk_inspector_menu_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MENU</NAME>
#define GTK_INSPECTOR_MENU(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_MENU, GtkInspectorMenu))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MENU_CLASS</NAME>
#define GTK_INSPECTOR_MENU_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_MENU, GtkInspectorMenuClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_MENU</NAME>
#define GTK_INSPECTOR_IS_MENU(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_MENU))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_MENU_CLASS</NAME>
#define GTK_INSPECTOR_IS_MENU_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_MENU))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MENU_GET_CLASS</NAME>
#define GTK_INSPECTOR_MENU_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_MENU, GtkInspectorMenuClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_menu_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_menu_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorMenu *sl, GObject          *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorMenuPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_MISC_INFO</NAME>
#define GTK_TYPE_INSPECTOR_MISC_INFO            (gtk_inspector_misc_info_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MISC_INFO</NAME>
#define GTK_INSPECTOR_MISC_INFO(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_MISC_INFO, GtkInspectorMiscInfo))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MISC_INFO_CLASS</NAME>
#define GTK_INSPECTOR_MISC_INFO_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_MISC_INFO, GtkInspectorMiscInfoClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_MISC_INFO</NAME>
#define GTK_INSPECTOR_IS_MISC_INFO(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_MISC_INFO))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_MISC_INFO_CLASS</NAME>
#define GTK_INSPECTOR_IS_MISC_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_MISC_INFO))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_MISC_INFO_GET_CLASS</NAME>
#define GTK_INSPECTOR_MISC_INFO_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_MISC_INFO, GtkInspectorMiscInfoClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_misc_info_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_misc_info_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorMiscInfo *sl, GObject              *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorMiscInfoPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_OBJECT_TREE</NAME>
#define GTK_TYPE_INSPECTOR_OBJECT_TREE            (gtk_inspector_object_tree_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_OBJECT_TREE</NAME>
#define GTK_INSPECTOR_OBJECT_TREE(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_OBJECT_TREE, GtkInspectorObjectTree))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_OBJECT_TREE_CLASS</NAME>
#define GTK_INSPECTOR_OBJECT_TREE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_OBJECT_TREE, GtkInspectorObjectTreeClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_OBJECT_TREE</NAME>
#define GTK_INSPECTOR_IS_OBJECT_TREE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_OBJECT_TREE))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_OBJECT_TREE_CLASS</NAME>
#define GTK_INSPECTOR_IS_OBJECT_TREE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_OBJECT_TREE))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_OBJECT_TREE_GET_CLASS</NAME>
#define GTK_INSPECTOR_OBJECT_TREE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_OBJECT_TREE, GtkInspectorObjectTreeClass))
</MACRO>
<USER_FUNCTION>
<NAME>object_selected</NAME>
<RETURNS>void</RETURNS>
GtkInspectorObjectTree *wt, GObject                *object
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>object_activated</NAME>
<RETURNS>void</RETURNS>
GtkInspectorObjectTree *wt, GObject                *object
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_object_tree_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_get_object_title</NAME>
<RETURNS>char *</RETURNS>
GObject                *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_object_tree_select_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorObjectTree *wt, GObject                *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_object_tree_activate_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorObjectTree *wt, GObject                *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_object_tree_get_selected</NAME>
<RETURNS>GObject *</RETURNS>
GtkInspectorObjectTree *wt
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_object_tree_set_display</NAME>
<RETURNS>void</RETURNS>
GtkInspectorObjectTree *wt, GdkDisplay             *display
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorObjectTreePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_PROP_EDITOR</NAME>
#define GTK_TYPE_INSPECTOR_PROP_EDITOR            (gtk_inspector_prop_editor_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_PROP_EDITOR</NAME>
#define GTK_INSPECTOR_PROP_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_PROP_EDITOR, GtkInspectorPropEditor))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_PROP_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_PROP_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_PROP_EDITOR, GtkInspectorPropEditorClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_PROP_EDITOR</NAME>
#define GTK_INSPECTOR_IS_PROP_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_PROP_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_PROP_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_IS_PROP_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_PROP_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_PROP_EDITOR_GET_CLASS</NAME>
#define GTK_INSPECTOR_PROP_EDITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_PROP_EDITOR, GtkInspectorPropEditorClass))
</MACRO>
<USER_FUNCTION>
<NAME>show_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorPropEditor *editor, GObject                *object, const gchar            *name, const gchar            *tab
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_prop_editor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_prop_editor_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GObject      *object, const gchar  *name, GtkSizeGroup *values
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_prop_editor_should_expand</NAME>
<RETURNS>gboolean</RETURNS>
GtkInspectorPropEditor *editor
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorPropEditorPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_PROP_LIST</NAME>
#define GTK_TYPE_INSPECTOR_PROP_LIST            (gtk_inspector_prop_list_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_PROP_LIST</NAME>
#define GTK_INSPECTOR_PROP_LIST(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_PROP_LIST, GtkInspectorPropList))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_PROP_LIST_CLASS</NAME>
#define GTK_INSPECTOR_PROP_LIST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_PROP_LIST, GtkInspectorPropListClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_PROP_LIST</NAME>
#define GTK_INSPECTOR_IS_PROP_LIST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_PROP_LIST))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_PROP_LIST_CLASS</NAME>
#define GTK_INSPECTOR_IS_PROP_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_PROP_LIST))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_PROP_LIST_GET_CLASS</NAME>
#define GTK_INSPECTOR_PROP_LIST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_PROP_LIST, GtkInspectorPropListClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_prop_list_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_prop_list_set_object</NAME>
<RETURNS>gboolean</RETURNS>
GtkInspectorPropList *pl, GObject              *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_prop_list_set_layout_child</NAME>
<RETURNS>void</RETURNS>
GtkInspectorPropList *pl, GObject              *object
</FUNCTION>
<FUNCTION>
<NAME>strdup_value_contents</NAME>
<RETURNS>void</RETURNS>
const GValue  *value, gchar        **contents, gchar        **type
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorPropListPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_RECORDER</NAME>
#define GTK_TYPE_INSPECTOR_RECORDER            (gtk_inspector_recorder_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RECORDER</NAME>
#define GTK_INSPECTOR_RECORDER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_RECORDER, GtkInspectorRecorder))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RECORDER_CLASS</NAME>
#define GTK_INSPECTOR_RECORDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_RECORDER, GtkInspectorRecorderClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RECORDER</NAME>
#define GTK_INSPECTOR_IS_RECORDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_RECORDER))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RECORDER_CLASS</NAME>
#define GTK_INSPECTOR_IS_RECORDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_RECORDER))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RECORDER_GET_CLASS</NAME>
#define GTK_INSPECTOR_RECORDER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_RECORDER, GtkInspectorRecorderClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_recorder_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_recorder_set_recording</NAME>
<RETURNS>void</RETURNS>
GtkInspectorRecorder   *recorder, gboolean                record
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_recorder_is_recording</NAME>
<RETURNS>gboolean</RETURNS>
GtkInspectorRecorder   *recorder
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_recorder_set_debug_nodes</NAME>
<RETURNS>void</RETURNS>
GtkInspectorRecorder   *recorder, gboolean                debug_nodes
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_recorder_record_render</NAME>
<RETURNS>void</RETURNS>
GtkInspectorRecorder   *recorder, GtkWidget              *widget, GskRenderer            *renderer, GdkSurface             *surface, const cairo_region_t   *region, GskRenderNode          *node
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorRecorderPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_RECORDING</NAME>
#define GTK_TYPE_INSPECTOR_RECORDING            (gtk_inspector_recording_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RECORDING</NAME>
#define GTK_INSPECTOR_RECORDING(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_RECORDING, GtkInspectorRecording))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RECORDING_CLASS</NAME>
#define GTK_INSPECTOR_RECORDING_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_RECORDING, GtkInspectorRecordingClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RECORDING</NAME>
#define GTK_INSPECTOR_IS_RECORDING(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_RECORDING))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RECORDING_CLASS</NAME>
#define GTK_INSPECTOR_IS_RECORDING_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_RECORDING))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RECORDING_GET_CLASS</NAME>
#define GTK_INSPECTOR_RECORDING_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_RECORDING, GtkInspectorRecordingClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_recording_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_recording_get_timestamp</NAME>
<RETURNS>gint64</RETURNS>
GtkInspectorRecording  *recording
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorRecordingPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_RENDER_RECORDING</NAME>
#define GTK_TYPE_INSPECTOR_RENDER_RECORDING            (gtk_inspector_render_recording_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RENDER_RECORDING</NAME>
#define GTK_INSPECTOR_RENDER_RECORDING(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_RENDER_RECORDING, GtkInspectorRenderRecording))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RENDER_RECORDING_CLASS</NAME>
#define GTK_INSPECTOR_RENDER_RECORDING_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_RENDER_RECORDING, GtkInspectorRenderRecordingClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RENDER_RECORDING</NAME>
#define GTK_INSPECTOR_IS_RENDER_RECORDING(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_RENDER_RECORDING))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RENDER_RECORDING_CLASS</NAME>
#define GTK_INSPECTOR_IS_RENDER_RECORDING_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_RENDER_RECORDING))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RENDER_RECORDING_GET_CLASS</NAME>
#define GTK_INSPECTOR_RENDER_RECORDING_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_RENDER_RECORDING, GtkInspectorRenderRecordingClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_render_recording_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_render_recording_new</NAME>
<RETURNS>GtkInspectorRecording *</RETURNS>
gint64                             timestamp, GskProfiler                       *profiler, const GdkRectangle                *area, const cairo_region_t              *clip_region, GskRenderNode                     *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_render_recording_get_node</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GtkInspectorRenderRecording       *recording
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_render_recording_get_clip_region</NAME>
<RETURNS>const cairo_region_t *</RETURNS>
GtkInspectorRenderRecording     *recording
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_render_recording_get_area</NAME>
<RETURNS>const cairo_rectangle_int_t *</RETURNS>
GtkInspectorRenderRecording       *recording
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_render_recording_get_profiler_info</NAME>
<RETURNS>const char *</RETURNS>
GtkInspectorRenderRecording       *recording
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorRenderRecordingPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_RESOURCE_LIST</NAME>
#define GTK_TYPE_INSPECTOR_RESOURCE_LIST            (gtk_inspector_resource_list_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RESOURCE_LIST</NAME>
#define GTK_INSPECTOR_RESOURCE_LIST(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_RESOURCE_LIST, GtkInspectorResourceList))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RESOURCE_LIST_CLASS</NAME>
#define GTK_INSPECTOR_RESOURCE_LIST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_RESOURCE_LIST, GtkInspectorResourceListClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RESOURCE_LIST</NAME>
#define GTK_INSPECTOR_IS_RESOURCE_LIST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_RESOURCE_LIST))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_RESOURCE_LIST_CLASS</NAME>
#define GTK_INSPECTOR_IS_RESOURCE_LIST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_RESOURCE_LIST))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_RESOURCE_LIST_GET_CLASS</NAME>
#define GTK_INSPECTOR_RESOURCE_LIST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_RESOURCE_LIST, GtkInspectorResourceListClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_resource_list_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorResourceListPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_SHORTCUTS</NAME>
#define GTK_TYPE_INSPECTOR_SHORTCUTS (gtk_inspector_shortcuts_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_shortcuts_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorShortcuts *sl, GObject               *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorShortcuts</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_SIZE_GROUPS</NAME>
#define GTK_TYPE_INSPECTOR_SIZE_GROUPS            (gtk_inspector_size_groups_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_SIZE_GROUPS</NAME>
#define GTK_INSPECTOR_SIZE_GROUPS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_SIZE_GROUPS, GtkInspectorSizeGroups))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_SIZE_GROUPS_CLASS</NAME>
#define GTK_INSPECTOR_SIZE_GROUPS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_SIZE_GROUPS, GtkInspectorSizeGroupsClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_SIZE_GROUPS</NAME>
#define GTK_INSPECTOR_IS_SIZE_GROUPS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_SIZE_GROUPS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_SIZE_GROUPS_CLASS</NAME>
#define GTK_INSPECTOR_IS_SIZE_GROUPS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_SIZE_GROUPS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_SIZE_GROUPS_GET_CLASS</NAME>
#define GTK_INSPECTOR_SIZE_GROUPS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_SIZE_GROUPS, GtkInspectorSizeGroupsClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_size_groups_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_size_groups_set_object</NAME>
<RETURNS>void</RETURNS>
GtkInspectorSizeGroups *sl, GObject                *object
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_START_RECORDING</NAME>
#define GTK_TYPE_INSPECTOR_START_RECORDING            (gtk_inspector_start_recording_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_START_RECORDING</NAME>
#define GTK_INSPECTOR_START_RECORDING(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_START_RECORDING, GtkInspectorStartRecording))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_START_RECORDING_CLASS</NAME>
#define GTK_INSPECTOR_START_RECORDING_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_START_RECORDING, GtkInspectorStartRecordingClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_START_RECORDING</NAME>
#define GTK_INSPECTOR_IS_START_RECORDING(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_START_RECORDING))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_START_RECORDING_CLASS</NAME>
#define GTK_INSPECTOR_IS_START_RECORDING_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_START_RECORDING))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_START_RECORDING_GET_CLASS</NAME>
#define GTK_INSPECTOR_START_RECORDING_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_START_RECORDING, GtkInspectorStartRecordingClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_start_recording_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_start_recording_new</NAME>
<RETURNS>GtkInspectorRecording *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorStartRecordingPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_STATISTICS</NAME>
#define GTK_TYPE_INSPECTOR_STATISTICS            (gtk_inspector_statistics_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_STATISTICS</NAME>
#define GTK_INSPECTOR_STATISTICS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_STATISTICS, GtkInspectorStatistics))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_STATISTICS_CLASS</NAME>
#define GTK_INSPECTOR_STATISTICS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_STATISTICS, GtkInspectorStatisticsClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_STATISTICS</NAME>
#define GTK_INSPECTOR_IS_STATISTICS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_STATISTICS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_STATISTICS_CLASS</NAME>
#define GTK_INSPECTOR_IS_STATISTICS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_STATISTICS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_STATISTICS_GET_CLASS</NAME>
#define GTK_INSPECTOR_STATISTICS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_STATISTICS, GtkInspectorStatisticsClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_statistics_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorStatisticsPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_STRV_EDITOR</NAME>
#define GTK_TYPE_INSPECTOR_STRV_EDITOR            (gtk_inspector_strv_editor_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_STRV_EDITOR</NAME>
#define GTK_INSPECTOR_STRV_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_STRV_EDITOR, GtkInspectorStrvEditor))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_STRV_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_STRV_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_STRV_EDITOR, GtkInspectorStrvEditorClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_STRV_EDITOR</NAME>
#define GTK_INSPECTOR_IS_STRV_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_STRV_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_STRV_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_IS_STRV_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_STRV_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_STRV_EDITOR_GET_CLASS</NAME>
#define GTK_INSPECTOR_STRV_EDITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_STRV_EDITOR, GtkInspectorStrvEditorClass))
</MACRO>
<USER_FUNCTION>
<NAME>changed</NAME>
<RETURNS>void</RETURNS>
GtkInspectorStrvEditor *editor
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_strv_editor_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_strv_editor_set_strv</NAME>
<RETURNS>void</RETURNS>
GtkInspectorStrvEditor  *editor, gchar                  **strv
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_strv_editor_get_strv</NAME>
<RETURNS>gchar **</RETURNS>
GtkInspectorStrvEditor  *editor
</FUNCTION>
<USER_FUNCTION>
<NAME>RowPredicate</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel *model, GtkTreeIter  *iter, gpointer      data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_tree_walk_new</NAME>
<RETURNS>GtkTreeWalk *</RETURNS>
GtkTreeModel   *model, RowPredicate    predicate, gpointer        data, GDestroyNotify  destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_walk_free</NAME>
<RETURNS>void</RETURNS>
GtkTreeWalk *walk
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_walk_reset</NAME>
<RETURNS>void</RETURNS>
GtkTreeWalk *walk, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_walk_next_match</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeWalk *walk, gboolean     force_move, gboolean     backwards, GtkTreeIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_walk_get_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeWalk *walk, GtkTreeIter *iter
</FUNCTION>
<STRUCT>
<NAME>GtkTreeWalk</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_TYPE_POPOVER</NAME>
#define GTK_TYPE_INSPECTOR_TYPE_POPOVER (gtk_inspector_type_popover_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_type_popover_set_gtype</NAME>
<RETURNS>void</RETURNS>
GtkInspectorTypePopover *self, GType                    gtype
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorTypePopover</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_UPDATES_OVERLAY</NAME>
#define GTK_TYPE_UPDATES_OVERLAY             (gtk_updates_overlay_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_updates_overlay_new</NAME>
<RETURNS>GtkInspectorOverlay *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkUpdatesOverlay</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_VISUAL</NAME>
#define GTK_TYPE_INSPECTOR_VISUAL            (gtk_inspector_visual_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_VISUAL</NAME>
#define GTK_INSPECTOR_VISUAL(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_VISUAL, GtkInspectorVisual))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_VISUAL_CLASS</NAME>
#define GTK_INSPECTOR_VISUAL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_VISUAL, GtkInspectorVisualClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_VISUAL</NAME>
#define GTK_INSPECTOR_IS_VISUAL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_VISUAL))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_VISUAL_CLASS</NAME>
#define GTK_INSPECTOR_IS_VISUAL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_VISUAL))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_VISUAL_GET_CLASS</NAME>
#define GTK_INSPECTOR_VISUAL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_VISUAL, GtkInspectorVisualClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_visual_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_visual_set_display</NAME>
<RETURNS>void</RETURNS>
GtkInspectorVisual *vis, GdkDisplay         *display
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorVisualPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_WINDOW</NAME>
#define GTK_TYPE_INSPECTOR_WINDOW            (gtk_inspector_window_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_WINDOW</NAME>
#define GTK_INSPECTOR_WINDOW(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_WINDOW, GtkInspectorWindow))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_WINDOW_CLASS</NAME>
#define GTK_INSPECTOR_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_WINDOW, GtkInspectorWindowClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_WINDOW</NAME>
#define GTK_INSPECTOR_IS_WINDOW(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_WINDOW_CLASS</NAME>
#define GTK_INSPECTOR_IS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_WINDOW_GET_CLASS</NAME>
#define GTK_INSPECTOR_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_WINDOW, GtkInspectorWindowClass))
</MACRO>
<MACRO>
<NAME>TREE_TEXT_SCALE</NAME>
#define TREE_TEXT_SCALE 0.8
</MACRO>
<MACRO>
<NAME>TREE_CHECKBOX_SIZE</NAME>
#define TREE_CHECKBOX_SIZE (gint)(0.8 * 13)
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_window_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_window_get</NAME>
<RETURNS>GtkWidget *</RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_flash_widget</NAME>
<RETURNS>void</RETURNS>
GtkInspectorWindow *iw, GtkWidget          *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_on_inspect</NAME>
<RETURNS>void</RETURNS>
GtkWidget          *widget, GtkInspectorWindow *iw
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_window_add_overlay</NAME>
<RETURNS>void</RETURNS>
GtkInspectorWindow     *iw, GtkInspectorOverlay    *overlay
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_window_remove_overlay</NAME>
<RETURNS>void</RETURNS>
GtkInspectorWindow     *iw, GtkInspectorOverlay    *overlay
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_window_select_widget_under_pointer</NAME>
<RETURNS>void</RETURNS>
GtkInspectorWindow     *iw
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_window_get_inspected_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GtkInspectorWindow     *iw
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_is_recording</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget              *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_prepare_render</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GtkWidget              *widget, GskRenderer            *renderer, GdkSurface             *surface, const cairo_region_t   *region, GskRenderNode          *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_handle_event</NAME>
<RETURNS>gboolean</RETURNS>
GdkEvent               *event
</FUNCTION>
<STRUCT>
<NAME>_GtkMountOperationHandlerIface</NAME>
struct __GtkMountOperationHandlerIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_ask_password) (
    _GtkMountOperationHandler *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_id,
    const gchar *arg_message,
    const gchar *arg_icon_name,
    const gchar *arg_default_user,
    const gchar *arg_default_domain,
    guint arg_flags);

  gboolean (*handle_ask_question) (
    _GtkMountOperationHandler *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_id,
    const gchar *arg_message,
    const gchar *arg_icon_name,
    const gchar *const *arg_choices);

  gboolean (*handle_close) (
    _GtkMountOperationHandler *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_show_processes) (
    _GtkMountOperationHandler *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_id,
    const gchar *arg_message,
    const gchar *arg_icon_name,
    GVariant *arg_application_pids,
    const gchar *const *arg_choices);

};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerProxy</NAME>
struct __GtkMountOperationHandlerProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  _GtkMountOperationHandlerProxyPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerProxyClass</NAME>
struct __GtkMountOperationHandlerProxyClass
{
  GDBusProxyClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerSkeleton</NAME>
struct __GtkMountOperationHandlerSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  _GtkMountOperationHandlerSkeletonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerSkeletonClass</NAME>
struct __GtkMountOperationHandlerSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandler</NAME>
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerProxyPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerSkeletonPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CSS_AFFECTS</NAME>
#define GTK_TYPE_CSS_AFFECTS (_gtk_css_affects_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_HANDLE_ROLE</NAME>
#define GTK_TYPE_TEXT_HANDLE_ROLE (_gtk_text_handle_role_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_LICENSE</NAME>
#define GTK_TYPE_LICENSE (gtk_license_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_APPLICATION_INHIBIT_FLAGS</NAME>
#define GTK_TYPE_APPLICATION_INHIBIT_FLAGS (gtk_application_inhibit_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ASSISTANT_PAGE_TYPE</NAME>
#define GTK_TYPE_ASSISTANT_PAGE_TYPE (gtk_assistant_page_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_BUILDER_ERROR</NAME>
#define GTK_TYPE_BUILDER_ERROR (gtk_builder_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_BUILDER_CLOSURE_FLAGS</NAME>
#define GTK_TYPE_BUILDER_CLOSURE_FLAGS (gtk_builder_closure_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_STATE</NAME>
#define GTK_TYPE_CELL_RENDERER_STATE (gtk_cell_renderer_state_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_MODE</NAME>
#define GTK_TYPE_CELL_RENDERER_MODE (gtk_cell_renderer_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_ACCEL_MODE</NAME>
#define GTK_TYPE_CELL_RENDERER_ACCEL_MODE (gtk_cell_renderer_accel_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DEBUG_FLAG</NAME>
#define GTK_TYPE_DEBUG_FLAG (gtk_debug_flag_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DIALOG_FLAGS</NAME>
#define GTK_TYPE_DIALOG_FLAGS (gtk_dialog_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_RESPONSE_TYPE</NAME>
#define GTK_TYPE_RESPONSE_TYPE (gtk_response_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_EDITABLE_PROPERTIES</NAME>
#define GTK_TYPE_EDITABLE_PROPERTIES (gtk_editable_properties_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ENTRY_ICON_POSITION</NAME>
#define GTK_TYPE_ENTRY_ICON_POSITION (gtk_entry_icon_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ALIGN</NAME>
#define GTK_TYPE_ALIGN (gtk_align_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ARROW_TYPE</NAME>
#define GTK_TYPE_ARROW_TYPE (gtk_arrow_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_BASELINE_POSITION</NAME>
#define GTK_TYPE_BASELINE_POSITION (gtk_baseline_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DELETE_TYPE</NAME>
#define GTK_TYPE_DELETE_TYPE (gtk_delete_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DIRECTION_TYPE</NAME>
#define GTK_TYPE_DIRECTION_TYPE (gtk_direction_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_SIZE</NAME>
#define GTK_TYPE_ICON_SIZE (gtk_icon_size_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SENSITIVITY_TYPE</NAME>
#define GTK_TYPE_SENSITIVITY_TYPE (gtk_sensitivity_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_DIRECTION</NAME>
#define GTK_TYPE_TEXT_DIRECTION (gtk_text_direction_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_JUSTIFICATION</NAME>
#define GTK_TYPE_JUSTIFICATION (gtk_justification_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MENU_DIRECTION_TYPE</NAME>
#define GTK_TYPE_MENU_DIRECTION_TYPE (gtk_menu_direction_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MESSAGE_TYPE</NAME>
#define GTK_TYPE_MESSAGE_TYPE (gtk_message_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MOVEMENT_STEP</NAME>
#define GTK_TYPE_MOVEMENT_STEP (gtk_movement_step_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SCROLL_STEP</NAME>
#define GTK_TYPE_SCROLL_STEP (gtk_scroll_step_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ORIENTATION</NAME>
#define GTK_TYPE_ORIENTATION (gtk_orientation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_OVERFLOW</NAME>
#define GTK_TYPE_OVERFLOW (gtk_overflow_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PACK_TYPE</NAME>
#define GTK_TYPE_PACK_TYPE (gtk_pack_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_POSITION_TYPE</NAME>
#define GTK_TYPE_POSITION_TYPE (gtk_position_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SCROLL_TYPE</NAME>
#define GTK_TYPE_SCROLL_TYPE (gtk_scroll_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SELECTION_MODE</NAME>
#define GTK_TYPE_SELECTION_MODE (gtk_selection_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_WRAP_MODE</NAME>
#define GTK_TYPE_WRAP_MODE (gtk_wrap_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SORT_TYPE</NAME>
#define GTK_TYPE_SORT_TYPE (gtk_sort_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_PAGES</NAME>
#define GTK_TYPE_PRINT_PAGES (gtk_print_pages_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PAGE_SET</NAME>
#define GTK_TYPE_PAGE_SET (gtk_page_set_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_NUMBER_UP_LAYOUT</NAME>
#define GTK_TYPE_NUMBER_UP_LAYOUT (gtk_number_up_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PAGE_ORIENTATION</NAME>
#define GTK_TYPE_PAGE_ORIENTATION (gtk_page_orientation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_QUALITY</NAME>
#define GTK_TYPE_PRINT_QUALITY (gtk_print_quality_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_DUPLEX</NAME>
#define GTK_TYPE_PRINT_DUPLEX (gtk_print_duplex_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_UNIT</NAME>
#define GTK_TYPE_UNIT (gtk_unit_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_GRID_LINES</NAME>
#define GTK_TYPE_TREE_VIEW_GRID_LINES (gtk_tree_view_grid_lines_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SIZE_GROUP_MODE</NAME>
#define GTK_TYPE_SIZE_GROUP_MODE (gtk_size_group_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SIZE_REQUEST_MODE</NAME>
#define GTK_TYPE_SIZE_REQUEST_MODE (gtk_size_request_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SCROLLABLE_POLICY</NAME>
#define GTK_TYPE_SCROLLABLE_POLICY (gtk_scrollable_policy_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_STATE_FLAGS</NAME>
#define GTK_TYPE_STATE_FLAGS (gtk_state_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_BORDER_STYLE</NAME>
#define GTK_TYPE_BORDER_STYLE (gtk_border_style_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_LEVEL_BAR_MODE</NAME>
#define GTK_TYPE_LEVEL_BAR_MODE (gtk_level_bar_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_INPUT_PURPOSE</NAME>
#define GTK_TYPE_INPUT_PURPOSE (gtk_input_purpose_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_INPUT_HINTS</NAME>
#define GTK_TYPE_INPUT_HINTS (gtk_input_hints_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PROPAGATION_PHASE</NAME>
#define GTK_TYPE_PROPAGATION_PHASE (gtk_propagation_phase_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PROPAGATION_LIMIT</NAME>
#define GTK_TYPE_PROPAGATION_LIMIT (gtk_propagation_limit_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_EVENT_SEQUENCE_STATE</NAME>
#define GTK_TYPE_EVENT_SEQUENCE_STATE (gtk_event_sequence_state_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PAN_DIRECTION</NAME>
#define GTK_TYPE_PAN_DIRECTION (gtk_pan_direction_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_SCOPE</NAME>
#define GTK_TYPE_SHORTCUT_SCOPE (gtk_shortcut_scope_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_POPOVER_CONSTRAINT</NAME>
#define GTK_TYPE_POPOVER_CONSTRAINT (gtk_popover_constraint_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PLACES_OPEN_FLAGS</NAME>
#define GTK_TYPE_PLACES_OPEN_FLAGS (gtk_places_open_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PICK_FLAGS</NAME>
#define GTK_TYPE_PICK_FLAGS (gtk_pick_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_RELATION</NAME>
#define GTK_TYPE_CONSTRAINT_RELATION (gtk_constraint_relation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_STRENGTH</NAME>
#define GTK_TYPE_CONSTRAINT_STRENGTH (gtk_constraint_strength_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_ATTRIBUTE</NAME>
#define GTK_TYPE_CONSTRAINT_ATTRIBUTE (gtk_constraint_attribute_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CONSTRAINT_VFL_PARSER_ERROR</NAME>
#define GTK_TYPE_CONSTRAINT_VFL_PARSER_ERROR (gtk_constraint_vfl_parser_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SYSTEM_SETTING</NAME>
#define GTK_TYPE_SYSTEM_SETTING (gtk_system_setting_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_EVENT_CONTROLLER_SCROLL_FLAGS</NAME>
#define GTK_TYPE_EVENT_CONTROLLER_SCROLL_FLAGS (gtk_event_controller_scroll_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_ACTION</NAME>
#define GTK_TYPE_FILE_CHOOSER_ACTION (gtk_file_chooser_action_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_ERROR</NAME>
#define GTK_TYPE_FILE_CHOOSER_ERROR (gtk_file_chooser_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FILE_FILTER_FLAGS</NAME>
#define GTK_TYPE_FILE_FILTER_FLAGS (gtk_file_filter_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FONT_CHOOSER_LEVEL</NAME>
#define GTK_TYPE_FONT_CHOOSER_LEVEL (gtk_font_chooser_level_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_LOOKUP_FLAGS</NAME>
#define GTK_TYPE_ICON_LOOKUP_FLAGS (gtk_icon_lookup_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_THEME_ERROR</NAME>
#define GTK_TYPE_ICON_THEME_ERROR (gtk_icon_theme_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_VIEW_DROP_POSITION</NAME>
#define GTK_TYPE_ICON_VIEW_DROP_POSITION (gtk_icon_view_drop_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_IMAGE_TYPE</NAME>
#define GTK_TYPE_IMAGE_TYPE (gtk_image_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_BUTTONS_TYPE</NAME>
#define GTK_TYPE_BUTTONS_TYPE (gtk_buttons_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_NOTEBOOK_TAB</NAME>
#define GTK_TYPE_NOTEBOOK_TAB (gtk_notebook_tab_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PAD_ACTION_TYPE</NAME>
#define GTK_TYPE_PAD_ACTION_TYPE (gtk_pad_action_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_POPOVER_MENU_FLAGS</NAME>
#define GTK_TYPE_POPOVER_MENU_FLAGS (gtk_popover_menu_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_STATUS</NAME>
#define GTK_TYPE_PRINT_STATUS (gtk_print_status_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_OPERATION_RESULT</NAME>
#define GTK_TYPE_PRINT_OPERATION_RESULT (gtk_print_operation_result_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_OPERATION_ACTION</NAME>
#define GTK_TYPE_PRINT_OPERATION_ACTION (gtk_print_operation_action_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_ERROR</NAME>
#define GTK_TYPE_PRINT_ERROR (gtk_print_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_RECENT_MANAGER_ERROR</NAME>
#define GTK_TYPE_RECENT_MANAGER_ERROR (gtk_recent_manager_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_REVEALER_TRANSITION_TYPE</NAME>
#define GTK_TYPE_REVEALER_TRANSITION_TYPE (gtk_revealer_transition_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CORNER_TYPE</NAME>
#define GTK_TYPE_CORNER_TYPE (gtk_corner_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_POLICY_TYPE</NAME>
#define GTK_TYPE_POLICY_TYPE (gtk_policy_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_ACTION_FLAGS</NAME>
#define GTK_TYPE_SHORTCUT_ACTION_FLAGS (gtk_shortcut_action_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SHORTCUT_TYPE</NAME>
#define GTK_TYPE_SHORTCUT_TYPE (gtk_shortcut_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY</NAME>
#define GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY (gtk_spin_button_update_policy_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SPIN_TYPE</NAME>
#define GTK_TYPE_SPIN_TYPE (gtk_spin_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_STACK_TRANSITION_TYPE</NAME>
#define GTK_TYPE_STACK_TRANSITION_TYPE (gtk_stack_transition_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_STYLE_CONTEXT_PRINT_FLAGS</NAME>
#define GTK_TYPE_STYLE_CONTEXT_PRINT_FLAGS (gtk_style_context_print_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_BUFFER_TARGET_INFO</NAME>
#define GTK_TYPE_TEXT_BUFFER_TARGET_INFO (gtk_text_buffer_target_info_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_SEARCH_FLAGS</NAME>
#define GTK_TYPE_TEXT_SEARCH_FLAGS (gtk_text_search_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_WINDOW_TYPE</NAME>
#define GTK_TYPE_TEXT_WINDOW_TYPE (gtk_text_window_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_VIEW_LAYER</NAME>
#define GTK_TYPE_TEXT_VIEW_LAYER (gtk_text_view_layer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_EXTEND_SELECTION</NAME>
#define GTK_TYPE_TEXT_EXTEND_SELECTION (gtk_text_extend_selection_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_MODEL_FLAGS</NAME>
#define GTK_TYPE_TREE_MODEL_FLAGS (gtk_tree_model_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_DROP_POSITION</NAME>
#define GTK_TYPE_TREE_VIEW_DROP_POSITION (gtk_tree_view_drop_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_COLUMN_SIZING</NAME>
#define GTK_TYPE_TREE_VIEW_COLUMN_SIZING (gtk_tree_view_column_sizing_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MAJOR_VERSION</NAME>
#define GTK_MAJOR_VERSION (3)
</MACRO>
<MACRO>
<NAME>GTK_MINOR_VERSION</NAME>
#define GTK_MINOR_VERSION (98)
</MACRO>
<MACRO>
<NAME>GTK_MICRO_VERSION</NAME>
#define GTK_MICRO_VERSION (4)
</MACRO>
<MACRO>
<NAME>GTK_BINARY_AGE</NAME>
#define GTK_BINARY_AGE    (9804)
</MACRO>
<MACRO>
<NAME>GTK_INTERFACE_AGE</NAME>
#define GTK_INTERFACE_AGE (0)
</MACRO>
<MACRO>
<NAME>GTK_CHECK_VERSION</NAME>
#define GTK_CHECK_VERSION(major,minor,micro)                          \
    (GTK_MAJOR_VERSION > (major) ||                                   \
     (GTK_MAJOR_VERSION == (major) && GTK_MINOR_VERSION > (minor)) || \
     (GTK_MAJOR_VERSION == (major) && GTK_MINOR_VERSION == (minor) && \
      GTK_MICRO_VERSION >= (micro)))
</MACRO>
<VARIABLE>
<NAME>zwp_text_input_v3_interface</NAME>
extern const struct wl_interface zwp_text_input_v3_interface;
</VARIABLE>
<VARIABLE>
<NAME>zwp_text_input_manager_v3_interface</NAME>
extern const struct wl_interface zwp_text_input_manager_v3_interface;
</VARIABLE>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_ENUM</NAME>
#define ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_text_input_v3_change_cause</NAME>
enum zwp_text_input_v3_change_cause {
	/**
	 * input method caused the change
	 */
	ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_INPUT_METHOD = 0,
	/**
	 * something else than the input method caused the change
	 */
	ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_OTHER = 1,
};
</ENUM>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_CONTENT_HINT_ENUM</NAME>
#define ZWP_TEXT_INPUT_V3_CONTENT_HINT_ENUM
</MACRO>
<ENUM>
<NAME>zwp_text_input_v3_content_hint</NAME>
enum zwp_text_input_v3_content_hint {
	/**
	 * no special behavior
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE = 0x0,
	/**
	 * suggest word completions
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_COMPLETION = 0x1,
	/**
	 * suggest word corrections
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_SPELLCHECK = 0x2,
	/**
	 * switch to uppercase letters at the start of a sentence
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_AUTO_CAPITALIZATION = 0x4,
	/**
	 * prefer lowercase letters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_LOWERCASE = 0x8,
	/**
	 * prefer uppercase letters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_UPPERCASE = 0x10,
	/**
	 * prefer casing for titles and headings (can be language dependent)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_TITLECASE = 0x20,
	/**
	 * characters should be hidden
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_HIDDEN_TEXT = 0x40,
	/**
	 * typed text should not be stored
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA = 0x80,
	/**
	 * just Latin characters should be entered
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_LATIN = 0x100,
	/**
	 * the text input is multiline
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_MULTILINE = 0x200,
};
</ENUM>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ENUM</NAME>
#define ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_text_input_v3_content_purpose</NAME>
enum zwp_text_input_v3_content_purpose {
	/**
	 * default input, allowing all characters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL = 0,
	/**
	 * allow only alphabetic characters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ALPHA = 1,
	/**
	 * allow only digits
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DIGITS = 2,
	/**
	 * input a number (including decimal separator and sign)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NUMBER = 3,
	/**
	 * input a phone number
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PHONE = 4,
	/**
	 * input an URL
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_URL = 5,
	/**
	 * input an email address
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_EMAIL = 6,
	/**
	 * input a name of a person
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NAME = 7,
	/**
	 * input a password (combine with sensitive_data hint)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PASSWORD = 8,
	/**
	 * input is a numeric password (combine with sensitive_data hint)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PIN = 9,
	/**
	 * input a date
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATE = 10,
	/**
	 * input a time
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TIME = 11,
	/**
	 * input a date and time
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATETIME = 12,
	/**
	 * input for a terminal
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TERMINAL = 13,
};
</ENUM>
<STRUCT>
<NAME>zwp_text_input_v3_listener</NAME>
struct zwp_text_input_v3_listener {
	/**
	 * enter event
	 *
	 * Notification that this seat's text-input focus is on a certain
	 * surface.
	 *
	 * When the seat has the keyboard capability the text-input focus
	 * follows the keyboard focus. This event sets the current surface
	 * for the text-input object.
	 */
	void (*enter)(void *data,
		      struct zwp_text_input_v3 *zwp_text_input_v3,
		      struct wl_surface *surface);
	/**
	 * leave event
	 *
	 * Notification that this seat's text-input focus is no longer on
	 * a certain surface. The client should reset any preedit string
	 * previously set.
	 *
	 * The leave notification clears the current surface. It is sent
	 * before the enter notification for the new focus.
	 *
	 * When the seat has the keyboard capability the text-input focus
	 * follows the keyboard focus.
	 */
	void (*leave)(void *data,
		      struct zwp_text_input_v3 *zwp_text_input_v3,
		      struct wl_surface *surface);
	/**
	 * pre-edit
	 *
	 * Notify when a new composing text (pre-edit) should be set at
	 * the current cursor position. Any previously set composing text
	 * must be removed. Any previously existing selected text must be
	 * removed.
	 *
	 * The argument text contains the pre-edit string buffer.
	 *
	 * The parameters cursor_begin and cursor_end are counted in bytes
	 * relative to the beginning of the submitted text buffer. Cursor
	 * should be hidden when both are equal to -1.
	 *
	 * They could be represented by the client as a line if both values
	 * are the same, or as a text highlight otherwise.
	 *
	 * Values set with this event are double-buffered. They must be
	 * applied and reset to initial on the next zwp_text_input_v3.done
	 * event.
	 *
	 * The initial value of text is an empty string, and cursor_begin,
	 * cursor_end and cursor_hidden are all 0.
	 */
	void (*preedit_string)(void *data,
			       struct zwp_text_input_v3 *zwp_text_input_v3,
			       const char *text,
			       int32_t cursor_begin,
			       int32_t cursor_end);
	/**
	 * text commit
	 *
	 * Notify when text should be inserted into the editor widget.
	 * The text to commit could be either just a single character after
	 * a key press or the result of some composing (pre-edit).
	 *
	 * Values set with this event are double-buffered. They must be
	 * applied and reset to initial on the next zwp_text_input_v3.done
	 * event.
	 *
	 * The initial value of text is an empty string.
	 */
	void (*commit_string)(void *data,
			      struct zwp_text_input_v3 *zwp_text_input_v3,
			      const char *text);
	/**
	 * delete surrounding text
	 *
	 * Notify when the text around the current cursor position should
	 * be deleted.
	 *
	 * Before_length and after_length are the number of bytes before
	 * and after the current cursor index (excluding the selection) to
	 * delete.
	 *
	 * If a preedit text is present, in effect before_length is counted
	 * from the beginning of it, and after_length from its end (see
	 * done event sequence).
	 *
	 * Values set with this event are double-buffered. They must be
	 * applied and reset to initial on the next zwp_text_input_v3.done
	 * event.
	 *
	 * The initial values of both before_length and after_length are 0.
	 * @param before_length length of text before current cursor position
	 * @param after_length length of text after current cursor position
	 */
	void (*delete_surrounding_text)(void *data,
					struct zwp_text_input_v3 *zwp_text_input_v3,
					uint32_t before_length,
					uint32_t after_length);
	/**
	 * apply changes
	 *
	 * Instruct the application to apply changes to state requested
	 * by the preedit_string, commit_string and delete_surrounding_text
	 * events. The state relating to these events is double-buffered,
	 * and each one modifies the pending state. This event replaces the
	 * current state with the pending state.
	 *
	 * The application must proceed by evaluating the changes in the
	 * following order:
	 *
	 * 1. Replace existing preedit string with the cursor. 2. Delete
	 * requested surrounding text. 3. Insert commit string with the
	 * cursor at its end. 4. Calculate surrounding text to send. 5.
	 * Insert new preedit text in cursor position. 6. Place cursor
	 * inside preedit text.
	 *
	 * The serial number reflects the last state of the
	 * zwp_text_input_v3 object known to the compositor. The value of
	 * the serial argument must be equal to the number of commit
	 * requests already issued on that object. When the client receives
	 * a done event with a serial different than the number of past
	 * commit requests, it must proceed as normal, except it should not
	 * change the current state of the zwp_text_input_v3 object.
	 */
	void (*done)(void *data,
		     struct zwp_text_input_v3 *zwp_text_input_v3,
		     uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_text_input_v3_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, const struct zwp_text_input_v3_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DESTROY</NAME>
#define ZWP_TEXT_INPUT_V3_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_ENABLE</NAME>
#define ZWP_TEXT_INPUT_V3_ENABLE 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DISABLE</NAME>
#define ZWP_TEXT_INPUT_V3_DISABLE 2
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT</NAME>
#define ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT 3
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE</NAME>
#define ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE 4
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE 5
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE 6
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_COMMIT</NAME>
#define ZWP_TEXT_INPUT_V3_COMMIT 7
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_ENTER_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_ENTER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_LEAVE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_LEAVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_PREEDIT_STRING_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_PREEDIT_STRING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_COMMIT_STRING_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_COMMIT_STRING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DELETE_SURROUNDING_TEXT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DELETE_SURROUNDING_TEXT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DONE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_ENABLE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_ENABLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DISABLE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DISABLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_COMMIT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_COMMIT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_text_input_v3_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_enable</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_disable</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_surrounding_text</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, const char *text, int32_t cursor, int32_t anchor
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_text_change_cause</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, uint32_t cause
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_content_type</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, uint32_t hint, uint32_t purpose
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_cursor_rectangle</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_commit</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_DESTROY</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_get_user_data</NAME>
<RETURNS>void *</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_get_text_input</NAME>
<RETURNS>struct zwp_text_input_v3 *</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3, struct wl_seat *seat
</FUNCTION>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_text_input_manager_v3</NAME>
struct zwp_text_input_manager_v3;
</STRUCT>
<STRUCT>
<NAME>zwp_text_input_v3</NAME>
struct zwp_text_input_v3;
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CSS_PARSER_ERROR</NAME>
#define GTK_TYPE_CSS_PARSER_ERROR (gtk_css_parser_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CSS_PARSER_WARNING</NAME>
#define GTK_TYPE_CSS_PARSER_WARNING (gtk_css_parser_warning_get_type ())
</MACRO>
