<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 char      *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_program_name</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_program_name</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_version</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_version</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *version
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_copyright</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_copyright</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *copyright
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_comments</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_comments</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *comments
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_license</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_license</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *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 char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_system_information</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *system_information
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_website</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_website</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *website
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_website_label</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_website_label</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *website_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_authors</NAME>
<RETURNS>const char * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_authors</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char     **authors
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_documenters</NAME>
<RETURNS>const char * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_documenters</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char     **documenters
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_artists</NAME>
<RETURNS>const char * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_artists</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char     **artists
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_translator_credits</NAME>
<RETURNS>const char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_translator_credits</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *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 char *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_logo_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_add_credit_section</NAME>
<RETURNS>void</RETURNS>
GtkAboutDialog  *about, const char      *section_name, const char     **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 char      *accelerator, guint	       *accelerator_key, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_parse_with_keycode</NAME>
<RETURNS>gboolean</RETURNS>
const char      *accelerator, GdkDisplay      *display, guint           *accelerator_key, guint          **accelerator_codes, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_name</NAME>
<RETURNS>char *</RETURNS>
guint	        accelerator_key, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_name_with_keycode</NAME>
<RETURNS>char *</RETURNS>
GdkDisplay      *display, guint            accelerator_key, guint            keycode, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_label</NAME>
<RETURNS>char *</RETURNS>
guint           accelerator_key, GdkModifierType accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_label_with_keycode</NAME>
<RETURNS>char *</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_ACCESSIBLE</NAME>
#define GTK_TYPE_ACCESSIBLE (gtk_accessible_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_accessible_get_accessible_role</NAME>
<RETURNS>GtkAccessibleRole</RETURNS>
GtkAccessible         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_update_state</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, GtkAccessibleState     first_state, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_update_property</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, GtkAccessibleProperty  first_property, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_update_relation</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, GtkAccessibleRelation  first_relation, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_update_state_value</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, int                    n_states, GtkAccessibleState     states[], const GValue           values[]
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_update_property_value</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, int                    n_properties, GtkAccessibleProperty  properties[], const GValue           values[]
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_update_relation_value</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, int                    n_relations, GtkAccessibleRelation  relations[], const GValue           values[]
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_reset_state</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, GtkAccessibleState     state
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_reset_property</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, GtkAccessibleProperty  property
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_reset_relation</NAME>
<RETURNS>void</RETURNS>
GtkAccessible         *self, GtkAccessibleRelation  relation
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_state_init_value</NAME>
<RETURNS>void</RETURNS>
GtkAccessibleState     state, GValue                *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_property_init_value</NAME>
<RETURNS>void</RETURNS>
GtkAccessibleProperty  property, GValue                *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_accessible_relation_init_value</NAME>
<RETURNS>void</RETURNS>
GtkAccessibleRelation  relation, GValue                *value
</FUNCTION>
<STRUCT>
<NAME>GtkAccessible</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkAccessibleInterface</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 char * (* get_action_name)             (GtkActionable *actionable);
  void          (* set_action_name)             (GtkActionable *actionable,
                                                 const char    *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 char *</RETURNS>
GtkActionable *actionable
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_action_name</NAME>
<RETURNS>void</RETURNS>
GtkActionable *actionable, const char    *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 char    *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_detailed_action_name</NAME>
<RETURNS>void</RETURNS>
GtkActionable *actionable, const char    *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_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>
double           value, double           lower, double           upper, double           step_increment, double           page_increment, double           page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_clamp_page</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           lower, double           upper
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_value</NAME>
<RETURNS>double</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_value</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           value
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_lower</NAME>
<RETURNS>double</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_lower</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           lower
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_upper</NAME>
<RETURNS>double</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_upper</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           upper
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_step_increment</NAME>
<RETURNS>double</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_step_increment</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           step_increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_page_increment</NAME>
<RETURNS>double</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_page_increment</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           page_increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_page_size</NAME>
<RETURNS>double</RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_page_size</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_configure</NAME>
<RETURNS>void</RETURNS>
GtkAdjustment   *adjustment, double           value, double           lower, double           upper, double           step_increment, double           page_increment, double           page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_minimum_increment</NAME>
<RETURNS>double</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>char *</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 char          *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 char          *name, const char          *label, GIcon               *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_active_custom_item</NAME>
<RETURNS>void</RETURNS>
GtkAppChooserButton *self, const char          *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 char          *heading
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_heading</NAME>
<RETURNS>const char *</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 char          *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 char          *heading
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_get_heading</NAME>
<RETURNS>const char *</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 char          *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 char          *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_default_text</NAME>
<RETURNS>const char *</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 char        *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_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 char                 *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>char **</RETURNS>
GtkApplication       *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_accels_for_action</NAME>
<RETURNS>char **</RETURNS>
GtkApplication       *application, const char           *detailed_action_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_actions_for_accel</NAME>
<RETURNS>char **</RETURNS>
GtkApplication       *application, const char           *accel
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_set_accels_for_action</NAME>
<RETURNS>void</RETURNS>
GtkApplication       *application, const char           *detailed_action_name, const char * const  *accels
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_menu_by_id</NAME>
<RETURNS>GMenu *</RETURNS>
GtkApplication       *application, const char           *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>
<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>int</RETURNS>
int 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>int</RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_current_page</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, int                   page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_n_pages</NAME>
<RETURNS>int</RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_nth_page</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAssistant         *assistant, int                   page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_prepend_page</NAME>
<RETURNS>int</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_append_page</NAME>
<RETURNS>int</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_insert_page</NAME>
<RETURNS>int</RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, int                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_remove_page</NAME>
<RETURNS>void</RETURNS>
GtkAssistant         *assistant, int                   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 char           *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page_title</NAME>
<RETURNS>const char *</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_AT_CONTEXT</NAME>
#define GTK_TYPE_AT_CONTEXT (gtk_at_context_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_at_context_get_accessible</NAME>
<RETURNS>GtkAccessible *</RETURNS>
GtkATContext      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_at_context_get_accessible_role</NAME>
<RETURNS>GtkAccessibleRole</RETURNS>
GtkATContext      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_at_context_create</NAME>
<RETURNS>GtkATContext *</RETURNS>
GtkAccessibleRole  accessible_role, GtkAccessible     *accessible, GdkDisplay        *display
</FUNCTION>
<STRUCT>
<NAME>GtkATContext</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>
<MACRO>
<NAME>GTK_TYPE_BITSET</NAME>
#define GTK_TYPE_BITSET (gtk_bitset_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_bitset_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_ref</NAME>
<RETURNS>GtkBitset *</RETURNS>
GtkBitset              *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_unref</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_contains</NAME>
<RETURNS>gboolean</RETURNS>
const GtkBitset        *self, guint                   value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_is_empty</NAME>
<RETURNS>gboolean</RETURNS>
const GtkBitset        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_equals</NAME>
<RETURNS>gboolean</RETURNS>
const GtkBitset        *self, const GtkBitset        *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_get_size</NAME>
<RETURNS>guint64</RETURNS>
const GtkBitset        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_get_size_in_range</NAME>
<RETURNS>guint64</RETURNS>
const GtkBitset        *self, guint                   first, guint                   last
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_get_nth</NAME>
<RETURNS>guint</RETURNS>
const GtkBitset        *self, guint                   nth
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_get_minimum</NAME>
<RETURNS>guint</RETURNS>
const GtkBitset        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_get_maximum</NAME>
<RETURNS>guint</RETURNS>
const GtkBitset        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_new_empty</NAME>
<RETURNS>GtkBitset *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_copy</NAME>
<RETURNS>GtkBitset *</RETURNS>
const GtkBitset        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_new_range</NAME>
<RETURNS>GtkBitset *</RETURNS>
guint                   start, guint                   n_items
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_remove_all</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_add</NAME>
<RETURNS>gboolean</RETURNS>
GtkBitset              *self, guint                   value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_remove</NAME>
<RETURNS>gboolean</RETURNS>
GtkBitset              *self, guint                   value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_add_range</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   start, guint                   n_items
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_remove_range</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   start, guint                   n_items
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_add_range_closed</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   first, guint                   last
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_remove_range_closed</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   first, guint                   last
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_add_rectangle</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   start, guint                   width, guint                   height, guint                   stride
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_remove_rectangle</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   start, guint                   width, guint                   height, guint                   stride
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_union</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, const GtkBitset        *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_intersect</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, const GtkBitset        *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_subtract</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, const GtkBitset        *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_difference</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, const GtkBitset        *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_shift_left</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   amount
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_shift_right</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   amount
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_splice</NAME>
<RETURNS>void</RETURNS>
GtkBitset              *self, guint                   position, guint                   removed, guint                   added
</FUNCTION>
<STRUCT>
<NAME>GtkBitsetIter</NAME>
struct _GtkBitsetIter
{
  /*< private >*/
  gpointer private_data[10];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_bitset_iter_init_first</NAME>
<RETURNS>gboolean</RETURNS>
GtkBitsetIter          *iter, const GtkBitset        *set, guint                  *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_iter_init_last</NAME>
<RETURNS>gboolean</RETURNS>
GtkBitsetIter          *iter, const GtkBitset        *set, guint                  *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_iter_init_at</NAME>
<RETURNS>gboolean</RETURNS>
GtkBitsetIter          *iter, const GtkBitset        *set, guint                   target, guint                  *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_iter_next</NAME>
<RETURNS>gboolean</RETURNS>
GtkBitsetIter          *iter, guint                  *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_iter_previous</NAME>
<RETURNS>gboolean</RETURNS>
GtkBitsetIter          *iter, guint                  *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_iter_get_value</NAME>
<RETURNS>guint</RETURNS>
const GtkBitsetIter    *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_bitset_iter_is_valid</NAME>
<RETURNS>gboolean</RETURNS>
const GtkBitsetIter    *iter
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BOOKMARK_LIST</NAME>
#define GTK_TYPE_BOOKMARK_LIST (gtk_bookmark_list_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_bookmark_list_new</NAME>
<RETURNS>GtkBookmarkList *</RETURNS>
const char *filename, const char *attributes
</FUNCTION>
<FUNCTION>
<NAME>gtk_bookmark_list_get_filename</NAME>
<RETURNS>const char *</RETURNS>
GtkBookmarkList *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bookmark_list_set_attributes</NAME>
<RETURNS>void</RETURNS>
GtkBookmarkList *self, const char      *attributes
</FUNCTION>
<FUNCTION>
<NAME>gtk_bookmark_list_get_attributes</NAME>
<RETURNS>const char *</RETURNS>
GtkBookmarkList *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bookmark_list_set_io_priority</NAME>
<RETURNS>void</RETURNS>
GtkBookmarkList *self, int              io_priority
</FUNCTION>
<FUNCTION>
<NAME>gtk_bookmark_list_get_io_priority</NAME>
<RETURNS>int</RETURNS>
GtkBookmarkList *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bookmark_list_is_loading</NAME>
<RETURNS>gboolean</RETURNS>
GtkBookmarkList *self
</FUNCTION>
<STRUCT>
<NAME>GtkBookmarkList</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkBookmarksChangedFunc</NAME>
<RETURNS>void</RETURNS>
gpointer data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BOOL_FILTER</NAME>
#define GTK_TYPE_BOOL_FILTER             (gtk_bool_filter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_bool_filter_new</NAME>
<RETURNS>GtkBoolFilter *</RETURNS>
GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_bool_filter_get_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkBoolFilter          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bool_filter_set_expression</NAME>
<RETURNS>void</RETURNS>
GtkBoolFilter          *self, GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_bool_filter_get_invert</NAME>
<RETURNS>gboolean</RETURNS>
GtkBoolFilter          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_bool_filter_set_invert</NAME>
<RETURNS>void</RETURNS>
GtkBoolFilter          *self, gboolean                invert
</FUNCTION>
<STRUCT>
<NAME>GtkBoolFilter</NAME>
</STRUCT>
<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, int             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, int             spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_get_spacing</NAME>
<RETURNS>int</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 char               *element_name,
                          const char              **attribute_names,
                          const char              **attribute_values,
                          gpointer                  user_data,
                          GError                  **error);

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

  /* Called for character data */
  /* text is not nul-terminated */
  void (*text)           (GtkBuildableParseContext *context,
                          const char               *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);

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

  /* virtual table */
  void          (* set_id)                 (GtkBuildable       *buildable,
                                            const char         *id);
  const char *  (* get_id)                 (GtkBuildable       *buildable);

  /**
   * GtkBuildableIface::add_child:
   * @buildable: a #GtkBuildable
   * @builder: a #GtkBuilder
   * @child: child to add
   * @type: (nullable): kind of child or %NULL
   *
   * Adds a child to @buildable. @type is an optional string
   * describing how the child should be added.
   */
  void          (* add_child)              (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const char         *type);
  void          (* set_buildable_property) (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            const char         *name,
                                            const GValue       *value);
  GObject *     (* construct_child)        (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            const char         *name);

  /**
   * GtkBuildableIface::custom_tag_start:
   * @buildable: a #GtkBuildable
   * @builder: a #GtkBuilder used to construct this object
   * @child: (nullable): child object or %NULL for non-child tags
   * @tagname: name of tag
   * @parser: (out): a #GtkBuildableParser to fill in
   * @data: (out): return location for user data that will be passed in
   *   to parser functions
   *
   * Called for each unknown element under `<child>`.
   *
   * Returns: %TRUE if an object has a custom implementation, %FALSE
   *   if it doesn't.
   */
  gboolean      (* custom_tag_start)       (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const char         *tagname,
                                            GtkBuildableParser *parser,
                                            gpointer           *data);
  /**
   * GtkBuildableIface::custom_tag_end:
   * @buildable: A #GtkBuildable
   * @builder: #GtkBuilder used to construct this object
   * @child: (nullable): child object or %NULL for non-child tags
   * @tagname: name of tag
   * @data: user data that will be passed in to parser functions
   *
   * Called at the end of each custom element handled by
   * the buildable.
   */
  void          (* custom_tag_end)         (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const char         *tagname,
                                            gpointer            data);
   /**
    * GtkBuildableIface::custom_finished:
    * @buildable: a #GtkBuildable
    * @builder: a #GtkBuilder
    * @child: (nullable): child object or %NULL for non-child tags
    * @tagname: the name of the tag
    * @data: user data created in custom_tag_start
    *
    * Similar to gtk_buildable_parser_finished() but is
    * called once for each custom tag handled by the @buildable.
    */
  void          (* custom_finished)        (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            GObject            *child,
                                            const char         *tagname,
                                            gpointer            data);
  void          (* parser_finished)        (GtkBuildable       *buildable,
                                            GtkBuilder         *builder);

  /**
   * GtkBuildableIface::get_internal_child:
   * @buildable: a #GtkBuildable
   * @builder: a #GtkBuilder
   * @childname: name of child
   *
   * Retrieves the internal child called @childname of the @buildable object.
   *
   * Returns: (transfer none): the internal child of the buildable object
   */
  GObject *     (* get_internal_child)     (GtkBuildable       *buildable,
                                            GtkBuilder         *builder,
                                            const char         *childname);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_buildable_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_get_buildable_id</NAME>
<RETURNS>const char *</RETURNS>
GtkBuildable        *buildable
</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, int                      *line_number, int                      *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 char    *filename, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_resource</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const char    *resource_path, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_string</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const char    *buffer, gssize         length, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const char    *filename, const char   **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_resource</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const char    *resource_path, const char   **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_string</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, const char    *buffer, gssize         length, const char   **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_object</NAME>
<RETURNS>GObject *</RETURNS>
GtkBuilder    *builder, const char    *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 char    *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 char   	*domain
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_translation_domain</NAME>
<RETURNS>const char *</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 char   	*string, GValue       	*value, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_value_from_string_type</NAME>
<RETURNS>gboolean</RETURNS>
GtkBuilder    *builder, GType        	 type, const char   	*string, GValue       	*value, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_file</NAME>
<RETURNS>GtkBuilder *</RETURNS>
const char    *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_resource</NAME>
<RETURNS>GtkBuilder *</RETURNS>
const char    *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_string</NAME>
<RETURNS>GtkBuilder *</RETURNS>
const char    *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, GObject       *object, GType          template_type, const char    *buffer, gssize         length, GError       **error
</FUNCTION>
<STRUCT>
<NAME>GtkBuilderClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BUILDER_LIST_ITEM_FACTORY</NAME>
#define GTK_TYPE_BUILDER_LIST_ITEM_FACTORY         (gtk_builder_list_item_factory_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BUILDER_LIST_ITEM_FACTORY</NAME>
#define GTK_BUILDER_LIST_ITEM_FACTORY(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_BUILDER_LIST_ITEM_FACTORY, GtkBuilderListItemFactory))
</MACRO>
<MACRO>
<NAME>GTK_BUILDER_LIST_ITEM_FACTORY_CLASS</NAME>
#define GTK_BUILDER_LIST_ITEM_FACTORY_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_BUILDER_LIST_ITEM_FACTORY, GtkBuilderListItemFactoryClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUILDER_LIST_ITEM_FACTORY</NAME>
#define GTK_IS_BUILDER_LIST_ITEM_FACTORY(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_BUILDER_LIST_ITEM_FACTORY))
</MACRO>
<MACRO>
<NAME>GTK_IS_BUILDER_LIST_ITEM_FACTORY_CLASS</NAME>
#define GTK_IS_BUILDER_LIST_ITEM_FACTORY_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_BUILDER_LIST_ITEM_FACTORY))
</MACRO>
<MACRO>
<NAME>GTK_BUILDER_LIST_ITEM_FACTORY_GET_CLASS</NAME>
#define GTK_BUILDER_LIST_ITEM_FACTORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_BUILDER_LIST_ITEM_FACTORY, GtkBuilderListItemFactoryClass))
</MACRO>
<FUNCTION>
<NAME>gtk_builder_list_item_factory_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_list_item_factory_new_from_bytes</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
GtkBuilderScope                *scope, GBytes                         *bytes
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_list_item_factory_new_from_resource</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
GtkBuilderScope                *scope, const char                     *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_list_item_factory_get_bytes</NAME>
<RETURNS>GBytes *</RETURNS>
GtkBuilderListItemFactory      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_list_item_factory_get_resource</NAME>
<RETURNS>const char *</RETURNS>
GtkBuilderListItemFactory      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_list_item_factory_get_scope</NAME>
<RETURNS>GtkBuilderScope *</RETURNS>
GtkBuilderListItemFactory      *self
</FUNCTION>
<STRUCT>
<NAME>GtkBuilderListItemFactory</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilderListItemFactoryClass</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 { /*< prefix=GTK_BUILDER_CLOSURE >*/
  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 char             *callback_name, GCallback               callback_symbol
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_cscope_add_callback_symbols</NAME>
<RETURNS>void</RETURNS>
GtkBuilderCScope       *self, const char             *first_callback_name, GCallback               first_callback_symbol, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_cscope_lookup_callback_symbol</NAME>
<RETURNS>GCallback</RETURNS>
GtkBuilderCScope      *self, const char            *callback_name
</FUNCTION>
<STRUCT>
<NAME>GtkBuilderCScope</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilderCScopeClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilderScope</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 char     *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_from_icon_name</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char     *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 char     *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_label</NAME>
<RETURNS>const char *</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);
  int                (* 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,
                                                          int                     *minimum_width,
                                                          int                     *natural_width);
  void               (* get_preferred_height_for_width)  (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          int                      width,
                                                          int                     *minimum_height,
                                                          int                     *natural_height);
  void               (* get_preferred_height)            (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          int                     *minimum_height,
                                                          int                     *natural_height);
  void               (* get_preferred_width_for_height)  (GtkCellArea             *area,
                                                          GtkCellAreaContext      *context,
                                                          GtkWidget               *widget,
                                                          int                      height,
                                                          int                     *minimum_width,
                                                          int                     *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>int</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, int                   x, int                   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, int                *minimum_width, int                *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_height_for_width</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, int                 width, int                *minimum_height, int                *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, int                *minimum_height, int                *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_width_for_height</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, int                 height, int                *minimum_width, int                *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_current_path_string</NAME>
<RETURNS>const char *</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 char         *attribute, int                 column
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_disconnect</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const char         *attribute
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_get_column</NAME>
<RETURNS>int</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const char         *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 char         *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 char      *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const char         *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const char         *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set_valist</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const char         *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 char         *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 char         *property_name, const GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get_property</NAME>
<RETURNS>void</RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const char         *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, int                 for_size, int                *minimum_size, int                *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>int</RETURNS>
GtkCellAreaBox  *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_set_spacing</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaBox  *box, int              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,
                                              int                 width,
                                              int                 height);
  void    (* reset)                          (GtkCellAreaContext *context);
  void    (* get_preferred_height_for_width) (GtkCellAreaContext *context,
                                              int                 width,
                                              int                *minimum_height,
                                              int                *natural_height);
  void    (* get_preferred_width_for_height) (GtkCellAreaContext *context,
                                              int                 height,
                                              int                *minimum_width,
                                              int                *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, int                 width, int                 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, int                *minimum_width, int                *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, int                *minimum_height, int                *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_preferred_height_for_width</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, int                 width, int                *minimum_height, int                *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_preferred_width_for_height</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, int                 height, int                *minimum_width, int                *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_get_allocation</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, int                *width, int                *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_push_preferred_width</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, int                 minimum_width, int                 natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_context_push_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellAreaContext *context, int                 minimum_height, int                 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 char            *attribute,
                               int                    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,
                               int                    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 char            *attribute, int                    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, int                    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,
                                                          int                  *minimum_size,
                                                          int                  *natural_size);
  void               (* get_preferred_height_for_width)  (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          int                   width,
                                                          int                  *minimum_height,
                                                          int                  *natural_height);
  void               (* get_preferred_height)            (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          int                  *minimum_size,
                                                          int                  *natural_size);
  void               (* get_preferred_width_for_height)  (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
                                                          int                   height,
                                                          int                  *minimum_width,
                                                          int                  *natural_width);
  void               (* get_aligned_area)                (GtkCellRenderer      *cell,
                                                          GtkWidget            *widget,
							  GtkCellRendererState  flags,
                                                          const GdkRectangle   *cell_area,
                                                          GdkRectangle         *aligned_area);
  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 char           *path,
                                                          const GdkRectangle   *background_area,
                                                          const GdkRectangle   *cell_area,
                                                          GtkCellRendererState  flags);
  GtkCellEditable *  (* start_editing)                   (GtkCellRenderer      *cell,
                                                          GdkEvent             *event,
                                                          GtkWidget            *widget,
                                                          const char           *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 char      *path);

  /*< private >*/
  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, int                *minimum_size, int                *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_height_for_width</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, int                 width, int                *minimum_height, int                *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_height</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, int                *minimum_size, int                *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_width_for_height</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, int                 height, int                *minimum_width, int                *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 char           *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 char           *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, int                   width, int                   height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_fixed_size</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, int                  *width, int                  *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_alignment</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, float                 xalign, float                 yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_alignment</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, float                *xalign, float                *yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_padding</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, int                   xpad, int                   ypad
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_padding</NAME>
<RETURNS>void</RETURNS>
GtkCellRenderer      *cell, int                  *xpad, int                  *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_expanded
</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>
<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 char          *path,
		   const char          *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, int                  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 char      *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_markup</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char      *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
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkCheckButtonClass</NAME>
struct _GtkCheckButtonClass
{
  GtkWidgetClass parent_class;

  void (* toggled) (GtkCheckButton *check_button);
  void (* activate) (GtkCheckButton *check_button);

  /*< private >*/
  gpointer padding[7];
};
</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 char *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char *label
</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>
<FUNCTION>
<NAME>gtk_check_button_get_active</NAME>
<RETURNS>gboolean</RETURNS>
GtkCheckButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_active</NAME>
<RETURNS>void</RETURNS>
GtkCheckButton *self, gboolean        setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_get_label</NAME>
<RETURNS>const char *</RETURNS>
GtkCheckButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_label</NAME>
<RETURNS>void</RETURNS>
GtkCheckButton *self, const char     *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_group</NAME>
<RETURNS>void</RETURNS>
GtkCheckButton *self, GtkCheckButton *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_get_use_underline</NAME>
<RETURNS>gboolean</RETURNS>
GtkCheckButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_use_underline</NAME>
<RETURNS>void</RETURNS>
GtkCheckButton *self, gboolean        setting
</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 char     *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_get_title</NAME>
<RETURNS>const char *</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,
                        int              colors_per_line,
                        int              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, int              colors_per_line, int              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 char *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>
<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_COLUMN_VIEW</NAME>
#define GTK_TYPE_COLUMN_VIEW         (gtk_column_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLUMN_VIEW</NAME>
#define GTK_COLUMN_VIEW(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_COLUMN_VIEW, GtkColumnView))
</MACRO>
<MACRO>
<NAME>GTK_COLUMN_VIEW_CLASS</NAME>
#define GTK_COLUMN_VIEW_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_COLUMN_VIEW, GtkColumnViewClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLUMN_VIEW</NAME>
#define GTK_IS_COLUMN_VIEW(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_COLUMN_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLUMN_VIEW_CLASS</NAME>
#define GTK_IS_COLUMN_VIEW_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_COLUMN_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_COLUMN_VIEW_GET_CLASS</NAME>
#define GTK_COLUMN_VIEW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_COLUMN_VIEW, GtkColumnViewClass))
</MACRO>
<FUNCTION>
<NAME>gtk_column_view_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_columns</NAME>
<RETURNS>GListModel *</RETURNS>
GtkColumnView          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_append_column</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, GtkColumnViewColumn    *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_remove_column</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, GtkColumnViewColumn    *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_insert_column</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, guint                   position, GtkColumnViewColumn    *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_model</NAME>
<RETURNS>GtkSelectionModel *</RETURNS>
GtkColumnView          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_set_model</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_show_row_separators</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnView          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_set_show_row_separators</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, gboolean                show_row_separators
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_show_column_separators</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnView          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_set_show_column_separators</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, gboolean                show_column_separators
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_sorter</NAME>
<RETURNS>GtkSorter *</RETURNS>
GtkColumnView          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_sort_by_column</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, GtkColumnViewColumn    *column, GtkSortType             direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_set_single_click_activate</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, gboolean                single_click_activate
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_single_click_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnView          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_set_reorderable</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, gboolean                reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_reorderable</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnView          *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_set_enable_rubberband</NAME>
<RETURNS>void</RETURNS>
GtkColumnView          *self, gboolean                enable_rubberband
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_get_enable_rubberband</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnView          *self
</FUNCTION>
<STRUCT>
<NAME>GtkColumnView</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkColumnViewClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkColumnViewColumn</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLUMN_VIEW_COLUMN</NAME>
#define GTK_TYPE_COLUMN_VIEW_COLUMN         (gtk_column_view_column_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLUMN_VIEW_COLUMN</NAME>
#define GTK_COLUMN_VIEW_COLUMN(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_COLUMN_VIEW_COLUMN, GtkColumnViewColumn))
</MACRO>
<MACRO>
<NAME>GTK_COLUMN_VIEW_COLUMN_CLASS</NAME>
#define GTK_COLUMN_VIEW_COLUMN_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_COLUMN_VIEW_COLUMN, GtkColumnViewColumnClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLUMN_VIEW_COLUMN</NAME>
#define GTK_IS_COLUMN_VIEW_COLUMN(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_COLUMN_VIEW_COLUMN))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLUMN_VIEW_COLUMN_CLASS</NAME>
#define GTK_IS_COLUMN_VIEW_COLUMN_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_COLUMN_VIEW_COLUMN))
</MACRO>
<MACRO>
<NAME>GTK_COLUMN_VIEW_COLUMN_GET_CLASS</NAME>
#define GTK_COLUMN_VIEW_COLUMN_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_COLUMN_VIEW_COLUMN, GtkColumnViewColumnClass))
</MACRO>
<FUNCTION>
<NAME>gtk_column_view_column_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_new</NAME>
<RETURNS>GtkColumnViewColumn *</RETURNS>
const char             *title, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_column_view</NAME>
<RETURNS>GtkColumnView *</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_factory</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_factory</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_title</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, const char             *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_title</NAME>
<RETURNS>const char *</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_sorter</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, GtkSorter              *sorter
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_sorter</NAME>
<RETURNS>GtkSorter *</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_visible</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, gboolean                visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_header_menu</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, GMenuModel             *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_header_menu</NAME>
<RETURNS>GMenuModel *</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_fixed_width</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, int                     fixed_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_fixed_width</NAME>
<RETURNS>int</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_resizable</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, gboolean                resizable
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_resizable</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_set_expand</NAME>
<RETURNS>void</RETURNS>
GtkColumnViewColumn    *self, gboolean                expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_column_view_column_get_expand</NAME>
<RETURNS>gboolean</RETURNS>
GtkColumnViewColumn    *self
</FUNCTION>
<STRUCT>
<NAME>GtkColumnViewColumnClass</NAME>
</STRUCT>
<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);
  char    *(* format_entry_text) (GtkComboBox *combo_box,
                                  const char *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>int</RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active</NAME>
<RETURNS>void</RETURNS>
GtkComboBox     *combo_box, int              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, int                 text_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_entry_text_column</NAME>
<RETURNS>int</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_id_column</NAME>
<RETURNS>int</RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_id_column</NAME>
<RETURNS>void</RETURNS>
GtkComboBox *combo_box, int          id_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_active_id</NAME>
<RETURNS>const char *</RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active_id</NAME>
<RETURNS>gboolean</RETURNS>
GtkComboBox *combo_box, const char *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 char          *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_insert_text</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, int                  position, const char          *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_prepend_text</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, const char          *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_remove</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, int                  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>char *</RETURNS>
GtkComboBoxText     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_insert</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, int                  position, const char          *id, const char          *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_append</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, const char          *id, const char          *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_prepend</NAME>
<RETURNS>void</RETURNS>
GtkComboBoxText     *combo_box, const char          *id, const char          *text
</FUNCTION>
<STRUCT>
<NAME>GtkComboBoxText</NAME>
</STRUCT>
<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_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 char      *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 char      *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_resource</NAME>
<RETURNS>void</RETURNS>
GtkCssProvider *css_provider, const char     *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>
<USER_FUNCTION>
<NAME>GtkCustomFilterFunc</NAME>
<RETURNS>gboolean</RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CUSTOM_FILTER</NAME>
#define GTK_TYPE_CUSTOM_FILTER             (gtk_custom_filter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_custom_filter_new</NAME>
<RETURNS>GtkCustomFilter *</RETURNS>
GtkCustomFilterFunc     match_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_custom_filter_set_filter_func</NAME>
<RETURNS>void</RETURNS>
GtkCustomFilter        *self, GtkCustomFilterFunc     match_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<STRUCT>
<NAME>GtkCustomFilter</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_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>
<FUNCTION>
<NAME>gtk_custom_paper_unix_dialog_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_load_custom_papers</NAME>
<RETURNS>void</RETURNS>
GListStore *store
</FUNCTION>
<STRUCT>
<NAME>GtkCustomPaperUnixDialog</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CUSTOM_SORTER</NAME>
#define GTK_TYPE_CUSTOM_SORTER             (gtk_custom_sorter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_custom_sorter_new</NAME>
<RETURNS>GtkCustomSorter *</RETURNS>
GCompareDataFunc        sort_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_custom_sorter_set_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkCustomSorter        *self, GCompareDataFunc        sort_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<STRUCT>
<NAME>GtkCustomSorter</NAME>
</STRUCT>
<ENUM>
<NAME>GtkDebugFlags</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 << 10,
  GTK_DEBUG_TOUCHSCREEN     = 1 << 11,
  GTK_DEBUG_ACTIONS         = 1 << 12,
  GTK_DEBUG_LAYOUT          = 1 << 13,
  GTK_DEBUG_SNAPSHOT        = 1 << 14,
  GTK_DEBUG_CONSTRAINTS     = 1 << 15,
  GTK_DEBUG_BUILDER_OBJECTS = 1 << 16,
  GTK_DEBUG_A11Y            = 1 << 17,
} GtkDebugFlags;
</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>GtkDebugFlags</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_set_debug_flags</NAME>
<RETURNS>void</RETURNS>
GtkDebugFlags 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, int 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 char      *title, GtkWindow       *parent, GtkDialogFlags   flags, const char      *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkDialog   *dialog, GtkWidget   *child, int          response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_button</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDialog   *dialog, const char *button_text, int          response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_buttons</NAME>
<RETURNS>void</RETURNS>
GtkDialog   *dialog, const char *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_set_response_sensitive</NAME>
<RETURNS>void</RETURNS>
GtkDialog *dialog, int        response_id, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_set_default_response</NAME>
<RETURNS>void</RETURNS>
GtkDialog *dialog, int        response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_widget_for_response</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkDialog *dialog, int        response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_response_for_widget</NAME>
<RETURNS>int</RETURNS>
GtkDialog *dialog, GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_response</NAME>
<RETURNS>void</RETURNS>
GtkDialog *dialog, int        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>
<MACRO>
<NAME>GTK_TYPE_DIRECTORY_LIST</NAME>
#define GTK_TYPE_DIRECTORY_LIST (gtk_directory_list_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_directory_list_new</NAME>
<RETURNS>GtkDirectoryList *</RETURNS>
const char             *attributes, GFile                  *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_set_file</NAME>
<RETURNS>void</RETURNS>
GtkDirectoryList       *self, GFile                  *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_get_file</NAME>
<RETURNS>GFile *</RETURNS>
GtkDirectoryList       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_set_attributes</NAME>
<RETURNS>void</RETURNS>
GtkDirectoryList       *self, const char             *attributes
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_get_attributes</NAME>
<RETURNS>const char *</RETURNS>
GtkDirectoryList       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_set_io_priority</NAME>
<RETURNS>void</RETURNS>
GtkDirectoryList       *self, int                     io_priority
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_get_io_priority</NAME>
<RETURNS>int</RETURNS>
GtkDirectoryList       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_is_loading</NAME>
<RETURNS>gboolean</RETURNS>
GtkDirectoryList       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_get_error</NAME>
<RETURNS>const GError *</RETURNS>
GtkDirectoryList       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_set_monitored</NAME>
<RETURNS>void</RETURNS>
GtkDirectoryList       *self, gboolean                monitored
</FUNCTION>
<FUNCTION>
<NAME>gtk_directory_list_get_monitored</NAME>
<RETURNS>gboolean</RETURNS>
GtkDirectoryList       *self
</FUNCTION>
<STRUCT>
<NAME>GtkDirectoryList</NAME>
</STRUCT>
<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>
<FUNCTION>
<NAME>gtk_drag_check_threshold_double</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget *widget, double     start_x, double     start_y, double     current_x, double     current_y
</FUNCTION>
<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>
<MACRO>
<NAME>GTK_TYPE_DROP_DOWN</NAME>
#define GTK_TYPE_DROP_DOWN         (gtk_drop_down_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_drop_down_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GListModel             *model, GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_new_from_strings</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char * const *    strings
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_set_model</NAME>
<RETURNS>void</RETURNS>
GtkDropDown            *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkDropDown            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_set_selected</NAME>
<RETURNS>void</RETURNS>
GtkDropDown            *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_get_selected</NAME>
<RETURNS>guint</RETURNS>
GtkDropDown            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_get_selected_item</NAME>
<RETURNS>gpointer</RETURNS>
GtkDropDown            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_set_factory</NAME>
<RETURNS>void</RETURNS>
GtkDropDown            *self, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_get_factory</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
GtkDropDown            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_set_list_factory</NAME>
<RETURNS>void</RETURNS>
GtkDropDown            *self, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_get_list_factory</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
GtkDropDown            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_set_expression</NAME>
<RETURNS>void</RETURNS>
GtkDropDown            *self, GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_get_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkDropDown            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_set_enable_search</NAME>
<RETURNS>void</RETURNS>
GtkDropDown            *self, gboolean                enable_search
</FUNCTION>
<FUNCTION>
<NAME>gtk_drop_down_get_enable_search</NAME>
<RETURNS>gboolean</RETURNS>
GtkDropDown            *self
</FUNCTION>
<STRUCT>
<NAME>GtkDropDown</NAME>
</STRUCT>
<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 char     *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_get_delegate</NAME>
<RETURNS>GtkEditable *</RETURNS>
GtkEditable *editable
</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_EDITABLE_LABEL</NAME>
#define GTK_TYPE_EDITABLE_LABEL (gtk_editable_label_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_editable_label_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char       *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_label_get_editing</NAME>
<RETURNS>gboolean</RETURNS>
GtkEditableLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_label_start_editing</NAME>
<RETURNS>void</RETURNS>
GtkEditableLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_editable_label_stop_editing</NAME>
<RETURNS>void</RETURNS>
GtkEditableLabel *self, gboolean          commit
</FUNCTION>
<STRUCT>
<NAME>GtkEditableLabel</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_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, int            max
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_max_length</NAME>
<RETURNS>int</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, float          xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_alignment</NAME>
<RETURNS>float</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, double        fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_progress_fraction</NAME>
<RETURNS>double</RETURNS>
GtkEntry     *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_progress_pulse_step</NAME>
<RETURNS>void</RETURNS>
GtkEntry     *entry, double        fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_progress_pulse_step</NAME>
<RETURNS>double</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 char *</RETURNS>
GtkEntry             *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_placeholder_text</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, const char           *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 char           *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 char *</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>int</RETURNS>
GtkEntry             *entry, int                   x, int                   y
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_set_icon_tooltip_text</NAME>
<RETURNS>void</RETURNS>
GtkEntry             *entry, GtkEntryIconPosition  icon_pos, const char           *tooltip
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_tooltip_text</NAME>
<RETURNS>char *</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 char           *tooltip
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_get_icon_tooltip_markup</NAME>
<RETURNS>char *</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>int</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 char     *chars,
                                          guint           n_chars);

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

  /* Virtual Methods */

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

  guint        (*get_length)             (GtkEntryBuffer *buffer);

  guint        (*insert_text)            (GtkEntryBuffer *buffer,
                                          guint           position,
                                          const char     *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 char      *initial_chars, int              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 char *</RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_set_text</NAME>
<RETURNS>void</RETURNS>
GtkEntryBuffer  *buffer, const char      *chars, int              n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_set_max_length</NAME>
<RETURNS>void</RETURNS>
GtkEntryBuffer  *buffer, int              max_length
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_max_length</NAME>
<RETURNS>int</RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_insert_text</NAME>
<RETURNS>guint</RETURNS>
GtkEntryBuffer  *buffer, guint            position, const char      *chars, int              n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_delete_text</NAME>
<RETURNS>guint</RETURNS>
GtkEntryBuffer  *buffer, guint            position, int              n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_emit_inserted_text</NAME>
<RETURNS>void</RETURNS>
GtkEntryBuffer  *buffer, guint            position, const char      *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 char         *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, int                          length
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_minimum_key_length</NAME>
<RETURNS>int</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_compute_prefix</NAME>
<RETURNS>char *</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_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 char *</RETURNS>
GtkEntryCompletion *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_text_column</NAME>
<RETURNS>void</RETURNS>
GtkEntryCompletion          *completion, int                          column
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_text_column</NAME>
<RETURNS>int</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>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>GtkOrdering</NAME>
typedef enum {
  GTK_ORDERING_SMALLER = -1,
  GTK_ORDERING_EQUAL = 0,
  GTK_ORDERING_LARGER = 1
} GtkOrdering;
</ENUM>
<FUNCTION>
<NAME>gtk_ordering_from_cmpfunc</NAME>
<RETURNS>GtkOrdering</RETURNS>
int cmpfunc_result
</FUNCTION>
<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,
  GTK_INPUT_HINT_PRIVATE             = 1 << 11,
} 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>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>
<ENUM>
<NAME>GtkAccessibleRole</NAME>
typedef enum {
  GTK_ACCESSIBLE_ROLE_ALERT,
  GTK_ACCESSIBLE_ROLE_ALERT_DIALOG,
  GTK_ACCESSIBLE_ROLE_BANNER,
  GTK_ACCESSIBLE_ROLE_BUTTON,
  GTK_ACCESSIBLE_ROLE_CAPTION,
  GTK_ACCESSIBLE_ROLE_CELL,
  GTK_ACCESSIBLE_ROLE_CHECKBOX,
  GTK_ACCESSIBLE_ROLE_COLUMN_HEADER,
  GTK_ACCESSIBLE_ROLE_COMBO_BOX,
  GTK_ACCESSIBLE_ROLE_COMMAND,
  GTK_ACCESSIBLE_ROLE_COMPOSITE,
  GTK_ACCESSIBLE_ROLE_DIALOG,
  GTK_ACCESSIBLE_ROLE_DOCUMENT,
  GTK_ACCESSIBLE_ROLE_FEED,
  GTK_ACCESSIBLE_ROLE_FORM,
  GTK_ACCESSIBLE_ROLE_GENERIC,
  GTK_ACCESSIBLE_ROLE_GRID,
  GTK_ACCESSIBLE_ROLE_GRID_CELL,
  GTK_ACCESSIBLE_ROLE_GROUP,
  GTK_ACCESSIBLE_ROLE_HEADING,
  GTK_ACCESSIBLE_ROLE_IMG,
  GTK_ACCESSIBLE_ROLE_INPUT,
  GTK_ACCESSIBLE_ROLE_LABEL,
  GTK_ACCESSIBLE_ROLE_LANDMARK,
  GTK_ACCESSIBLE_ROLE_LEGEND,
  GTK_ACCESSIBLE_ROLE_LINK,
  GTK_ACCESSIBLE_ROLE_LIST,
  GTK_ACCESSIBLE_ROLE_LIST_BOX,
  GTK_ACCESSIBLE_ROLE_LIST_ITEM,
  GTK_ACCESSIBLE_ROLE_LOG,
  GTK_ACCESSIBLE_ROLE_MAIN,
  GTK_ACCESSIBLE_ROLE_MARQUEE,
  GTK_ACCESSIBLE_ROLE_MATH,
  GTK_ACCESSIBLE_ROLE_METER,
  GTK_ACCESSIBLE_ROLE_MENU,
  GTK_ACCESSIBLE_ROLE_MENU_BAR,
  GTK_ACCESSIBLE_ROLE_MENU_ITEM,
  GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX,
  GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO,
  GTK_ACCESSIBLE_ROLE_NAVIGATION,
  GTK_ACCESSIBLE_ROLE_NONE,
  GTK_ACCESSIBLE_ROLE_NOTE,
  GTK_ACCESSIBLE_ROLE_OPTION,
  GTK_ACCESSIBLE_ROLE_PRESENTATION,
  GTK_ACCESSIBLE_ROLE_PROGRESS_BAR,
  GTK_ACCESSIBLE_ROLE_RADIO,
  GTK_ACCESSIBLE_ROLE_RADIO_GROUP,
  GTK_ACCESSIBLE_ROLE_RANGE,
  GTK_ACCESSIBLE_ROLE_REGION,
  GTK_ACCESSIBLE_ROLE_ROW,
  GTK_ACCESSIBLE_ROLE_ROW_GROUP,
  GTK_ACCESSIBLE_ROLE_ROW_HEADER,
  GTK_ACCESSIBLE_ROLE_SCROLLBAR,
  GTK_ACCESSIBLE_ROLE_SEARCH,
  GTK_ACCESSIBLE_ROLE_SEARCH_BOX,
  GTK_ACCESSIBLE_ROLE_SECTION,
  GTK_ACCESSIBLE_ROLE_SECTION_HEAD,
  GTK_ACCESSIBLE_ROLE_SELECT,
  GTK_ACCESSIBLE_ROLE_SEPARATOR,
  GTK_ACCESSIBLE_ROLE_SLIDER,
  GTK_ACCESSIBLE_ROLE_SPIN_BUTTON,
  GTK_ACCESSIBLE_ROLE_STATUS,
  GTK_ACCESSIBLE_ROLE_STRUCTURE,
  GTK_ACCESSIBLE_ROLE_SWITCH,
  GTK_ACCESSIBLE_ROLE_TAB,
  GTK_ACCESSIBLE_ROLE_TABLE,
  GTK_ACCESSIBLE_ROLE_TAB_LIST,
  GTK_ACCESSIBLE_ROLE_TAB_PANEL,
  GTK_ACCESSIBLE_ROLE_TEXT_BOX,
  GTK_ACCESSIBLE_ROLE_TIME,
  GTK_ACCESSIBLE_ROLE_TIMER,
  GTK_ACCESSIBLE_ROLE_TOOLBAR,
  GTK_ACCESSIBLE_ROLE_TOOLTIP,
  GTK_ACCESSIBLE_ROLE_TREE,
  GTK_ACCESSIBLE_ROLE_TREE_GRID,
  GTK_ACCESSIBLE_ROLE_TREE_ITEM,
  GTK_ACCESSIBLE_ROLE_WIDGET,
  GTK_ACCESSIBLE_ROLE_WINDOW
} GtkAccessibleRole;
</ENUM>
<ENUM>
<NAME>GtkAccessibleState</NAME>
typedef enum {
  GTK_ACCESSIBLE_STATE_BUSY,
  GTK_ACCESSIBLE_STATE_CHECKED,
  GTK_ACCESSIBLE_STATE_DISABLED,
  GTK_ACCESSIBLE_STATE_EXPANDED,
  GTK_ACCESSIBLE_STATE_HIDDEN,
  GTK_ACCESSIBLE_STATE_INVALID,
  GTK_ACCESSIBLE_STATE_PRESSED,
  GTK_ACCESSIBLE_STATE_SELECTED
} GtkAccessibleState;
</ENUM>
<MACRO>
<NAME>GTK_ACCESSIBLE_VALUE_UNDEFINED</NAME>
#define GTK_ACCESSIBLE_VALUE_UNDEFINED  (-1)
</MACRO>
<ENUM>
<NAME>GtkAccessibleProperty</NAME>
typedef enum {
  GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE,
  GTK_ACCESSIBLE_PROPERTY_DESCRIPTION,
  GTK_ACCESSIBLE_PROPERTY_HAS_POPUP,
  GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS,
  GTK_ACCESSIBLE_PROPERTY_LABEL,
  GTK_ACCESSIBLE_PROPERTY_LEVEL,
  GTK_ACCESSIBLE_PROPERTY_MODAL,
  GTK_ACCESSIBLE_PROPERTY_MULTI_LINE,
  GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE,
  GTK_ACCESSIBLE_PROPERTY_ORIENTATION,
  GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER,
  GTK_ACCESSIBLE_PROPERTY_READ_ONLY,
  GTK_ACCESSIBLE_PROPERTY_REQUIRED,
  GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION,
  GTK_ACCESSIBLE_PROPERTY_SORT,
  GTK_ACCESSIBLE_PROPERTY_VALUE_MAX,
  GTK_ACCESSIBLE_PROPERTY_VALUE_MIN,
  GTK_ACCESSIBLE_PROPERTY_VALUE_NOW,
  GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT
} GtkAccessibleProperty;
</ENUM>
<ENUM>
<NAME>GtkAccessibleRelation</NAME>
typedef enum {
  GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT,
  GTK_ACCESSIBLE_RELATION_COL_COUNT,
  GTK_ACCESSIBLE_RELATION_COL_INDEX,
  GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT,
  GTK_ACCESSIBLE_RELATION_COL_SPAN,
  GTK_ACCESSIBLE_RELATION_CONTROLS,
  GTK_ACCESSIBLE_RELATION_DESCRIBED_BY,
  GTK_ACCESSIBLE_RELATION_DETAILS,
  GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE,
  GTK_ACCESSIBLE_RELATION_FLOW_TO,
  GTK_ACCESSIBLE_RELATION_LABELLED_BY,
  GTK_ACCESSIBLE_RELATION_OWNS,
  GTK_ACCESSIBLE_RELATION_POS_IN_SET,
  GTK_ACCESSIBLE_RELATION_ROW_COUNT,
  GTK_ACCESSIBLE_RELATION_ROW_INDEX,
  GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT,
  GTK_ACCESSIBLE_RELATION_ROW_SPAN,
  GTK_ACCESSIBLE_RELATION_SET_SIZE
} GtkAccessibleRelation;
</ENUM>
<ENUM>
<NAME>GtkAccessibleTristate</NAME>
typedef enum {
  GTK_ACCESSIBLE_TRISTATE_FALSE,
  GTK_ACCESSIBLE_TRISTATE_TRUE,
  GTK_ACCESSIBLE_TRISTATE_MIXED
} GtkAccessibleTristate;
</ENUM>
<ENUM>
<NAME>GtkAccessibleInvalidState</NAME>
typedef enum { /*< prefix=GTK_ACCESSIBLE_INVALID >*/
  GTK_ACCESSIBLE_INVALID_FALSE,
  GTK_ACCESSIBLE_INVALID_TRUE,
  GTK_ACCESSIBLE_INVALID_GRAMMAR,
  GTK_ACCESSIBLE_INVALID_SPELLING,
} GtkAccessibleInvalidState;
</ENUM>
<ENUM>
<NAME>GtkAccessibleAutocomplete</NAME>
typedef enum { /*< prefix=GTK_ACCESSIBLE_AUTOCOMPLETE >*/
  GTK_ACCESSIBLE_AUTOCOMPLETE_NONE,
  GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE,
  GTK_ACCESSIBLE_AUTOCOMPLETE_LIST,
  GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH
} GtkAccessibleAutocomplete;
</ENUM>
<ENUM>
<NAME>GtkAccessibleSort</NAME>
typedef enum { /*< prefix=GTK_ACCESSIBLE_SORT >*/
  GTK_ACCESSIBLE_SORT_NONE,
  GTK_ACCESSIBLE_SORT_ASCENDING,
  GTK_ACCESSIBLE_SORT_DESCENDING,
  GTK_ACCESSIBLE_SORT_OTHER
} GtkAccessibleSort;
</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_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 char *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char *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 char *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_label</NAME>
<RETURNS>const char *</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_EXPRESSION</NAME>
#define GTK_TYPE_EXPRESSION     (gtk_expression_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IS_EXPRESSION</NAME>
#define GTK_IS_EXPRESSION(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EXPRESSION))
</MACRO>
<MACRO>
<NAME>GTK_EXPRESSION</NAME>
#define GTK_EXPRESSION(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EXPRESSION, GtkExpression))
</MACRO>
<USER_FUNCTION>
<NAME>GtkExpressionNotify</NAME>
<RETURNS>void</RETURNS>
gpointer                        user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_expression_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_ref</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkExpression                  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_unref</NAME>
<RETURNS>void</RETURNS>
GtkExpression                  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_get_value_type</NAME>
<RETURNS>GType</RETURNS>
GtkExpression                  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_is_static</NAME>
<RETURNS>gboolean</RETURNS>
GtkExpression                  *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_evaluate</NAME>
<RETURNS>gboolean</RETURNS>
GtkExpression                  *self, gpointer                        this_, GValue                         *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_watch</NAME>
<RETURNS>GtkExpressionWatch *</RETURNS>
GtkExpression                  *self, gpointer                        this_, GtkExpressionNotify             notify, gpointer                        user_data, GDestroyNotify                  user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_bind</NAME>
<RETURNS>GtkExpressionWatch *</RETURNS>
GtkExpression                  *self, gpointer                        target, const char *                    property, gpointer                        this_
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_watch_ref</NAME>
<RETURNS>GtkExpressionWatch *</RETURNS>
GtkExpressionWatch             *watch
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_watch_unref</NAME>
<RETURNS>void</RETURNS>
GtkExpressionWatch             *watch
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_watch_evaluate</NAME>
<RETURNS>gboolean</RETURNS>
GtkExpressionWatch             *watch, GValue                         *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_expression_watch_unwatch</NAME>
<RETURNS>void</RETURNS>
GtkExpressionWatch             *watch
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PROPERTY_EXPRESSION</NAME>
#define GTK_TYPE_PROPERTY_EXPRESSION (gtk_property_expression_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_property_expression_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_expression_new</NAME>
<RETURNS>GtkExpression *</RETURNS>
GType                           this_type, GtkExpression                  *expression, const char                     *property_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_expression_new_for_pspec</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkExpression                  *expression, GParamSpec                     *pspec
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_expression_get_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkExpression                  *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_expression_get_pspec</NAME>
<RETURNS>GParamSpec *</RETURNS>
GtkExpression                  *expression
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CONSTANT_EXPRESSION</NAME>
#define GTK_TYPE_CONSTANT_EXPRESSION (gtk_constant_expression_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_constant_expression_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_constant_expression_new</NAME>
<RETURNS>GtkExpression *</RETURNS>
GType                           value_type, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_constant_expression_new_for_value</NAME>
<RETURNS>GtkExpression *</RETURNS>
const GValue                   *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_constant_expression_get_value</NAME>
<RETURNS>const GValue *</RETURNS>
GtkExpression                  *expression
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_OBJECT_EXPRESSION</NAME>
#define GTK_TYPE_OBJECT_EXPRESSION (gtk_object_expression_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_object_expression_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_object_expression_new</NAME>
<RETURNS>GtkExpression *</RETURNS>
GObject                        *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_object_expression_get_object</NAME>
<RETURNS>GObject *</RETURNS>
GtkExpression                  *expression
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CLOSURE_EXPRESSION</NAME>
#define GTK_TYPE_CLOSURE_EXPRESSION (gtk_closure_expression_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_closure_expression_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_closure_expression_new</NAME>
<RETURNS>GtkExpression *</RETURNS>
GType                           value_type, GClosure                       *closure, guint                           n_params, GtkExpression                 **params
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CCLOSURE_EXPRESSION</NAME>
#define GTK_TYPE_CCLOSURE_EXPRESSION (gtk_cclosure_expression_get_type())
</MACRO>
<FUNCTION>
<NAME>gtk_cclosure_expression_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cclosure_expression_new</NAME>
<RETURNS>GtkExpression *</RETURNS>
GType                           value_type, GClosureMarshal                 marshal, guint                           n_params, GtkExpression                 **params, GCallback                       callback_func, gpointer                        user_data, GClosureNotify                  user_destroy
</FUNCTION>
<MACRO>
<NAME>GTK_VALUE_HOLDS_EXPRESSION</NAME>
#define GTK_VALUE_HOLDS_EXPRESSION(value)       (G_VALUE_HOLDS ((value), GTK_TYPE_EXPRESSION))
</MACRO>
<FUNCTION>
<NAME>gtk_value_set_expression</NAME>
<RETURNS>void</RETURNS>
GValue        *value, GtkExpression *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_value_take_expression</NAME>
<RETURNS>void</RETURNS>
GValue        *value, GtkExpression *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_value_get_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
const GValue  *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_value_dup_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
const GValue  *value
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PARAM_SPEC_EXPRESSION</NAME>
#define GTK_TYPE_PARAM_SPEC_EXPRESSION (gtk_param_expression_get_type())
</MACRO>
<MACRO>
<NAME>GTK_PARAM_SPEC_EXPRESSION</NAME>
#define GTK_PARAM_SPEC_EXPRESSION(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PARAM_SPEC_EXPRESSION, GtkParamSpecExpression))
</MACRO>
<MACRO>
<NAME>GTK_IS_PARAM_SPEC_EXPRESSION</NAME>
#define GTK_IS_PARAM_SPEC_EXPRESSION(obj)       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PARAM_SPEC_EXPRESSION))
</MACRO>
<STRUCT>
<NAME>GtkParamSpecExpression</NAME>
typedef struct {
  /*< private >*/
  GParamSpec parent_instance;
} GtkParamSpecExpression;
</STRUCT>
<FUNCTION>
<NAME>gtk_param_expression_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_param_spec_expression</NAME>
<RETURNS>GParamSpec *</RETURNS>
const char    *name, const char    *nick, const char    *blurb, GParamFlags    flags
</FUNCTION>
<STRUCT>
<NAME>GtkCClosureExpression</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkClosureExpression</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkConstantExpression</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkExpression</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkExpressionWatch</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkObjectExpression</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPropertyExpression</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 char           *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_current_name</NAME>
<RETURNS>char *</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_get_files</NAME>
<RETURNS>GListModel *</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_get_filters</NAME>
<RETURNS>GListModel *</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_get_shortcut_folders</NAME>
<RETURNS>GListModel *</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_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 char           *title, GtkWindow            *parent, GtkFileChooserAction  action, const char           *first_button_text, ...
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooserDialog</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 char           *title, GtkWindow            *parent, GtkFileChooserAction  action, const char           *accept_label, const char           *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_FILTERS,
  GTK_FILE_CHOOSER_PROP_SHORTCUT_FOLDERS,
  GTK_FILE_CHOOSER_PROP_LAST                   = GTK_FILE_CHOOSER_PROP_SHORTCUT_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>
<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 char    *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_get_name</NAME>
<RETURNS>const char *</RETURNS>
GtkFileFilter *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_mime_type</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter *filter, const char    *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_pattern</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter *filter, const char    *pattern
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_pixbuf_formats</NAME>
<RETURNS>void</RETURNS>
GtkFileFilter *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_get_attributes</NAME>
<RETURNS>const char **</RETURNS>
GtkFileFilter *filter
</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_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>
<ENUM>
<NAME>GtkFilterMatch</NAME>
typedef enum {
  GTK_FILTER_MATCH_SOME = 0,
  GTK_FILTER_MATCH_NONE,
  GTK_FILTER_MATCH_ALL
} GtkFilterMatch;
</ENUM>
<ENUM>
<NAME>GtkFilterChange</NAME>
typedef enum {
  GTK_FILTER_CHANGE_DIFFERENT = 0,
  GTK_FILTER_CHANGE_LESS_STRICT,
  GTK_FILTER_CHANGE_MORE_STRICT,
} GtkFilterChange;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_FILTER</NAME>
#define GTK_TYPE_FILTER             (gtk_filter_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkFilterClass</NAME>
struct _GtkFilterClass
{
  GObjectClass parent_class;

  gboolean              (* match)                               (GtkFilter              *self,
                                                                 gpointer                item);

  /* optional */
  GtkFilterMatch        (* get_strictness)                      (GtkFilter              *self);

  /* 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_filter_match</NAME>
<RETURNS>gboolean</RETURNS>
GtkFilter              *self, gpointer                item
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_get_strictness</NAME>
<RETURNS>GtkFilterMatch</RETURNS>
GtkFilter              *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_changed</NAME>
<RETURNS>void</RETURNS>
GtkFilter              *self, GtkFilterChange         change
</FUNCTION>
<STRUCT>
<NAME>GtkFilter</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILTER_LIST_MODEL</NAME>
#define GTK_TYPE_FILTER_LIST_MODEL (gtk_filter_list_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_filter_list_model_new</NAME>
<RETURNS>GtkFilterListModel *</RETURNS>
GListModel             *model, GtkFilter              *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_set_filter</NAME>
<RETURNS>void</RETURNS>
GtkFilterListModel     *self, GtkFilter              *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_get_filter</NAME>
<RETURNS>GtkFilter *</RETURNS>
GtkFilterListModel     *self
</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_set_incremental</NAME>
<RETURNS>void</RETURNS>
GtkFilterListModel     *self, gboolean                incremental
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_get_incremental</NAME>
<RETURNS>gboolean</RETURNS>
GtkFilterListModel     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_get_pending</NAME>
<RETURNS>guint</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, double        x, double        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, double        x, double        y
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_get_child_position</NAME>
<RETURNS>void</RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, double       *x, double       *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>
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>int</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, int                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, int                idx
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_child_at_pos</NAME>
<RETURNS>GtkFlowBoxChild *</RETURNS>
GtkFlowBox        *box, int                x, int                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>int</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>
<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 char    *fontname
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_get_title</NAME>
<RETURNS>const char *</RETURNS>
GtkFontButton *font_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_set_title</NAME>
<RETURNS>void</RETURNS>
GtkFontButton *font_button, const char    *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);
  int               (* 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 char     *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>int</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>char *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_font</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, const char       *fontname
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_preview_text</NAME>
<RETURNS>char *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_preview_text</NAME>
<RETURNS>void</RETURNS>
GtkFontChooser   *fontchooser, const char       *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 char           *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 char    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_label</NAME>
<RETURNS>void</RETURNS>
GtkFrame    *frame, const char *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label</NAME>
<RETURNS>const char *</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, float          xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label_align</NAME>
<RETURNS>float</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, double           *x, double           *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, double           *x, double           *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,
                         int              n_press,
                         double           x,
                         double           y);
  void     (* released) (GtkGestureClick *gesture,
                         int              n_press,
                         double           x,
                         double           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, double         *x, double         *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_drag_get_offset</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureDrag *gesture, double         *x, double         *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>double</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, double           *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_axes</NAME>
<RETURNS>gboolean</RETURNS>
GtkGestureStylus  *gesture, GdkAxisUse         axes[], double           **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, double          *velocity_x, double          *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>double</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, int           major, int           minor
</FUNCTION>
<FUNCTION>
<NAME>gtk_gl_area_get_required_version</NAME>
<RETURNS>void</RETURNS>
GtkGLArea    *area, int          *major, int          *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, int              column, int              row, int              width, int              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_attach_next_to</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, GtkWidget       *child, GtkWidget       *sibling, GtkPositionType  side, int              width, int              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_child_at</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkGrid         *grid, int              column, int              row
</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, int              position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_insert_column</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, int              position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_remove_row</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, int              position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_remove_column</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, int              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, int           row, GtkBaselinePosition pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_row_baseline_position</NAME>
<RETURNS>GtkBaselinePosition</RETURNS>
GtkGrid      *grid, int           row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_baseline_row</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, int              row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_baseline_row</NAME>
<RETURNS>int</RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_query_child</NAME>
<RETURNS>void</RETURNS>
GtkGrid         *grid, GtkWidget       *child, int             *column, int             *row, int             *width, int             *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_row</NAME>
<RETURNS>void</RETURNS>
GtkGridLayoutChild  *child, int                  row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_row</NAME>
<RETURNS>int</RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_column</NAME>
<RETURNS>void</RETURNS>
GtkGridLayoutChild  *child, int                  column
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_column</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_GRID_VIEW</NAME>
#define GTK_TYPE_GRID_VIEW         (gtk_grid_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GRID_VIEW</NAME>
#define GTK_GRID_VIEW(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GRID_VIEW, GtkGridView))
</MACRO>
<MACRO>
<NAME>GTK_GRID_VIEW_CLASS</NAME>
#define GTK_GRID_VIEW_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GRID_VIEW, GtkGridViewClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GRID_VIEW</NAME>
#define GTK_IS_GRID_VIEW(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GRID_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_IS_GRID_VIEW_CLASS</NAME>
#define GTK_IS_GRID_VIEW_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GRID_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_GRID_VIEW_GET_CLASS</NAME>
#define GTK_GRID_VIEW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GRID_VIEW, GtkGridViewClass))
</MACRO>
<FUNCTION>
<NAME>gtk_grid_view_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkSelectionModel      *model, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_get_model</NAME>
<RETURNS>GtkSelectionModel *</RETURNS>
GtkGridView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_set_model</NAME>
<RETURNS>void</RETURNS>
GtkGridView            *self, GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_set_factory</NAME>
<RETURNS>void</RETURNS>
GtkGridView            *self, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_get_factory</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
GtkGridView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_get_min_columns</NAME>
<RETURNS>guint</RETURNS>
GtkGridView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_set_min_columns</NAME>
<RETURNS>void</RETURNS>
GtkGridView            *self, guint                   min_columns
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_get_max_columns</NAME>
<RETURNS>guint</RETURNS>
GtkGridView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_set_max_columns</NAME>
<RETURNS>void</RETURNS>
GtkGridView            *self, guint                   max_columns
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_set_enable_rubberband</NAME>
<RETURNS>void</RETURNS>
GtkGridView            *self, gboolean                enable_rubberband
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_get_enable_rubberband</NAME>
<RETURNS>gboolean</RETURNS>
GtkGridView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_set_single_click_activate</NAME>
<RETURNS>void</RETURNS>
GtkGridView            *self, gboolean                single_click_activate
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_view_get_single_click_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkGridView            *self
</FUNCTION>
<STRUCT>
<NAME>GtkGridView</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGridViewClass</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 char   *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_decoration_layout</NAME>
<RETURNS>const char *</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_get_display</NAME>
<RETURNS>GdkDisplay *</RETURNS>
GtkIconTheme                *self
</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 char                  *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_icon_sizes</NAME>
<RETURNS>int *</RETURNS>
GtkIconTheme                *self, const char                  *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_icon</NAME>
<RETURNS>GtkIconPaintable *</RETURNS>
GtkIconTheme                *self, const char                  *icon_name, const char                  *fallbacks[], int                          size, int                          scale, GtkTextDirection             direction, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_by_gicon</NAME>
<RETURNS>GtkIconPaintable *</RETURNS>
GtkIconTheme                *self, GIcon                       *icon, int                          size, int                          scale, GtkTextDirection             direction, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_paintable_new_for_file</NAME>
<RETURNS>GtkIconPaintable *</RETURNS>
GFile                       *file, int                          size, int                          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 char *</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, int             column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_text_column</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_markup_column</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_markup_column</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_pixbuf_column</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_pixbuf_column</NAME>
<RETURNS>int</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, int             columns
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_columns</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_width</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             item_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_width</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_spacing</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_spacing</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_row_spacing</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             row_spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_row_spacing</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_column_spacing</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             column_spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_column_spacing</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_margin</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_margin</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_padding</NAME>
<RETURNS>void</RETURNS>
GtkIconView    *icon_view, int             item_padding
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_padding</NAME>
<RETURNS>int</RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_path_at_pos</NAME>
<RETURNS>GtkTreePath *</RETURNS>
GtkIconView     *icon_view, int              x, int              y
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_at_pos</NAME>
<RETURNS>gboolean</RETURNS>
GtkIconView     *icon_view, int               x, int               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>int</RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_column</NAME>
<RETURNS>int</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, float                   row_align, float                   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, int                       drag_x, int                       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, int                x, int                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, int                column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_tooltip_column</NAME>
<RETURNS>int</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 char      *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_resource</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char      *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 char      *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 char      *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_resource</NAME>
<RETURNS>void</RETURNS>
GtkImage        *image, const char      *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 char      *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, int              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>int</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 char *str);
  gboolean (*retrieve_surrounding) (GtkIMContext *context);
  gboolean (*delete_surrounding)   (GtkIMContext *context,
				    int           offset,
				    int           n_chars);

  /* Virtual functions */
  void     (*set_client_widget)   (GtkIMContext   *context,
				   GtkWidget      *widget);
  void     (*get_preedit_string)  (GtkIMContext   *context,
				   char          **str,
				   PangoAttrList **attrs,
				   int            *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 char     *text,
				   int             len,
				   int             cursor_index);
  gboolean (*get_surrounding)     (GtkIMContext   *context,
				   char          **text,
				   int            *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, char              **str, PangoAttrList     **attrs, int                *cursor_pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_filter_keypress</NAME>
<RETURNS>gboolean</RETURNS>
GtkIMContext       *context, GdkEvent           *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_filter_key</NAME>
<RETURNS>gboolean</RETURNS>
GtkIMContext       *context, gboolean            press, GdkSurface         *surface, GdkDevice          *device, guint32             time, guint               keycode, GdkModifierType     state, int                 group
</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 char         *text, int                 len, int                 cursor_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_get_surrounding</NAME>
<RETURNS>gboolean</RETURNS>
GtkIMContext       *context, char              **text, int                *cursor_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_delete_surrounding</NAME>
<RETURNS>gboolean</RETURNS>
GtkIMContext       *context, int                 offset, int                 n_chars
</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, int                 max_seq_len, int                 n_seqs
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_context_simple_add_compose_file</NAME>
<RETURNS>void</RETURNS>
GtkIMContextSimple *context_simple, const char         *compose_file
</FUNCTION>
<STRUCT>
<NAME>GtkIMContextSimplePrivate</NAME>
</STRUCT>
<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 char     *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_action_widget</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, GtkWidget      *child, int             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 char     *button_text, int             response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_buttons</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, const char     *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, int             response_id, gboolean        setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_default_response</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, int             response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_response</NAME>
<RETURNS>void</RETURNS>
GtkInfoBar     *info_bar, int             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>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 char    *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char    *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_text</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, const char    *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_text</NAME>
<RETURNS>const char *</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 char    *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_label</NAME>
<RETURNS>const char *</RETURNS>
GtkLabel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_markup</NAME>
<RETURNS>void</RETURNS>
GtkLabel      *self, const char    *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 char       *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 char       *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>int</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>int</RETURNS>
GtkLabel         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_lines</NAME>
<RETURNS>void</RETURNS>
GtkLabel         *self, int               lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_lines</NAME>
<RETURNS>int</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, int               start_offset, int               end_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_selection_bounds</NAME>
<RETURNS>gboolean</RETURNS>
GtkLabel         *self, int              *start, int              *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, int      *x, int      *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 char *</RETURNS>
GtkLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_xalign</NAME>
<RETURNS>void</RETURNS>
GtkLabel *self, float     xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_xalign</NAME>
<RETURNS>float</RETURNS>
GtkLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_yalign</NAME>
<RETURNS>void</RETURNS>
GtkLabel *self, float     yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_yalign</NAME>
<RETURNS>float</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;

  /**
   * GtkLayoutManagerClass::create_layout_child:
   * @manager: the #GtkLayoutManager
   * @widget: the widget using the @manager
   * @for_child: the child of @widget
   *
   * Create a #GtkLayoutChild instance for the given @for_child widget.
   *
   * Returns: (transfer full): a #GtkLayoutChild
   */
  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>
<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>
double       min_value, double       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, double       value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_value</NAME>
<RETURNS>double</RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_min_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, double       value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_min_value</NAME>
<RETURNS>double</RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_max_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, double       value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_max_value</NAME>
<RETURNS>double</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 char *name, double       value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_remove_offset_value</NAME>
<RETURNS>void</RETURNS>
GtkLevelBar *self, const char *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_offset_value</NAME>
<RETURNS>gboolean</RETURNS>
GtkLevelBar *self, const char *name, double      *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 char    *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_new_with_label</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char    *uri, const char    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_get_uri</NAME>
<RETURNS>const char *</RETURNS>
GtkLinkButton *link_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_set_uri</NAME>
<RETURNS>void</RETURNS>
GtkLinkButton *link_button, const char    *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_BASE</NAME>
#define GTK_TYPE_LIST_BASE         (gtk_list_base_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_BASE</NAME>
#define GTK_LIST_BASE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_LIST_BASE, GtkListBase))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BASE_CLASS</NAME>
#define GTK_LIST_BASE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_LIST_BASE, GtkListBaseClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BASE</NAME>
#define GTK_IS_LIST_BASE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_LIST_BASE))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_BASE_CLASS</NAME>
#define GTK_IS_LIST_BASE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_LIST_BASE))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BASE_GET_CLASS</NAME>
#define GTK_LIST_BASE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_LIST_BASE, GtkListBaseClass))
</MACRO>
<FUNCTION>
<NAME>gtk_list_base_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkListBase</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkListBaseClass</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>int</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>int</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_append</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkWidget                     *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_insert</NAME>
<RETURNS>void</RETURNS>
GtkListBox                    *box, GtkWidget                     *child, int                            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, int                            index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_box_get_row_at_y</NAME>
<RETURNS>GtkListBoxRow *</RETURNS>
GtkListBox                    *box, int                            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_ITEM</NAME>
#define GTK_TYPE_LIST_ITEM         (gtk_list_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_ITEM</NAME>
#define GTK_LIST_ITEM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_LIST_ITEM, GtkListItem))
</MACRO>
<MACRO>
<NAME>GTK_LIST_ITEM_CLASS</NAME>
#define GTK_LIST_ITEM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_LIST_ITEM, GtkListItemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_ITEM</NAME>
#define GTK_IS_LIST_ITEM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_LIST_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_ITEM_CLASS</NAME>
#define GTK_IS_LIST_ITEM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_LIST_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_LIST_ITEM_GET_CLASS</NAME>
#define GTK_LIST_ITEM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_LIST_ITEM, GtkListItemClass))
</MACRO>
<FUNCTION>
<NAME>gtk_list_item_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_get_item</NAME>
<RETURNS>gpointer</RETURNS>
GtkListItem            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_get_position</NAME>
<RETURNS>guint</RETURNS>
GtkListItem            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_get_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkListItem            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_get_selectable</NAME>
<RETURNS>gboolean</RETURNS>
GtkListItem            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_set_selectable</NAME>
<RETURNS>void</RETURNS>
GtkListItem            *self, gboolean                selectable
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_get_activatable</NAME>
<RETURNS>gboolean</RETURNS>
GtkListItem            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_set_activatable</NAME>
<RETURNS>void</RETURNS>
GtkListItem            *self, gboolean                activatable
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_set_child</NAME>
<RETURNS>void</RETURNS>
GtkListItem            *self, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_item_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkListItem            *self
</FUNCTION>
<STRUCT>
<NAME>GtkListItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkListItemClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LIST_ITEM_FACTORY</NAME>
#define GTK_TYPE_LIST_ITEM_FACTORY         (gtk_list_item_factory_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_ITEM_FACTORY</NAME>
#define GTK_LIST_ITEM_FACTORY(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_LIST_ITEM_FACTORY, GtkListItemFactory))
</MACRO>
<MACRO>
<NAME>GTK_LIST_ITEM_FACTORY_CLASS</NAME>
#define GTK_LIST_ITEM_FACTORY_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_LIST_ITEM_FACTORY, GtkListItemFactoryClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_ITEM_FACTORY</NAME>
#define GTK_IS_LIST_ITEM_FACTORY(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_LIST_ITEM_FACTORY))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_ITEM_FACTORY_CLASS</NAME>
#define GTK_IS_LIST_ITEM_FACTORY_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_LIST_ITEM_FACTORY))
</MACRO>
<MACRO>
<NAME>GTK_LIST_ITEM_FACTORY_GET_CLASS</NAME>
#define GTK_LIST_ITEM_FACTORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_LIST_ITEM_FACTORY, GtkListItemFactoryClass))
</MACRO>
<FUNCTION>
<NAME>gtk_list_item_factory_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkListItemFactoryClass</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>
int           n_columns, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_newv</NAME>
<RETURNS>GtkListStore *</RETURNS>
int           n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_column_types</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, int           n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_value</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, int           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, int          *columns, GValue       *values, int           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, int           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, int           position, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_with_valuesv</NAME>
<RETURNS>void</RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, int           position, int          *columns, GValue       *values, int           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, int          *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_LIST_VIEW</NAME>
#define GTK_TYPE_LIST_VIEW         (gtk_list_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LIST_VIEW</NAME>
#define GTK_LIST_VIEW(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_LIST_VIEW, GtkListView))
</MACRO>
<MACRO>
<NAME>GTK_LIST_VIEW_CLASS</NAME>
#define GTK_LIST_VIEW_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_LIST_VIEW, GtkListViewClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_VIEW</NAME>
#define GTK_IS_LIST_VIEW(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_LIST_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_IS_LIST_VIEW_CLASS</NAME>
#define GTK_IS_LIST_VIEW_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_LIST_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_LIST_VIEW_GET_CLASS</NAME>
#define GTK_LIST_VIEW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_LIST_VIEW, GtkListViewClass))
</MACRO>
<FUNCTION>
<NAME>gtk_list_view_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkSelectionModel      *model, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_get_model</NAME>
<RETURNS>GtkSelectionModel *</RETURNS>
GtkListView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_set_model</NAME>
<RETURNS>void</RETURNS>
GtkListView            *self, GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_set_factory</NAME>
<RETURNS>void</RETURNS>
GtkListView            *self, GtkListItemFactory     *factory
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_get_factory</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
GtkListView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_set_show_separators</NAME>
<RETURNS>void</RETURNS>
GtkListView            *self, gboolean                show_separators
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_get_show_separators</NAME>
<RETURNS>gboolean</RETURNS>
GtkListView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_set_single_click_activate</NAME>
<RETURNS>void</RETURNS>
GtkListView            *self, gboolean                single_click_activate
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_get_single_click_activate</NAME>
<RETURNS>gboolean</RETURNS>
GtkListView            *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_set_enable_rubberband</NAME>
<RETURNS>void</RETURNS>
GtkListView            *self, gboolean                enable_rubberband
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_view_get_enable_rubberband</NAME>
<RETURNS>gboolean</RETURNS>
GtkListView            *self
</FUNCTION>
<STRUCT>
<NAME>GtkListView</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkListViewClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkListView</NAME>
struct _GtkListView
{
  GtkListBase parent_instance;

  GtkListItemManager *item_manager;
  gboolean show_separators;

  int list_width;
};
</STRUCT>
<STRUCT>
<NAME>GtkListViewClass</NAME>
struct _GtkListViewClass
{
  GtkListBaseClass parent_class;
};
</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_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>
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, int             code, const char     *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_error_valist</NAME>
<RETURNS>void</RETURNS>
GtkMediaStream *self, GQuark          domain, int             code, const char     *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_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_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 char     *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_new_with_markup</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWindow      *parent, GtkDialogFlags  flags, GtkMessageType  type, GtkButtonsType  buttons, const char     *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_set_markup</NAME>
<RETURNS>void</RETURNS>
GtkMessageDialog *message_dialog, const char       *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_format_secondary_text</NAME>
<RETURNS>void</RETURNS>
GtkMessageDialog *message_dialog, const char       *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_format_secondary_markup</NAME>
<RETURNS>void</RETURNS>
GtkMessageDialog *message_dialog, const char       *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_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_MULTI_FILTER</NAME>
#define GTK_TYPE_MULTI_FILTER             (gtk_multi_filter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_multi_filter_append</NAME>
<RETURNS>void</RETURNS>
GtkMultiFilter         *self, GtkFilter              *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_multi_filter_remove</NAME>
<RETURNS>void</RETURNS>
GtkMultiFilter         *self, guint                   position
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ANY_FILTER</NAME>
#define GTK_TYPE_ANY_FILTER             (gtk_any_filter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_any_filter_new</NAME>
<RETURNS>GtkAnyFilter *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_EVERY_FILTER</NAME>
#define GTK_TYPE_EVERY_FILTER             (gtk_every_filter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_every_filter_new</NAME>
<RETURNS>GtkEveryFilter *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkAnyFilter</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEveryFilter</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkMultiFilter</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MULTI_SELECTION</NAME>
#define GTK_TYPE_MULTI_SELECTION (gtk_multi_selection_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_multi_selection_new</NAME>
<RETURNS>GtkMultiSelection *</RETURNS>
GListModel           *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_multi_selection_get_model</NAME>
<RETURNS>GListModel *</RETURNS>
GtkMultiSelection    *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_multi_selection_set_model</NAME>
<RETURNS>void</RETURNS>
GtkMultiSelection    *self, GListModel           *model
</FUNCTION>
<STRUCT>
<NAME>GtkMultiSelection</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MULTI_SORTER</NAME>
#define GTK_TYPE_MULTI_SORTER             (gtk_multi_sorter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_multi_sorter_new</NAME>
<RETURNS>GtkMultiSorter *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_multi_sorter_append</NAME>
<RETURNS>void</RETURNS>
GtkMultiSorter         *self, GtkSorter              *sorter
</FUNCTION>
<FUNCTION>
<NAME>gtk_multi_sorter_remove</NAME>
<RETURNS>void</RETURNS>
GtkMultiSorter         *self, guint                   position
</FUNCTION>
<STRUCT>
<NAME>GtkMultiSorter</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NATIVE</NAME>
#define GTK_TYPE_NATIVE               (gtk_native_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_native_realize</NAME>
<RETURNS>void</RETURNS>
GtkNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_unrealize</NAME>
<RETURNS>void</RETURNS>
GtkNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_get_for_surface</NAME>
<RETURNS>GtkNative *</RETURNS>
GdkSurface *surface
</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>
<STRUCT>
<NAME>GtkNativeInterface</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
{
  /*< private >*/
  GObjectClass parent_class;

  /*< public >*/
  void (* response) (GtkNativeDialog *self, int 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>
<FUNCTION>
<NAME>gtk_no_selection_set_model</NAME>
<RETURNS>void</RETURNS>
GtkNoSelection         *self, GListModel             *model
</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>int</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_append_page_menu</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prepend_page</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prepend_page_menu</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_insert_page</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, int          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_insert_page_menu</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label, int          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_remove_page</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, int          page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_group_name</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, const char  *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_group_name</NAME>
<RETURNS>const char *</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_current_page</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_nth_page</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkNotebook *notebook, int          page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_n_pages</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_num</NAME>
<RETURNS>int</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_current_page</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, int          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 char  *tab_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_label_text</NAME>
<RETURNS>const char *</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 char  *menu_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_menu_label_text</NAME>
<RETURNS>const char *</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_reorder_child</NAME>
<RETURNS>void</RETURNS>
GtkNotebook *notebook, GtkWidget   *child, int          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_NUMERIC_SORTER</NAME>
#define GTK_TYPE_NUMERIC_SORTER             (gtk_numeric_sorter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_numeric_sorter_new</NAME>
<RETURNS>GtkNumericSorter *</RETURNS>
GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_numeric_sorter_get_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkNumericSorter       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_numeric_sorter_set_expression</NAME>
<RETURNS>void</RETURNS>
GtkNumericSorter       *self, GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_numeric_sorter_get_sort_order</NAME>
<RETURNS>GtkSortType</RETURNS>
GtkNumericSorter       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_numeric_sorter_set_sort_order</NAME>
<RETURNS>void</RETURNS>
GtkNumericSorter       *self, GtkSortType             sort_order
</FUNCTION>
<STRUCT>
<NAME>GtkNumericSorter</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, int                      n_entries
</FUNCTION>
<FUNCTION>
<NAME>gtk_pad_controller_set_action</NAME>
<RETURNS>void</RETURNS>
GtkPadController *controller, GtkPadActionType  type, int               index, int               mode, const char       *label, const char       *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>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_top_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, double              margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_bottom_margin</NAME>
<RETURNS>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_bottom_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, double              margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_left_margin</NAME>
<RETURNS>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_left_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, double              margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_right_margin</NAME>
<RETURNS>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_right_margin</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup       *setup, double              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>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_paper_height</NAME>
<RETURNS>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_page_width</NAME>
<RETURNS>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_page_height</NAME>
<RETURNS>double</RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new_from_file</NAME>
<RETURNS>GtkPageSetup *</RETURNS>
const char          *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 char          *group_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_load_key_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPageSetup        *setup, GKeyFile            *key_file, const char          *group_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_to_key_file</NAME>
<RETURNS>void</RETURNS>
GtkPageSetup        *setup, GKeyFile            *key_file, const char          *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 char             *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>int</RETURNS>
GtkPaned       *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_position</NAME>
<RETURNS>void</RETURNS>
GtkPaned       *paned, int             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>
<MACRO>
<NAME>GTK_TYPE_PANED_HANDLE</NAME>
#define GTK_TYPE_PANED_HANDLE                 (gtk_paned_handle_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PANED_HANDLE</NAME>
#define GTK_PANED_HANDLE(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PANED_HANDLE, GtkPanedHandle))
</MACRO>
<MACRO>
<NAME>GTK_PANED_HANDLE_CLASS</NAME>
#define GTK_PANED_HANDLE_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PANED_HANDLE, GtkPanedHandleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PANED_HANDLE</NAME>
#define GTK_IS_PANED_HANDLE(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PANED_HANDLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_PANED_HANDLE_CLASS</NAME>
#define GTK_IS_PANED_HANDLE_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PANED_HANDLE))
</MACRO>
<MACRO>
<NAME>GTK_PANED_HANDLE_GET_CLASS</NAME>
#define GTK_PANED_HANDLE_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PANED_HANDLE, GtkPanedHandleClass))
</MACRO>
<STRUCT>
<NAME>GtkPanedHandle</NAME>
struct _GtkPanedHandle
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkPanedHandleClass</NAME>
struct _GtkPanedHandleClass
{
  GtkWidgetClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_paned_handle_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_handle_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</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 char   *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_ppd</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
const char   *ppd_name, const char   *ppd_display_name, double        width, double        height
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_ipp</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
const char   *ipp_name, double        width, double        height
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_custom</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
const char   *name, const char   *display_name, double        width, double        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 char *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_display_name</NAME>
<RETURNS>const char *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_ppd_name</NAME>
<RETURNS>const char *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_width</NAME>
<RETURNS>double</RETURNS>
GtkPaperSize *size, GtkUnit unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_height</NAME>
<RETURNS>double</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, double        width, double        height, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_top_margin</NAME>
<RETURNS>double</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_bottom_margin</NAME>
<RETURNS>double</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_left_margin</NAME>
<RETURNS>double</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_right_margin</NAME>
<RETURNS>double</RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default</NAME>
<RETURNS>const char *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_key_file</NAME>
<RETURNS>GtkPaperSize *</RETURNS>
GKeyFile    *key_file, const char *group_name, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_to_key_file</NAME>
<RETURNS>void</RETURNS>
GtkPaperSize *size, GKeyFile     *key_file, const char   *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>
<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>GtkPasswordEntry</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPasswordEntryClass</NAME>
</STRUCT>
<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 char             *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_new_for_resource</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char             *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 char             *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_picture_set_resource</NAME>
<RETURNS>void</RETURNS>
GtkPicture             *self, const char             *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_offset</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover, int         x_offset, int         y_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_offset</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover, int        *x_offset, int        *y_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_cascade_popdown</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover, gboolean    cascade_popdown
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_cascade_popdown</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopover *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_default_widget</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover, GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_present</NAME>
<RETURNS>void</RETURNS>
GtkPopover *popover
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_POPOVER_CONTENT</NAME>
#define GTK_TYPE_POPOVER_CONTENT                 (gtk_popover_content_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_CONTENT</NAME>
#define GTK_POPOVER_CONTENT(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_POPOVER_CONTENT, GtkPopoverContent))
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_CONTENT_CLASS</NAME>
#define GTK_POPOVER_CONTENT_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_POPOVER_CONTENT, GtkPopoverContentClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER_CONTENT</NAME>
#define GTK_IS_POPOVER_CONTENT(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_POPOVER_CONTENT))
</MACRO>
<MACRO>
<NAME>GTK_IS_POPOVER_CONTENT_CLASS</NAME>
#define GTK_IS_POPOVER_CONTENT_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_POPOVER_CONTENT))
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_CONTENT_GET_CLASS</NAME>
#define GTK_POPOVER_CONTENT_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_POPOVER_CONTENT, GtkPopoverContentClass))
</MACRO>
<STRUCT>
<NAME>GtkPopoverContent</NAME>
struct _GtkPopoverContent
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkPopoverContentClass</NAME>
struct _GtkPopoverContentClass
{
  GtkWidgetClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_popover_content_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_content_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</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>
<FUNCTION>
<NAME>gtk_popover_menu_add_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopoverMenu *popover, GtkWidget      *child, const char     *id
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_remove_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopoverMenu *popover, GtkWidget      *child
</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>
<FUNCTION>
<NAME>gtk_popover_menu_bar_add_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopoverMenuBar *bar, GtkWidget         *child, const char        *id
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_bar_remove_child</NAME>
<RETURNS>gboolean</RETURNS>
GtkPopoverMenuBar *bar, GtkWidget         *child
</FUNCTION>
<STRUCT>
<NAME>GtkPopoverMenuBar</NAME>
</STRUCT>
<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_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>double</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_height</NAME>
<RETURNS>double</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_dpi_x</NAME>
<RETURNS>double</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_dpi_y</NAME>
<RETURNS>double</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_hard_margins</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintContext *context, double          *top, double          *bottom, double          *left, double          *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 char      *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 char *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_state_message</NAME>
<RETURNS>const char *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_description</NAME>
<RETURNS>const char *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_location</NAME>
<RETURNS>const char *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_icon_name</NAME>
<RETURNS>const char *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_job_count</NAME>
<RETURNS>int</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>int</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, double           *top, double           *bottom, double           *left, double           *right
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_hard_margins_for_paper_size</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrinter       *printer, GtkPaperSize     *paper_size, double           *top, double           *bottom, double           *left, double           *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, const char           **choices, const 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 char *</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 char               *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 char *</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 char               *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, int               *n_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_page_ranges</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, GtkPageRange      *ranges, int                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>int</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_num_copies</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, int                num_copies
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_get_scale</NAME>
<RETURNS>double</RETURNS>
GtkPrintJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_job_set_scale</NAME>
<RETURNS>void</RETURNS>
GtkPrintJob       *job, double             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>
<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,
                                  int                page_nr,
                                  GtkPageSetup      *setup);
  void     (*draw_page)          (GtkPrintOperation *operation,
                                  GtkPrintContext   *context,
                                  int                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 char         *job_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_n_pages</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, int                 n_pages
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_set_current_page</NAME>
<RETURNS>void</RETURNS>
GtkPrintOperation  *op, int                 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 char         *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 char         *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 char *</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>int</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,
				       int                       page_nr);
  gboolean          (*is_selected)    (GtkPrintOperationPreview *preview,
				       int                       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, int                       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, int                       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 char *key, const char *value, gpointer     user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkPageRange</NAME>
struct _GtkPageRange
{
  int start;
  int 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 char           *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_load_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, const char           *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, const char           *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new_from_key_file</NAME>
<RETURNS>GtkPrintSettings *</RETURNS>
GKeyFile             *key_file, const char           *group_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_load_key_file</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, GKeyFile             *key_file, const char           *group_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_key_file</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, GKeyFile             *key_file, const char           *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_has_key</NAME>
<RETURNS>gboolean</RETURNS>
GtkPrintSettings     *settings, const char           *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get</NAME>
<RETURNS>const char *</RETURNS>
GtkPrintSettings     *settings, const char           *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const char           *key, const char           *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_unset</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const char           *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 char           *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_bool</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const char           *key, gboolean              value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_double</NAME>
<RETURNS>double</RETURNS>
GtkPrintSettings     *settings, const char           *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_double_with_default</NAME>
<RETURNS>double</RETURNS>
GtkPrintSettings     *settings, const char           *key, double                def
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_double</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const char           *key, double                value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_length</NAME>
<RETURNS>double</RETURNS>
GtkPrintSettings     *settings, const char           *key, GtkUnit               unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_length</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const char           *key, double                value, GtkUnit               unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_int</NAME>
<RETURNS>int</RETURNS>
GtkPrintSettings     *settings, const char           *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_int_with_default</NAME>
<RETURNS>int</RETURNS>
GtkPrintSettings     *settings, const char           *key, int                   def
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_int</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings     *settings, const char           *key, int                   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 char *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_printer</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const char         *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>double</RETURNS>
GtkPrintSettings   *settings, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_width</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, double              width, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_paper_height</NAME>
<RETURNS>double</RETURNS>
GtkPrintSettings   *settings, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_height</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, double              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>int</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_n_copies</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, int                 num_copies
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_number_up</NAME>
<RETURNS>int</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_number_up</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, int                 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>int</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_resolution</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, int                 resolution
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution_x</NAME>
<RETURNS>int</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution_y</NAME>
<RETURNS>int</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_resolution_xy</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, int                 resolution_x, int                 resolution_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_printer_lpi</NAME>
<RETURNS>double</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_printer_lpi</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, double              lpi
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_scale</NAME>
<RETURNS>double</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_scale</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, double              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, int                *num_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_page_ranges</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, GtkPageRange       *page_ranges, int                 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 char *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_default_source</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const char         *default_source
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_media_type</NAME>
<RETURNS>const char *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_media_type</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const char         *media_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_dither</NAME>
<RETURNS>const char *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_dither</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const char         *dither
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_finishings</NAME>
<RETURNS>const char *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_finishings</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const char         *finishings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_output_bin</NAME>
<RETURNS>const char *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_output_bin</NAME>
<RETURNS>void</RETURNS>
GtkPrintSettings   *settings, const char         *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 char *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, int                 current_page
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_current_page</NAME>
<RETURNS>int</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>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 char     *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_fraction</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar *pbar, double          fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_pulse_step</NAME>
<RETURNS>void</RETURNS>
GtkProgressBar *pbar, double          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 char *</RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_fraction</NAME>
<RETURNS>double</RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_pulse_step</NAME>
<RETURNS>double</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_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,
                             double	   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,
                             double        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, int           *slider_start, int           *slider_end
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_increments</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, double         step, double         page
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_range</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, double         min, double         max
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_value</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, double         value
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_value</NAME>
<RETURNS>double</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, double         fill_level
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_fill_level</NAME>
<RETURNS>double</RETURNS>
GtkRange      *range
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_set_round_digits</NAME>
<RETURNS>void</RETURNS>
GtkRange      *range, int            round_digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_range_get_round_digits</NAME>
<RETURNS>int</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
{
  char *display_name;
  char *description;

  char *mime_type;

  char *app_name;
  char *app_exec;

  char **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 char           *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_add_full</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const char           *uri, const GtkRecentData  *recent_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_remove_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const char           *uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_lookup_item</NAME>
<RETURNS>GtkRecentInfo *</RETURNS>
GtkRecentManager     *manager, const char           *uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_has_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const char           *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_move_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentManager     *manager, const char           *uri, const char           *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>int</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 char *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_display_name</NAME>
<RETURNS>const char *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_description</NAME>
<RETURNS>const char *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_mime_type</NAME>
<RETURNS>const char *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_added</NAME>
<RETURNS>GDateTime *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_modified</NAME>
<RETURNS>GDateTime *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_visited</NAME>
<RETURNS>GDateTime *</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 char     *app_name, const char    **app_exec, guint          *count, GDateTime     **stamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_create_app_info</NAME>
<RETURNS>GAppInfo *</RETURNS>
GtkRecentInfo  *info, const char     *app_name, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_applications</NAME>
<RETURNS>char **</RETURNS>
GtkRecentInfo  *info, gsize          *length
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_last_application</NAME>
<RETURNS>char *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_has_application</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info, const char     *app_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_groups</NAME>
<RETURNS>char **</RETURNS>
GtkRecentInfo  *info, gsize          *length
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_has_group</NAME>
<RETURNS>gboolean</RETURNS>
GtkRecentInfo  *info, const char     *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>char *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_uri_display</NAME>
<RETURNS>char *</RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_age</NAME>
<RETURNS>int</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, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_option</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_arrow</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               angle, double               x, double               y, double               size
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_background</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_frame</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_expander</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_focus</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_layout</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, PangoLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_line</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x0, double               y0, double               x1, double               y1
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_handle</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_activity</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, double               x, double               y, double               width, double               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_icon</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext     *context, cairo_t             *cr, GdkTexture          *texture, double               x, double               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>
<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,
                               int      *x,
                               int      *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, double           min, double           max, double           step
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_digits</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, int              digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_digits</NAME>
<RETURNS>int</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, int             *x, int             *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_add_mark</NAME>
<RETURNS>void</RETURNS>
GtkScale        *scale, double           value, GtkPositionType  position, const char      *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
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleButtonClass</NAME>
struct _GtkScaleButtonClass
{
  GtkWidgetClass parent_class;

  /* signals */
  void	(* value_changed) (GtkScaleButton *button,
                           double          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>
double           min, double           max, double           step, const char     **icons
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_set_icons</NAME>
<RETURNS>void</RETURNS>
GtkScaleButton  *button, const char     **icons
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_get_value</NAME>
<RETURNS>double</RETURNS>
GtkScaleButton  *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_button_set_value</NAME>
<RETURNS>void</RETURNS>
GtkScaleButton  *button, double           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>
void
</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>int</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_min_content_width</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, int                width
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_min_content_height</NAME>
<RETURNS>int</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_min_content_height</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, int                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_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, int                width
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_max_content_width</NAME>
<RETURNS>int</RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_max_content_height</NAME>
<RETURNS>void</RETURNS>
GtkScrolledWindow *scrolled_window, int                height
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_max_content_height</NAME>
<RETURNS>int</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_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_FILTER_MODEL</NAME>
#define GTK_TYPE_SELECTION_FILTER_MODEL (gtk_selection_filter_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_selection_filter_model_new</NAME>
<RETURNS>GtkSelectionFilterModel *</RETURNS>
GtkSelectionModel           *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_filter_model_set_model</NAME>
<RETURNS>void</RETURNS>
GtkSelectionFilterModel     *self, GtkSelectionModel           *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_filter_model_get_model</NAME>
<RETURNS>GtkSelectionModel *</RETURNS>
GtkSelectionFilterModel     *self
</FUNCTION>
<STRUCT>
<NAME>GtkSelectionFilterModel</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);
  GtkBitset *           (* get_selection_in_range)              (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                   n_items);

  gboolean              (* select_item)                         (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 gboolean                unselect_rest);
  gboolean              (* unselect_item)                       (GtkSelectionModel      *model,
                                                                 guint                   position);
  gboolean              (* select_range)                        (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                   n_items,
                                                                 gboolean                unselect_rest);
  gboolean              (* unselect_range)                      (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                   n_items);
  gboolean              (* select_all)                          (GtkSelectionModel      *model);
  gboolean              (* unselect_all)                        (GtkSelectionModel      *model);
  gboolean              (* set_selection)                       (GtkSelectionModel      *model,
                                                                 GtkBitset              *selected,
                                                                 GtkBitset              *mask);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_selection_model_is_selected</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_get_selection</NAME>
<RETURNS>GtkBitset *</RETURNS>
GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_get_selection_in_range</NAME>
<RETURNS>GtkBitset *</RETURNS>
GtkSelectionModel      *model, guint                   position, guint                   n_items
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_select_item</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, guint                   position, gboolean                unselect_rest
</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                unselect_rest
</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_set_selection</NAME>
<RETURNS>gboolean</RETURNS>
GtkSelectionModel      *model, GtkBitset              *selected, GtkBitset              *mask
</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
   */
  char *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 char             *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 char             *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>
<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>
<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 char       *accelerator
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_get_accelerator</NAME>
<RETURNS>const char *</RETURNS>
GtkShortcutLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_set_accelerator</NAME>
<RETURNS>void</RETURNS>
GtkShortcutLabel *self, const char       *accelerator
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_get_disabled_text</NAME>
<RETURNS>const char *</RETURNS>
GtkShortcutLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_set_disabled_text</NAME>
<RETURNS>void</RETURNS>
GtkShortcutLabel *self, const char       *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>
<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>
<FUNCTION>
<NAME>gtk_shortcuts_window_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutsWindow</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>int</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_SIGNAL_LIST_ITEM_FACTORY</NAME>
#define GTK_TYPE_SIGNAL_LIST_ITEM_FACTORY         (gtk_signal_list_item_factory_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SIGNAL_LIST_ITEM_FACTORY</NAME>
#define GTK_SIGNAL_LIST_ITEM_FACTORY(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_SIGNAL_LIST_ITEM_FACTORY, GtkSignalListItemFactory))
</MACRO>
<MACRO>
<NAME>GTK_SIGNAL_LIST_ITEM_FACTORY_CLASS</NAME>
#define GTK_SIGNAL_LIST_ITEM_FACTORY_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_SIGNAL_LIST_ITEM_FACTORY, GtkSignalListItemFactoryClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SIGNAL_LIST_ITEM_FACTORY</NAME>
#define GTK_IS_SIGNAL_LIST_ITEM_FACTORY(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_SIGNAL_LIST_ITEM_FACTORY))
</MACRO>
<MACRO>
<NAME>GTK_IS_SIGNAL_LIST_ITEM_FACTORY_CLASS</NAME>
#define GTK_IS_SIGNAL_LIST_ITEM_FACTORY_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_SIGNAL_LIST_ITEM_FACTORY))
</MACRO>
<MACRO>
<NAME>GTK_SIGNAL_LIST_ITEM_FACTORY_GET_CLASS</NAME>
#define GTK_SIGNAL_LIST_ITEM_FACTORY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_SIGNAL_LIST_ITEM_FACTORY, GtkSignalListItemFactoryClass))
</MACRO>
<FUNCTION>
<NAME>gtk_signal_list_item_factory_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_signal_list_item_factory_new</NAME>
<RETURNS>GtkListItemFactory *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkSignalListItemFactory</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSignalListItemFactoryClass</NAME>
</STRUCT>
<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_set_model</NAME>
<RETURNS>void</RETURNS>
GtkSingleSelection     *self, GListModel             *model
</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;
  int      minimum_size;
  int      natural_size;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_distribute_natural_allocation</NAME>
<RETURNS>int</RETURNS>
int               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_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_push_gl_shader</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GskGLShader            *shader, const graphene_rect_t  *bounds, GBytes                 *take_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_gl_shader_pop_texture</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot
</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_radial_gradient</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_point_t *center, float                   hradius, float                   vradius, float                   start, float                   end, const GskColorStop     *stops, gsize                   n_stops
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_repeating_radial_gradient</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_point_t *center, float                   hradius, float                   vradius, float                   start, float                   end, const GskColorStop     *stops, gsize                   n_stops
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_conic_gradient</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_point_t *center, float                   rotation, 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, double                  x, double                  y, double                  width, double                  height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_frame</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, double                  x, double                  y, double                  width, double                  height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_focus</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, double                  x, double                  y, double                  width, double                  height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_layout</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, double                  x, double                  y, PangoLayout            *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_insertion_cursor</NAME>
<RETURNS>void</RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, double                  x, double                  y, PangoLayout            *layout, int                     index, PangoDirection          direction
</FUNCTION>
<STRUCT>
<NAME>GtkSnapshotClass</NAME>
</STRUCT>
<ENUM>
<NAME>GtkSorterOrder</NAME>
typedef enum {
  GTK_SORTER_ORDER_PARTIAL,
  GTK_SORTER_ORDER_NONE,
  GTK_SORTER_ORDER_TOTAL
} GtkSorterOrder;
</ENUM>
<ENUM>
<NAME>GtkSorterChange</NAME>
typedef enum {
  GTK_SORTER_CHANGE_DIFFERENT,
  GTK_SORTER_CHANGE_INVERTED,
  GTK_SORTER_CHANGE_LESS_STRICT,
  GTK_SORTER_CHANGE_MORE_STRICT
} GtkSorterChange;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_SORTER</NAME>
#define GTK_TYPE_SORTER             (gtk_sorter_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkSorterClass</NAME>
struct _GtkSorterClass
{
  GObjectClass parent_class;

  GtkOrdering           (* compare)                             (GtkSorter              *self,
                                                                 gpointer                item1,
                                                                 gpointer                item2);

  /* optional */
  GtkSorterOrder        (* get_order)                           (GtkSorter              *self);

  /* 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_sorter_compare</NAME>
<RETURNS>GtkOrdering</RETURNS>
GtkSorter              *self, gpointer                item1, gpointer                item2
</FUNCTION>
<FUNCTION>
<NAME>gtk_sorter_get_order</NAME>
<RETURNS>GtkSorterOrder</RETURNS>
GtkSorter              *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_sorter_changed</NAME>
<RETURNS>void</RETURNS>
GtkSorter              *self, GtkSorterChange         change
</FUNCTION>
<STRUCT>
<NAME>GtkSorter</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, GtkSorter             *sorter
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_set_sorter</NAME>
<RETURNS>void</RETURNS>
GtkSortListModel       *self, GtkSorter              *sorter
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_get_sorter</NAME>
<RETURNS>GtkSorter *</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_set_incremental</NAME>
<RETURNS>void</RETURNS>
GtkSortListModel       *self, gboolean                incremental
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_get_incremental</NAME>
<RETURNS>gboolean</RETURNS>
GtkSortListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_get_pending</NAME>
<RETURNS>guint</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, double          climb_rate, guint           digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkAdjustment  *adjustment, double          climb_rate, guint           digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_new_with_range</NAME>
<RETURNS>GtkWidget *</RETURNS>
double   min, double   max, double   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, double          step, double          page
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_increments</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, double         *step, double         *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_range</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, double          min, double          max
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_range</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, double         *min, double         *max
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_value</NAME>
<RETURNS>double</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_value_as_int</NAME>
<RETURNS>int</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_value</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, double          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, double          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_set_climb_rate</NAME>
<RETURNS>void</RETURNS>
GtkSpinButton  *spin_button, double          climb_rate
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_climb_rate</NAME>
<RETURNS>double</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           *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_visible</NAME>
<RETURNS>gboolean</RETURNS>
GtkStackPage           *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_set_visible</NAME>
<RETURNS>void</RETURNS>
GtkStackPage           *self, gboolean                visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_needs_attention</NAME>
<RETURNS>gboolean</RETURNS>
GtkStackPage           *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_set_needs_attention</NAME>
<RETURNS>void</RETURNS>
GtkStackPage           *self, gboolean                setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_use_underline</NAME>
<RETURNS>gboolean</RETURNS>
GtkStackPage           *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_set_use_underline</NAME>
<RETURNS>void</RETURNS>
GtkStackPage           *self, gboolean                setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_name</NAME>
<RETURNS>const char *</RETURNS>
GtkStackPage           *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_set_name</NAME>
<RETURNS>void</RETURNS>
GtkStackPage           *self, const char            *setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_title</NAME>
<RETURNS>const char *</RETURNS>
GtkStackPage           *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_set_title</NAME>
<RETURNS>void</RETURNS>
GtkStackPage           *self, const char             *setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_icon_name</NAME>
<RETURNS>const char *</RETURNS>
GtkStackPage           *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_set_icon_name</NAME>
<RETURNS>void</RETURNS>
GtkStackPage           *self, const char             *setting
</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_child</NAME>
<RETURNS>GtkStackPage *</RETURNS>
GtkStack               *stack, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_add_named</NAME>
<RETURNS>GtkStackPage *</RETURNS>
GtkStack               *stack, GtkWidget              *child, const char             *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_add_titled</NAME>
<RETURNS>GtkStackPage *</RETURNS>
GtkStack               *stack, GtkWidget              *child, const char             *name, const char             *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 char             *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 char             *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_visible_child_name</NAME>
<RETURNS>const char *</RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_visible_child_full</NAME>
<RETURNS>void</RETURNS>
GtkStack               *stack, const char             *name, GtkStackTransitionType  transition
</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 char   *context_description
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_push</NAME>
<RETURNS>guint</RETURNS>
GtkStatusbar *statusbar, guint	       context_id, const char   *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>
<ENUM>
<NAME>GtkStringFilterMatchMode</NAME>
typedef enum {
  GTK_STRING_FILTER_MATCH_MODE_EXACT,
  GTK_STRING_FILTER_MATCH_MODE_SUBSTRING,
  GTK_STRING_FILTER_MATCH_MODE_PREFIX
} GtkStringFilterMatchMode;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_STRING_FILTER</NAME>
#define GTK_TYPE_STRING_FILTER             (gtk_string_filter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_string_filter_new</NAME>
<RETURNS>GtkStringFilter *</RETURNS>
GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_get_search</NAME>
<RETURNS>const char *</RETURNS>
GtkStringFilter        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_set_search</NAME>
<RETURNS>void</RETURNS>
GtkStringFilter        *self, const char             *search
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_get_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkStringFilter        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_set_expression</NAME>
<RETURNS>void</RETURNS>
GtkStringFilter        *self, GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_get_ignore_case</NAME>
<RETURNS>gboolean</RETURNS>
GtkStringFilter        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_set_ignore_case</NAME>
<RETURNS>void</RETURNS>
GtkStringFilter        *self, gboolean                ignore_case
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_get_match_mode</NAME>
<RETURNS>GtkStringFilterMatchMode</RETURNS>
GtkStringFilter        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_filter_set_match_mode</NAME>
<RETURNS>void</RETURNS>
GtkStringFilter        *self, GtkStringFilterMatchMode mode
</FUNCTION>
<STRUCT>
<NAME>GtkStringFilter</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_STRING_OBJECT</NAME>
#define GTK_TYPE_STRING_OBJECT (gtk_string_object_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_string_object_new</NAME>
<RETURNS>GtkStringObject *</RETURNS>
const char      *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_object_get_string</NAME>
<RETURNS>const char *</RETURNS>
GtkStringObject *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_STRING_LIST</NAME>
#define GTK_TYPE_STRING_LIST (gtk_string_list_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_string_list_new</NAME>
<RETURNS>GtkStringList *</RETURNS>
const char * const    *strings
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_list_append</NAME>
<RETURNS>void</RETURNS>
GtkStringList         *self, const char            *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_list_take</NAME>
<RETURNS>void</RETURNS>
GtkStringList         *self, char                  *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_list_remove</NAME>
<RETURNS>void</RETURNS>
GtkStringList         *self, guint                  position
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_list_splice</NAME>
<RETURNS>void</RETURNS>
GtkStringList         *self, guint                  position, guint                  n_removals, const char * const    *additions
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_list_get_string</NAME>
<RETURNS>const char *</RETURNS>
GtkStringList         *self, guint                  position
</FUNCTION>
<STRUCT>
<NAME>GtkStringList</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkStringObject</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_STRING_SORTER</NAME>
#define GTK_TYPE_STRING_SORTER             (gtk_string_sorter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_string_sorter_new</NAME>
<RETURNS>GtkStringSorter *</RETURNS>
GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_sorter_get_expression</NAME>
<RETURNS>GtkExpression *</RETURNS>
GtkStringSorter        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_sorter_set_expression</NAME>
<RETURNS>void</RETURNS>
GtkStringSorter        *self, GtkExpression          *expression
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_sorter_get_ignore_case</NAME>
<RETURNS>gboolean</RETURNS>
GtkStringSorter        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_string_sorter_set_ignore_case</NAME>
<RETURNS>void</RETURNS>
GtkStringSorter        *self, gboolean                ignore_case
</FUNCTION>
<STRUCT>
<NAME>GtkStringSorter</NAME>
</STRUCT>
<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>
<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, int              scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_scale</NAME>
<RETURNS>int</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_add_class</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, const char      *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_remove_class</NAME>
<RETURNS>void</RETURNS>
GtkStyleContext *context, const char      *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_has_class</NAME>
<RETURNS>gboolean</RETURNS>
GtkStyleContext *context, const char      *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 char      *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>
<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>
<MACRO>
<NAME>gtk_test_accessible_assert_role</NAME>
#define gtk_test_accessible_assert_role(accessible,role) \
G_STMT_START { \
  GtkAccessible *__a = GTK_ACCESSIBLE (accessible); \
  GtkAccessibleRole __r1 = (role); \
  GtkAccessibleRole __r2 = gtk_accessible_get_accessible_role (__a); \
  if (__r1 == __r2) ; else { \
    gtk_test_accessible_assertion_message_role (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
                                                #accessible ".accessible-role == " #role, \
                                                __a, __r1, __r2); \
  } \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>gtk_test_accessible_assert_property</NAME>
#define gtk_test_accessible_assert_property(accessible,property,...) \
G_STMT_START { \
  GtkAccessible *__a = GTK_ACCESSIBLE (accessible); \
  GtkAccessibleProperty __p = (property); \
  char *value__ = gtk_test_accessible_check_property (__a, __p, __VA_ARGS__); \
  if (value__ == NULL) ; else { \
    char *msg__ = g_strdup_printf ("assertion failed: (" #accessible ".accessible-property(" #property ") == " # __VA_ARGS__ "): value = '%s'", value__); \
    g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg__); \
    g_free (msg__); \
  } \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>gtk_test_accessible_assert_relation</NAME>
#define gtk_test_accessible_assert_relation(accessible,relation,...) \
G_STMT_START { \
  GtkAccessible *__a = GTK_ACCESSIBLE (accessible); \
  GtkAccessibleRelation __r = (relation); \
  char *value__ = gtk_test_accessible_check_relation (__a, __r, __VA_ARGS__); \
  if (value__ == NULL); else { \
    char *msg__ = g_strdup_printf ("assertion failed: (" #accessible ".accessible-relation(" #relation ") == " # __VA_ARGS__ "): value = '%s'", value__); \
    g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg__); \
    g_free (msg__); \
  } \
} G_STMT_END
</MACRO>
<MACRO>
<NAME>gtk_test_accessible_assert_state</NAME>
#define gtk_test_accessible_assert_state(accessible,state,...) \
G_STMT_START { \
  GtkAccessible *__a = GTK_ACCESSIBLE (accessible); \
  GtkAccessibleState __s = (state); \
  char *value__ = gtk_test_accessible_check_state (__a, __s, __VA_ARGS__); \
  if (value__ == NULL); else { \
    char *msg__ = g_strdup_printf ("assertion failed: (" #accessible ".accessible-state(" #state ") == " # __VA_ARGS__ "): value = '%s'", value__); \
    g_assertion_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg__); \
    g_free (msg__); \
  } \
} G_STMT_END
</MACRO>
<FUNCTION>
<NAME>gtk_test_accessible_has_role</NAME>
<RETURNS>gboolean</RETURNS>
GtkAccessible         *accessible, GtkAccessibleRole      role
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_accessible_has_property</NAME>
<RETURNS>gboolean</RETURNS>
GtkAccessible         *accessible, GtkAccessibleProperty  property
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_accessible_has_relation</NAME>
<RETURNS>gboolean</RETURNS>
GtkAccessible         *accessible, GtkAccessibleRelation  relation
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_accessible_has_state</NAME>
<RETURNS>gboolean</RETURNS>
GtkAccessible         *accessible, GtkAccessibleState     state
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_accessible_check_property</NAME>
<RETURNS>char *</RETURNS>
GtkAccessible         *accessible, GtkAccessibleProperty  property, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_accessible_check_relation</NAME>
<RETURNS>char *</RETURNS>
GtkAccessible         *accessible, GtkAccessibleRelation  relation, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_accessible_check_state</NAME>
<RETURNS>char *</RETURNS>
GtkAccessible         *accessible, GtkAccessibleState     state, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_test_accessible_assertion_message_role</NAME>
<RETURNS>void</RETURNS>
const char        *domain, const char        *file, int                line, const char        *func, const char        *expr, GtkAccessible     *accessible, GtkAccessibleRole  expected_role, GtkAccessibleRole  actual_role
</FUNCTION>
<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>int</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>
<FUNCTION>
<NAME>gtk_text_set_enable_emoji_completion</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, gboolean         enable_emoji_completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_enable_emoji_completion</NAME>
<RETURNS>gboolean</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_propagate_text_width</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, gboolean         propagate_text_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_propagate_text_width</NAME>
<RETURNS>gboolean</RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_truncate_multiline</NAME>
<RETURNS>void</RETURNS>
GtkText         *self, gboolean         truncate_multiline
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_truncate_multiline</NAME>
<RETURNS>gboolean</RETURNS>
GtkText         *self
</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;
  int height;
  int top_ink : 16;
  int 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>
<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 char         *new_text,
                                   int                 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>int</RETURNS>
GtkTextBuffer   *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_char_count</NAME>
<RETURNS>int</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 char    *text, int            len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, const char    *text, int            len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_at_cursor</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, const char    *text, int            len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_interactive</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, const char    *text, int            len, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_interactive_at_cursor</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, const char    *text, int            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 char        *text, int                len, GtkTextTag        *first_tag, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_with_tags_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const char        *text, int                len, const char        *first_tag_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_markup</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const char        *markup, int                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>char *</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *start, const GtkTextIter *end, gboolean           include_hidden_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_slice</NAME>
<RETURNS>char *</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 char        *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 char        *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_move_mark_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const char        *name, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_mark_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const char        *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 char        *name, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_tag_by_name</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer     *buffer, const char        *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 char    *tag_name, const char    *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line_offset</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, int            line_number, int            char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line_index</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, int            line_number, int            byte_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, int            char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, int            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;
  int dummy3;
  int dummy4;
  int dummy5;
  int dummy6;
  int dummy7;
  int dummy8;
  gpointer dummy9;
  gpointer dummy10;
  int dummy11;
  int dummy12;
  /* padding */
  int 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>int</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line</NAME>
<RETURNS>int</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line_offset</NAME>
<RETURNS>int</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line_index</NAME>
<RETURNS>int</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_line_offset</NAME>
<RETURNS>int</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_line_index</NAME>
<RETURNS>int</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>char *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_text</NAME>
<RETURNS>char *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_slice</NAME>
<RETURNS>char *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_text</NAME>
<RETURNS>char *</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>int</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_bytes_in_line</NAME>
<RETURNS>int</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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_chars</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_lines</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_word_starts</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_lines</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_word_starts</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_sentence_starts</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_cursor_positions</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          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, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_cursor_positions</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextIter *iter, int          count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, int          char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, int          line_number
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line_offset</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, int          char_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line_index</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, int          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, int          char_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_visible_line_index</NAME>
<RETURNS>void</RETURNS>
GtkTextIter *iter, int          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 char        *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 char        *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>int</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 char *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 char *</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_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 char        *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_get_priority</NAME>
<RETURNS>int</RETURNS>
GtkTextTag        *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_set_priority</NAME>
<RETURNS>void</RETURNS>
GtkTextTag        *tag, int                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 char             *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>int</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 char *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_byte_begins_utf8_char</NAME>
<RETURNS>gboolean</RETURNS>
const char *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>
<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,
                                  int               count,
                                  gboolean          extend_selection);
  void (* set_anchor)            (GtkTextView      *text_view);
  void (* insert_at_cursor)      (GtkTextView      *text_view,
                                  const char       *str);
  void (* delete_from_cursor)    (GtkTextView      *text_view,
                                  GtkDeleteType     type,
                                  int               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, double         within_margin, gboolean       use_align, double         xalign, double         yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_scroll_to_mark</NAME>
<RETURNS>void</RETURNS>
GtkTextView   *text_view, GtkTextMark   *mark, double         within_margin, gboolean       use_align, double         xalign, double         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, int            x, int            y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_iter_at_position</NAME>
<RETURNS>gboolean</RETURNS>
GtkTextView   *text_view, GtkTextIter   *iter, int           *trailing, int            x, int            y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_line_yrange</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, const GtkTextIter *iter, int               *y, int               *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_line_at_y</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, GtkTextIter       *target_iter, int                y, int               *line_top
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_buffer_to_window_coords</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, GtkTextWindowType  win, int                buffer_x, int                buffer_y, int               *window_x, int               *window_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_window_to_buffer_coords</NAME>
<RETURNS>void</RETURNS>
GtkTextView       *text_view, GtkTextWindowType  win, int                window_x, int                window_y, int               *buffer_x, int               *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, int                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, int                   xpos, int                   ypos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_move_overlay</NAME>
<RETURNS>void</RETURNS>
GtkTextView          *text_view, GtkWidget            *child, int                   xpos, int                   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, int               pixels_above_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_above_lines</NAME>
<RETURNS>int</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_below_lines</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, int               pixels_below_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_below_lines</NAME>
<RETURNS>int</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_inside_wrap</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, int               pixels_inside_wrap
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_inside_wrap</NAME>
<RETURNS>int</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, int               left_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_left_margin</NAME>
<RETURNS>int</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_right_margin</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, int               right_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_right_margin</NAME>
<RETURNS>int</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_top_margin</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, int               top_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_top_margin</NAME>
<RETURNS>int</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_bottom_margin</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, int               bottom_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_bottom_margin</NAME>
<RETURNS>int</RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_indent</NAME>
<RETURNS>void</RETURNS>
GtkTextView      *text_view, int               indent
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_indent</NAME>
<RETURNS>int</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_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 char      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *</RETURNS>
const char      *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>
<FUNCTION>
<NAME>gtk_toggle_button_set_group</NAME>
<RETURNS>void</RETURNS>
GtkToggleButton *toggle_button, GtkToggleButton *group
</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 char         *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_text</NAME>
<RETURNS>void</RETURNS>
GtkTooltip         *tooltip, const char         *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 char         *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>
<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_EXPANDER</NAME>
#define GTK_TYPE_TREE_EXPANDER         (gtk_tree_expander_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_tree_expander_new</NAME>
<RETURNS>GtkWidget *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_expander_get_child</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkTreeExpander        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_expander_set_child</NAME>
<RETURNS>void</RETURNS>
GtkTreeExpander        *self, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_expander_get_item</NAME>
<RETURNS>gpointer</RETURNS>
GtkTreeExpander        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_expander_get_list_row</NAME>
<RETURNS>GtkTreeListRow *</RETURNS>
GtkTreeExpander        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_expander_set_list_row</NAME>
<RETURNS>void</RETURNS>
GtkTreeExpander        *self, GtkTreeListRow         *list_row
</FUNCTION>
<STRUCT>
<NAME>GtkTreeExpander</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>
GListModel             *root, gboolean                passthrough, 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_LIST_ROW_SORTER</NAME>
#define GTK_TYPE_TREE_LIST_ROW_SORTER             (gtk_tree_list_row_sorter_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_tree_list_row_sorter_new</NAME>
<RETURNS>GtkTreeListRowSorter *</RETURNS>
GtkSorter            *sorter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_sorter_get_sorter</NAME>
<RETURNS>GtkSorter *</RETURNS>
GtkTreeListRowSorter *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_sorter_set_sorter</NAME>
<RETURNS>void</RETURNS>
GtkTreeListRowSorter *self, GtkSorter            *sorter
</FUNCTION>
<STRUCT>
<NAME>GtkTreeListRowSorter</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
{
  int 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,
					  int          *new_order);

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

  int          (* get_n_columns)   (GtkTreeModel *tree_model);
  GType        (* get_column_type) (GtkTreeModel *tree_model,
				    int           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,
				    int           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);
  int          (* iter_n_children) (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gboolean     (* iter_nth_child)  (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreeIter  *parent,
				    int           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 char        *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_new_from_indices</NAME>
<RETURNS>GtkTreePath *</RETURNS>
int                first_index, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_new_from_indicesv</NAME>
<RETURNS>GtkTreePath *</RETURNS>
int              *indices, gsize             length
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_to_string</NAME>
<RETURNS>char *</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, int                index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_prepend_index</NAME>
<RETURNS>void</RETURNS>
GtkTreePath       *path, int                index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_get_depth</NAME>
<RETURNS>int</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_get_indices</NAME>
<RETURNS>int *</RETURNS>
GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_path_get_indices_with_depth</NAME>
<RETURNS>int *</RETURNS>
GtkTreePath *path, int         *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>int</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, int         *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>int</RETURNS>
GtkTreeModel *tree_model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_column_type</NAME>
<RETURNS>GType</RETURNS>
GtkTreeModel *tree_model, int           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 char   *path_string
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_get_string_from_iter</NAME>
<RETURNS>char *</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, int           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>int</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, int           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, int          *new_order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_model_rows_reordered_with_length</NAME>
<RETURNS>void</RETURNS>
GtkTreeModel *tree_model, GtkTreePath  *path, GtkTreeIter  *iter, int          *new_order, int           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, int           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,
                   int                 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, int                           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, int                           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_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>int</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>int</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,
				      int                    *sort_column_id,
				      GtkSortType            *order);
  void     (* set_sort_column_id)    (GtkTreeSortable        *sortable,
				      int                     sort_column_id,
				      GtkSortType             order);
  void     (* set_sort_func)         (GtkTreeSortable        *sortable,
				      int                     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, int                    *sort_column_id, GtkSortType            *order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_set_sort_column_id</NAME>
<RETURNS>void</RETURNS>
GtkTreeSortable        *sortable, int                     sort_column_id, GtkSortType             order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_sortable_set_sort_func</NAME>
<RETURNS>void</RETURNS>
GtkTreeSortable        *sortable, int                     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>
int           n_columns, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_newv</NAME>
<RETURNS>GtkTreeStore *</RETURNS>
int           n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_column_types</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, int           n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_value</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, int           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, int          *columns, GValue       *values, int           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, int           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, int           position, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_with_valuesv</NAME>
<RETURNS>void</RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, int           position, int          *columns, GValue       *values, int           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>int</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, int          *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>
<MACRO>
<NAME>GTK_TREE_VIEW_CLASS</NAME>
#define GTK_TREE_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW, GtkTreeViewClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_VIEW_CLASS</NAME>
#define GTK_IS_TREE_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW_GET_CLASS</NAME>
#define GTK_TREE_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_VIEW, GtkTreeViewClass))
</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, int                      column, const char              *key, GtkTreeIter             *iter, gpointer                 search_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewRowSeparatorFunc</NAME>
<RETURNS>gboolean</RETURNS>
GtkTreeModel      *model, GtkTreeIter       *iter, gpointer           data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTreeView</NAME>
struct _GtkTreeView
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeViewClass</NAME>
struct _GtkTreeViewClass
{
  GtkWidgetClass parent_class;

  void     (* row_activated)              (GtkTreeView       *tree_view,
                                           GtkTreePath       *path,
                                           GtkTreeViewColumn *column);
  gboolean (* test_expand_row)            (GtkTreeView       *tree_view,
                                           GtkTreeIter       *iter,
                                           GtkTreePath       *path);
  gboolean (* test_collapse_row)          (GtkTreeView       *tree_view,
                                           GtkTreeIter       *iter,
                                           GtkTreePath       *path);
  void     (* row_expanded)               (GtkTreeView       *tree_view,
                                           GtkTreeIter       *iter,
                                           GtkTreePath       *path);
  void     (* row_collapsed)              (GtkTreeView       *tree_view,
                                           GtkTreeIter       *iter,
                                           GtkTreePath       *path);
  void     (* columns_changed)            (GtkTreeView       *tree_view);
  void     (* cursor_changed)             (GtkTreeView       *tree_view);

  /* Key Binding signals */
  gboolean (* move_cursor)                (GtkTreeView       *tree_view,
                                           GtkMovementStep    step,
                                           int                count,
                                           gboolean           extend,
                                           gboolean           modify);
  gboolean (* select_all)                 (GtkTreeView       *tree_view);
  gboolean (* unselect_all)               (GtkTreeView       *tree_view);
  gboolean (* select_cursor_row)          (GtkTreeView       *tree_view,
                                           gboolean           start_editing);
  gboolean (* toggle_cursor_row)          (GtkTreeView       *tree_view);
  gboolean (* expand_collapse_cursor_row) (GtkTreeView       *tree_view,
                                           gboolean           logical,
                                           gboolean           expand,
                                           gboolean           open_all);
  gboolean (* select_cursor_parent)       (GtkTreeView       *tree_view);
  gboolean (* start_interactive_search)   (GtkTreeView       *tree_view);

  /*< private >*/
  gpointer _reserved[16];
};
</STRUCT>
<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>int</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_remove_column</NAME>
<RETURNS>int</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column</NAME>
<RETURNS>int</RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column, int                        position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column_with_attributes</NAME>
<RETURNS>int</RETURNS>
GtkTreeView               *tree_view, int                        position, const char                *title, GtkCellRenderer           *cell, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column_with_data_func</NAME>
<RETURNS>int</RETURNS>
GtkTreeView               *tree_view, int                        position, const char                *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, int                        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, int                        tree_x, int                        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, float                      row_align, float                      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, int                        x, int                        y, GtkTreePath              **path, GtkTreeViewColumn        **column, int                       *cell_x, int                       *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, int                        x, int                        y, GtkTreePath              **path, GtkTreeViewColumn        **column, int                       *cell_x, int                       *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, int                        drag_x, int                        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>int</RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_column</NAME>
<RETURNS>void</RETURNS>
GtkTreeView                *tree_view, int                         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, int          wx, int          wy, int         *tx, int         *ty
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_tree_to_widget_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, int          tx, int          ty, int         *wx, int         *wy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_widget_to_bin_window_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, int          wx, int          wy, int         *bx, int         *by
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_bin_window_to_widget_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, int          bx, int          by, int         *wx, int         *wy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_tree_to_bin_window_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, int          tx, int          ty, int         *bx, int         *by
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_bin_window_to_tree_coords</NAME>
<RETURNS>void</RETURNS>
GtkTreeView *tree_view, int          bx, int          by, int         *tx, int         *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, int                         indentation
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_level_indentation</NAME>
<RETURNS>int</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, int                x, int                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, int                column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_tooltip_column</NAME>
<RETURNS>int</RETURNS>
GtkTreeView       *tree_view
</FUNCTION>
<STRUCT>
<NAME>GtkTreeSelection</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 char              *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 char              *attribute, int                      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, int                      spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_spacing</NAME>
<RETURNS>int</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>int</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_width</NAME>
<RETURNS>int</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_fixed_width</NAME>
<RETURNS>int</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_fixed_width</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, int                      fixed_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_min_width</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, int                      min_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_min_width</NAME>
<RETURNS>int</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_max_width</NAME>
<RETURNS>void</RETURNS>
GtkTreeViewColumn       *tree_column, int                      max_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_max_width</NAME>
<RETURNS>int</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 char              *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_title</NAME>
<RETURNS>const char *</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, float                    xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_alignment</NAME>
<RETURNS>float</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, int                      sort_column_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sort_column_id</NAME>
<RETURNS>int</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, int                     *x_offset, int                     *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>GtkBitset</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilder</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilderScope</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCssStyleChange</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventController</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGesture</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkLayoutManager</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkListItem</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkListItemFactory</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>GtkTickCallback</NAME>
<RETURNS>gboolean</RETURNS>
GtkWidget     *widget, GdkFrameClock *frame_clock, gpointer       user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkRequisition</NAME>
struct _GtkRequisition
{
  int width;
  int 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 >*/

  /* 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);

  /* 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);

  gboolean     (* query_tooltip)      (GtkWidget  *widget,
                                       int         x,
                                       int         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,
                                                double     x,
                                                double     y);

  /*< private >*/

  GtkWidgetClassPrivate *priv;

  gpointer padding[8];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_widget_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</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 char          *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_add_binding_signal</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass      *widget_class, guint                keyval, GdkModifierType      mods, const char          *signal, const char          *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_add_binding_action</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass      *widget_class, guint                keyval, GdkModifierType      mods, const char          *action_name, const char          *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_add_shortcut</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass      *widget_class, GtkShortcut         *shortcut
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_activate_signal</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass *widget_class, guint           signal_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_activate_signal_from_name</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass *widget_class, const char     *signal_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_get_activate_signal</NAME>
<RETURNS>guint</RETURNS>
GtkWidgetClass *widget_class
</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_set_name</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, const char   *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_name</NAME>
<RETURNS>const char *</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_get_size</NAME>
<RETURNS>int</RETURNS>
GtkWidget     *widget, GtkOrientation orientation
</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, int                  width, int                  height
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_size_request</NAME>
<RETURNS>void</RETURNS>
GtkWidget           *widget, int                 *width, int                 *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>int</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_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>int</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_start</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, int        margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_end</NAME>
<RETURNS>int</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_end</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, int        margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_top</NAME>
<RETURNS>int</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_top</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, int        margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_bottom</NAME>
<RETURNS>int</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_bottom</NAME>
<RETURNS>void</RETURNS>
GtkWidget *widget, int        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, double      x, double      y
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_pick</NAME>
<RETURNS>GtkWidget *</RETURNS>
GtkWidget   *widget, double       x, double       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 char *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 char  *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_tooltip_text</NAME>
<RETURNS>const char *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_tooltip_markup</NAME>
<RETURNS>void</RETURNS>
GtkWidget   *widget, const char  *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_tooltip_markup</NAME>
<RETURNS>const char *</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 char            *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 char            *resource_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_bind_template_callback_full</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass        *widget_class, const char            *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 char            *name, gboolean               internal_child, gssize                 struct_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_insert_action_group</NAME>
<RETURNS>void</RETURNS>
GtkWidget    *widget, const char   *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>
<FUNCTION>
<NAME>gtk_widget_class_set_accessible_role</NAME>
<RETURNS>void</RETURNS>
GtkWidgetClass    *widget_class, GtkAccessibleRole  accessible_role
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_get_accessible_role</NAME>
<RETURNS>GtkAccessibleRole</RETURNS>
GtkWidgetClass    *widget_class
</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 char          *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_title</NAME>
<RETURNS>const char *</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_startup_id</NAME>
<RETURNS>void</RETURNS>
GtkWindow           *window, const char          *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 char *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_icon_name</NAME>
<RETURNS>const char *</RETURNS>
GtkWindow  *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_default_icon_name</NAME>
<RETURNS>void</RETURNS>
const char *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_default_icon_name</NAME>
<RETURNS>const char *</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, int          width, int          height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_default_size</NAME>
<RETURNS>void</RETURNS>
GtkWindow   *window, int         *width, int         *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_is_fullscreen</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>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>
<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>
<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>
<MACRO>
<NAME>GTK_TYPE_CSS_AFFECTS</NAME>
#define GTK_TYPE_CSS_AFFECTS (_gtk_css_affects_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_PLACES_SECTION_TYPE</NAME>
#define GTK_TYPE_PLACES_SECTION_TYPE (_gtk_places_section_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PLACES_PLACE_TYPE</NAME>
#define GTK_TYPE_PLACES_PLACE_TYPE (_gtk_places_place_type_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_FLAGS</NAME>
#define GTK_TYPE_DEBUG_FLAGS (gtk_debug_flags_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_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_ORDERING</NAME>
#define GTK_TYPE_ORDERING (gtk_ordering_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_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_ACCESSIBLE_ROLE</NAME>
#define GTK_TYPE_ACCESSIBLE_ROLE (gtk_accessible_role_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE_STATE</NAME>
#define GTK_TYPE_ACCESSIBLE_STATE (gtk_accessible_state_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE_PROPERTY</NAME>
#define GTK_TYPE_ACCESSIBLE_PROPERTY (gtk_accessible_property_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE_RELATION</NAME>
#define GTK_TYPE_ACCESSIBLE_RELATION (gtk_accessible_relation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE_TRISTATE</NAME>
#define GTK_TYPE_ACCESSIBLE_TRISTATE (gtk_accessible_tristate_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE_INVALID_STATE</NAME>
#define GTK_TYPE_ACCESSIBLE_INVALID_STATE (gtk_accessible_invalid_state_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE_AUTOCOMPLETE</NAME>
#define GTK_TYPE_ACCESSIBLE_AUTOCOMPLETE (gtk_accessible_autocomplete_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE_SORT</NAME>
#define GTK_TYPE_ACCESSIBLE_SORT (gtk_accessible_sort_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_FILTER_MATCH</NAME>
#define GTK_TYPE_FILTER_MATCH (gtk_filter_match_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FILTER_CHANGE</NAME>
#define GTK_TYPE_FILTER_CHANGE (gtk_filter_change_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_SORTER_ORDER</NAME>
#define GTK_TYPE_SORTER_ORDER (gtk_sorter_order_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SORTER_CHANGE</NAME>
#define GTK_TYPE_SORTER_CHANGE (gtk_sorter_change_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_STRING_FILTER_MATCH_MODE</NAME>
#define GTK_TYPE_STRING_FILTER_MATCH_MODE (gtk_string_filter_match_mode_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_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 (4)
</MACRO>
<MACRO>
<NAME>GTK_MINOR_VERSION</NAME>
#define GTK_MINOR_VERSION (1)
</MACRO>
<MACRO>
<NAME>GTK_MICRO_VERSION</NAME>
#define GTK_MICRO_VERSION (1)
</MACRO>
<MACRO>
<NAME>GTK_BINARY_AGE</NAME>
#define GTK_BINARY_AGE    (101)
</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>
<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 char *</RETURNS>
guint   required_major, guint   required_minor, guint   required_micro
</FUNCTION>
<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>
