<MACRO>
<NAME>GSK_TYPE_PANGO_RENDERER</NAME>
#define GSK_TYPE_PANGO_RENDERER (gsk_pango_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_PANGO_RENDERER</NAME>
#define GSK_PANGO_RENDERER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_PANGO_RENDERER, GskPangoRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_PANGO_RENDERER</NAME>
#define GSK_IS_PANGO_RENDERER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_PANGO_RENDERER))
</MACRO>
<FUNCTION>
<NAME>gsk_pango_renderer_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GskPangoRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskPangoRendererClass</NAME>
</STRUCT>
<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_ABOUT_DIALOG_CLASS</NAME>
#define GTK_ABOUT_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ABOUT_DIALOG, GtkAboutDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_ABOUT_DIALOG_CLASS</NAME>
#define GTK_IS_ABOUT_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ABOUT_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_ABOUT_DIALOG_GET_CLASS</NAME>
#define GTK_ABOUT_DIALOG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ABOUT_DIALOG, GtkAboutDialogClass))
</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
} GtkLicense;
</ENUM>
<STRUCT>
<NAME>GtkAboutDialog</NAME>
struct _GtkAboutDialog
{
  GtkDialog parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkAboutDialogClass</NAME>
struct _GtkAboutDialogClass
{
  GtkDialogClass parent_class;

  gboolean (*activate_link) (GtkAboutDialog *dialog,
                             const gchar    *uri);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_about_dialog_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_new</NAME>
<RETURNS>GtkWidget              *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_show_about_dialog</NAME>
<RETURNS>void                    </RETURNS>
GtkWindow       *parent, const gchar     *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_program_name</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_program_name</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_version</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_version</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *version
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_copyright</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_copyright</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *copyright
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_comments</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_comments</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *comments
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_license</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_license</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *license
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_license_type</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, GtkLicense       license_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_license_type</NAME>
<RETURNS>GtkLicense              </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_wrap_license</NAME>
<RETURNS>gboolean                </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_wrap_license</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, gboolean         wrap_license
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_system_information</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_system_information</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *system_information
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_website</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_website</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *website
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_website_label</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_website_label</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *website_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_authors</NAME>
<RETURNS>const gchar * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_authors</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar    **authors
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_documenters</NAME>
<RETURNS>const gchar * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_documenters</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar    **documenters
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_artists</NAME>
<RETURNS>const gchar * const *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_artists</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar    **artists
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_translator_credits</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_translator_credits</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *translator_credits
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_logo</NAME>
<RETURNS>GdkPaintable           *</RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_logo</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, GdkPaintable    *logo
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_get_logo_icon_name</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkAboutDialog  *about
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_set_logo_icon_name</NAME>
<RETURNS>void                    </RETURNS>
GtkAboutDialog  *about, const gchar     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_about_dialog_add_credit_section</NAME>
<RETURNS>void                   </RETURNS>
GtkAboutDialog  *about, const gchar     *section_name, const gchar    **people
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ACCEL_GROUP</NAME>
#define GTK_TYPE_ACCEL_GROUP              (gtk_accel_group_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_GROUP</NAME>
#define GTK_ACCEL_GROUP(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_ACCEL_GROUP, GtkAccelGroup))
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_GROUP_CLASS</NAME>
#define GTK_ACCEL_GROUP_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_GROUP, GtkAccelGroupClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCEL_GROUP</NAME>
#define GTK_IS_ACCEL_GROUP(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_ACCEL_GROUP))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCEL_GROUP_CLASS</NAME>
#define GTK_IS_ACCEL_GROUP_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_GROUP))
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_GROUP_GET_CLASS</NAME>
#define GTK_ACCEL_GROUP_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_GROUP, GtkAccelGroupClass))
</MACRO>
<ENUM>
<NAME>GtkAccelFlags</NAME>
typedef enum
{
  GTK_ACCEL_VISIBLE        = 1 << 0,
  GTK_ACCEL_LOCKED         = 1 << 1,
  GTK_ACCEL_MASK           = 0x07
} GtkAccelFlags;
</ENUM>
<USER_FUNCTION>
<NAME>GtkAccelGroupActivate</NAME>
<RETURNS>gboolean </RETURNS>
GtkAccelGroup  *accel_group,
					   GObject        *acceleratable,
					   guint           keyval,
					   GdkModifierType modifier
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkAccelGroupFindFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkAccelKey    *key,
					   GClosure       *closure,
					   gpointer        data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkAccelGroup</NAME>
struct _GtkAccelGroup
{
  GObject               parent;
  GtkAccelGroupPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkAccelGroupClass</NAME>
struct _GtkAccelGroupClass
{
  GObjectClass parent_class;

  /*< public >*/

  void	(*accel_changed)	(GtkAccelGroup	*accel_group,
				 guint           keyval,
				 GdkModifierType modifier,
				 GClosure       *accel_closure);

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<STRUCT>
<NAME>GtkAccelKey</NAME>
struct _GtkAccelKey
{
  guint           accel_key;
  GdkModifierType accel_mods;
  guint           accel_flags : 16;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_accel_group_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_new</NAME>
<RETURNS>GtkAccelGroup * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_get_is_locked</NAME>
<RETURNS>gboolean        </RETURNS>
GtkAccelGroup  *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_get_modifier_mask</NAME>
<RETURNS>GdkModifierType</RETURNS>
GtkAccelGroup  *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_lock</NAME>
<RETURNS>void 	       </RETURNS>
GtkAccelGroup  *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_unlock</NAME>
<RETURNS>void 	       </RETURNS>
GtkAccelGroup  *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_connect</NAME>
<RETURNS>void 	       </RETURNS>
GtkAccelGroup  *accel_group, guint	   accel_key, GdkModifierType accel_mods, GtkAccelFlags   accel_flags, GClosure	  *closure
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_connect_by_path</NAME>
<RETURNS>void            </RETURNS>
GtkAccelGroup  *accel_group, const gchar	  *accel_path, GClosure	  *closure
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_disconnect</NAME>
<RETURNS>gboolean        </RETURNS>
GtkAccelGroup  *accel_group, GClosure	  *closure
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_disconnect_key</NAME>
<RETURNS>gboolean        </RETURNS>
GtkAccelGroup  *accel_group, guint	   accel_key, GdkModifierType accel_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_activate</NAME>
<RETURNS>gboolean        </RETURNS>
GtkAccelGroup   *accel_group, GQuark	   accel_quark, GObject	  *acceleratable, guint	   accel_key, GdkModifierType accel_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_groups_activate</NAME>
<RETURNS>gboolean         </RETURNS>
GObject	*object, guint		 accel_key, GdkModifierType accel_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_groups_from_object</NAME>
<RETURNS>GSList *	        </RETURNS>
GObject	*object
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_find</NAME>
<RETURNS>GtkAccelKey *	</RETURNS>
GtkAccelGroup	      *accel_group, GtkAccelGroupFindFunc find_func, gpointer              data
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_from_accel_closure</NAME>
<RETURNS>GtkAccelGroup *	</RETURNS>
GClosure    *closure
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_valid</NAME>
<RETURNS>gboolean  </RETURNS>
guint	        keyval, GdkModifierType  modifiers
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_parse</NAME>
<RETURNS>void 	 </RETURNS>
const gchar     *accelerator, guint	       *accelerator_key, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_parse_with_keycode</NAME>
<RETURNS>void  </RETURNS>
const gchar     *accelerator, guint           *accelerator_key, guint          **accelerator_codes, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_name</NAME>
<RETURNS>gchar *	 </RETURNS>
guint	        accelerator_key, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_name_with_keycode</NAME>
<RETURNS>gchar *	 </RETURNS>
GdkDisplay      *display, guint            accelerator_key, guint            keycode, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_label</NAME>
<RETURNS>gchar *   </RETURNS>
guint           accelerator_key, GdkModifierType accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_label_with_keycode</NAME>
<RETURNS>gchar *   </RETURNS>
GdkDisplay      *display, guint            accelerator_key, guint            keycode, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_set_default_mod_mask</NAME>
<RETURNS>void 	 </RETURNS>
GdkModifierType  default_mod_mask
</FUNCTION>
<FUNCTION>
<NAME>gtk_accelerator_get_default_mod_mask</NAME>
<RETURNS>GdkModifierType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_group_query</NAME>
<RETURNS>GtkAccelGroupEntry *	</RETURNS>
GtkAccelGroup	*accel_group, guint		 accel_key, GdkModifierType accel_mods, guint          *n_entries
</FUNCTION>
<STRUCT>
<NAME>GtkAccelGroupEntry</NAME>
struct _GtkAccelGroupEntry
{
  GtkAccelKey  key;
  GClosure    *closure;
  GQuark       accel_path_quark;
};
</STRUCT>
<STRUCT>
<NAME>GtkAccelGroupPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACCEL_LABEL</NAME>
#define GTK_TYPE_ACCEL_LABEL		(gtk_accel_label_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_LABEL</NAME>
#define GTK_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabel))
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_LABEL_CLASS</NAME>
#define GTK_ACCEL_LABEL_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_LABEL, GtkAccelLabelClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCEL_LABEL</NAME>
#define GTK_IS_ACCEL_LABEL(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCEL_LABEL))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCEL_LABEL_CLASS</NAME>
#define GTK_IS_ACCEL_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_LABEL))
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_LABEL_GET_CLASS</NAME>
#define GTK_ACCEL_LABEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_LABEL, GtkAccelLabelClass))
</MACRO>
<STRUCT>
<NAME>GtkAccelLabel</NAME>
struct _GtkAccelLabel
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkAccelLabelClass</NAME>
struct _GtkAccelLabelClass
{
  GtkWidgetClass parent_class;

  gchar		*mod_name_shift;
  gchar		*mod_name_control;
  gchar		*mod_name_alt;
  gchar		*mod_separator;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_accel_label_get_type</NAME>
<RETURNS>GType 	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar   *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_accel_widget</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkAccelLabel *accel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_accel_width</NAME>
<RETURNS>guint 	   </RETURNS>
GtkAccelLabel *accel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_accel_widget</NAME>
<RETURNS>void 	   </RETURNS>
GtkAccelLabel *accel_label, GtkWidget	    *accel_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_accel_closure</NAME>
<RETURNS>void 	   </RETURNS>
GtkAccelLabel *accel_label, GClosure	    *accel_closure
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_refetch</NAME>
<RETURNS>gboolean    </RETURNS>
GtkAccelLabel *accel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_accel</NAME>
<RETURNS>void        </RETURNS>
GtkAccelLabel   *accel_label, guint            accelerator_key, GdkModifierType  accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_accel</NAME>
<RETURNS>void        </RETURNS>
GtkAccelLabel   *accel_label, guint           *accelerator_key, GdkModifierType *accelerator_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_label</NAME>
<RETURNS>void       </RETURNS>
GtkAccelLabel   *accel_label, const char      *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_label</NAME>
<RETURNS>const char  * </RETURNS>
GtkAccelLabel   *accel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_set_use_underline</NAME>
<RETURNS>void       </RETURNS>
GtkAccelLabel   *accel_label, gboolean         setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_label_get_use_underline</NAME>
<RETURNS>gboolean   </RETURNS>
GtkAccelLabel   *accel_label
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ACCEL_MAP</NAME>
#define GTK_TYPE_ACCEL_MAP                (gtk_accel_map_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_MAP</NAME>
#define GTK_ACCEL_MAP(accel_map)	  (G_TYPE_CHECK_INSTANCE_CAST ((accel_map), GTK_TYPE_ACCEL_MAP, GtkAccelMap))
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_MAP_CLASS</NAME>
#define GTK_ACCEL_MAP_CLASS(klass)	  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCEL_MAP, GtkAccelMapClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCEL_MAP</NAME>
#define GTK_IS_ACCEL_MAP(accel_map)	  (G_TYPE_CHECK_INSTANCE_TYPE ((accel_map), GTK_TYPE_ACCEL_MAP))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCEL_MAP_CLASS</NAME>
#define GTK_IS_ACCEL_MAP_CLASS(klass)	  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCEL_MAP))
</MACRO>
<MACRO>
<NAME>GTK_ACCEL_MAP_GET_CLASS</NAME>
#define GTK_ACCEL_MAP_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCEL_MAP, GtkAccelMapClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkAccelMapForeach</NAME>
<RETURNS>void </RETURNS>
gpointer	 data,
						 const gchar	*accel_path,
						 guint           accel_key,
						 GdkModifierType accel_mods,
						 gboolean	 changed
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_add_entry</NAME>
<RETURNS>void 	   </RETURNS>
const gchar		*accel_path, guint			 accel_key, GdkModifierType         accel_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_lookup_entry</NAME>
<RETURNS>gboolean    </RETURNS>
const gchar		*accel_path, GtkAccelKey		*key
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_change_entry</NAME>
<RETURNS>gboolean    </RETURNS>
const gchar		*accel_path, guint			 accel_key, GdkModifierType	 accel_mods, gboolean		 replace
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_load</NAME>
<RETURNS>void 	   </RETURNS>
const gchar		*file_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_save</NAME>
<RETURNS>void 	   </RETURNS>
const gchar		*file_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_foreach</NAME>
<RETURNS>void 	   </RETURNS>
gpointer		 data, GtkAccelMapForeach	 foreach_func
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_load_fd</NAME>
<RETURNS>void 	   </RETURNS>
gint			 fd
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_load_scanner</NAME>
<RETURNS>void 	   </RETURNS>
GScanner		*scanner
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_save_fd</NAME>
<RETURNS>void 	   </RETURNS>
gint			 fd
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_lock_path</NAME>
<RETURNS>void        </RETURNS>
const gchar            *accel_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_unlock_path</NAME>
<RETURNS>void        </RETURNS>
const gchar            *accel_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_add_filter</NAME>
<RETURNS>void 	</RETURNS>
const gchar		*filter_pattern
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_foreach_unfiltered</NAME>
<RETURNS>void 	</RETURNS>
gpointer		 data, GtkAccelMapForeach	 foreach_func
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_accel_map_get</NAME>
<RETURNS>GtkAccelMap  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkAccelMap</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkAccelMapClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACCESSIBLE</NAME>
#define GTK_TYPE_ACCESSIBLE                  (gtk_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACCESSIBLE</NAME>
#define GTK_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessible))
</MACRO>
<MACRO>
<NAME>GTK_ACCESSIBLE_CLASS</NAME>
#define GTK_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCESSIBLE</NAME>
#define GTK_IS_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACCESSIBLE, GtkAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkAccessible</NAME>
struct _GtkAccessible
{
  AtkObject parent;

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

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

  /*< public >*/

  const gchar * (* get_action_name)             (GtkActionable *actionable);
  void          (* set_action_name)             (GtkActionable *actionable,
                                                 const gchar   *action_name);
  GVariant *    (* get_action_target_value)     (GtkActionable *actionable);
  void          (* set_action_target_value)     (GtkActionable *actionable,
                                                 GVariant      *target_value);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_actionable_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_get_action_name</NAME>
<RETURNS>const gchar  *           </RETURNS>
GtkActionable *actionable
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_action_name</NAME>
<RETURNS>void                     </RETURNS>
GtkActionable *actionable, const gchar   *action_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_get_action_target_value</NAME>
<RETURNS>GVariant  *              </RETURNS>
GtkActionable *actionable
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_action_target_value</NAME>
<RETURNS>void                     </RETURNS>
GtkActionable *actionable, GVariant      *target_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_action_target</NAME>
<RETURNS>void                     </RETURNS>
GtkActionable *actionable, const gchar   *format_string, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_actionable_set_detailed_action_name</NAME>
<RETURNS>void                     </RETURNS>
GtkActionable *actionable, const gchar   *detailed_action_name
</FUNCTION>
<STRUCT>
<NAME>GtkActionable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACTION_BAR</NAME>
#define GTK_TYPE_ACTION_BAR            (gtk_action_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACTION_BAR</NAME>
#define GTK_ACTION_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ACTION_BAR, GtkActionBar))
</MACRO>
<MACRO>
<NAME>GTK_ACTION_BAR_CLASS</NAME>
#define GTK_ACTION_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ACTION_BAR, GtkActionBarClass))
</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>
<MACRO>
<NAME>GTK_IS_ACTION_BAR_CLASS</NAME>
#define GTK_IS_ACTION_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ACTION_BAR))
</MACRO>
<MACRO>
<NAME>GTK_ACTION_BAR_GET_CLASS</NAME>
#define GTK_ACTION_BAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ACTION_BAR, GtkActionBarClass))
</MACRO>
<STRUCT>
<NAME>GtkActionBar</NAME>
struct _GtkActionBar
{
  /*< private >*/
  GtkContainer container;
};
</STRUCT>
<STRUCT>
<NAME>GtkActionBarClass</NAME>
struct _GtkActionBarClass
{
  /*< private >*/
  GtkContainerClass 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_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_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>GtkActionBarPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ACTION_OBSERVABLE</NAME>
#define GTK_TYPE_ACTION_OBSERVABLE                          (gtk_action_observable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ACTION_OBSERVABLE</NAME>
#define GTK_ACTION_OBSERVABLE(inst)                         (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
                                                             GTK_TYPE_ACTION_OBSERVABLE, GtkActionObservable))
</MACRO>
<MACRO>
<NAME>GTK_IS_ACTION_OBSERVABLE</NAME>
#define GTK_IS_ACTION_OBSERVABLE(inst)                      (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
                                                             GTK_TYPE_ACTION_OBSERVABLE))
</MACRO>
<MACRO>
<NAME>GTK_ACTION_OBSERVABLE_GET_IFACE</NAME>
#define GTK_ACTION_OBSERVABLE_GET_IFACE(inst)               (G_TYPE_INSTANCE_GET_INTERFACE ((inst),                  \
                                                             GTK_TYPE_ACTION_OBSERVABLE,                             \
                                                             GtkActionObservableInterface))
</MACRO>
<STRUCT>
<NAME>GtkActionObservableInterface</NAME>
struct _GtkActionObservableInterface
{
  GTypeInterface g_iface;

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

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_adjustment_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_new</NAME>
<RETURNS>GtkAdjustment *   </RETURNS>
gdouble          value, gdouble          lower, gdouble          upper, gdouble          step_increment, gdouble          page_increment, gdouble          page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_clamp_page</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          lower, gdouble          upper
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_value</NAME>
<RETURNS>gdouble     </RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_value</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          value
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_lower</NAME>
<RETURNS>gdouble     </RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_lower</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          lower
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_upper</NAME>
<RETURNS>gdouble     </RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_upper</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          upper
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_step_increment</NAME>
<RETURNS>gdouble     </RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_step_increment</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          step_increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_page_increment</NAME>
<RETURNS>gdouble     </RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_page_increment</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          page_increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_page_size</NAME>
<RETURNS>gdouble     </RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_set_page_size</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_configure</NAME>
<RETURNS>void        </RETURNS>
GtkAdjustment   *adjustment, gdouble          value, gdouble          lower, gdouble          upper, gdouble          step_increment, gdouble          page_increment, gdouble          page_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_adjustment_get_minimum_increment</NAME>
<RETURNS>gdouble     </RETURNS>
GtkAdjustment   *adjustment
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_APP_CHOOSER</NAME>
#define GTK_TYPE_APP_CHOOSER    (gtk_app_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER</NAME>
#define GTK_APP_CHOOSER(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_APP_CHOOSER, GtkAppChooser))
</MACRO>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER</NAME>
#define GTK_IS_APP_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_APP_CHOOSER))
</MACRO>
<FUNCTION>
<NAME>gtk_app_chooser_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_get_app_info</NAME>
<RETURNS>GAppInfo  * </RETURNS>
GtkAppChooser *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_get_content_type</NAME>
<RETURNS>gchar  *    </RETURNS>
GtkAppChooser *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_refresh</NAME>
<RETURNS>void        </RETURNS>
GtkAppChooser *self
</FUNCTION>
<STRUCT>
<NAME>GtkAppChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_APP_CHOOSER_BUTTON</NAME>
#define GTK_TYPE_APP_CHOOSER_BUTTON            (gtk_app_chooser_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_BUTTON</NAME>
#define GTK_APP_CHOOSER_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_APP_CHOOSER_BUTTON, GtkAppChooserButton))
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_BUTTON_CLASS</NAME>
#define GTK_APP_CHOOSER_BUTTON_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_APP_CHOOSER_BUTTON, GtkAppChooserButtonClass))
</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>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER_BUTTON_CLASS</NAME>
#define GTK_IS_APP_CHOOSER_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_APP_CHOOSER_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_BUTTON_GET_CLASS</NAME>
#define GTK_APP_CHOOSER_BUTTON_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_APP_CHOOSER_BUTTON, GtkAppChooserButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkAppChooserButton</NAME>
struct _GtkAppChooserButton {
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkAppChooserButtonClass</NAME>
struct _GtkAppChooserButtonClass {
  GtkWidgetClass parent_class;

  /*< public >*/

  void (* changed)               (GtkAppChooserButton *self);
  void (* custom_item_activated) (GtkAppChooserButton *self,
                                  const gchar *item_name);

  /*< private >*/

  /* padding for future class expansion */
  gpointer padding[16];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_new</NAME>
<RETURNS>GtkWidget  * </RETURNS>
const gchar         *content_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_append_separator</NAME>
<RETURNS>void         </RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_append_custom_item</NAME>
<RETURNS>void         </RETURNS>
GtkAppChooserButton *self, const gchar         *name, const gchar         *label, GIcon               *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_active_custom_item</NAME>
<RETURNS>void      </RETURNS>
GtkAppChooserButton *self, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_show_dialog_item</NAME>
<RETURNS>void      </RETURNS>
GtkAppChooserButton *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_show_dialog_item</NAME>
<RETURNS>gboolean  </RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_heading</NAME>
<RETURNS>void      </RETURNS>
GtkAppChooserButton *self, const gchar         *heading
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_heading</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_set_show_default_item</NAME>
<RETURNS>void      </RETURNS>
GtkAppChooserButton *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_button_get_show_default_item</NAME>
<RETURNS>gboolean  </RETURNS>
GtkAppChooserButton *self
</FUNCTION>
<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_APP_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_APP_CHOOSER_DIALOG_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_APP_CHOOSER_DIALOG, GtkAppChooserDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_IS_APP_CHOOSER_DIALOG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_APP_CHOOSER_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_DIALOG_GET_CLASS</NAME>
#define GTK_APP_CHOOSER_DIALOG_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_APP_CHOOSER_DIALOG, GtkAppChooserDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkAppChooserDialog</NAME>
struct _GtkAppChooserDialog {
  GtkDialog parent;

  /*< private >*/
  GtkAppChooserDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkAppChooserDialogClass</NAME>
struct _GtkAppChooserDialogClass {
  GtkDialogClass parent_class;

  /*< private >*/

  /* padding for future class expansion */
  gpointer padding[16];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_new</NAME>
<RETURNS>GtkWidget  *   </RETURNS>
GtkWindow           *parent, GtkDialogFlags       flags, GFile               *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_new_for_content_type</NAME>
<RETURNS>GtkWidget  *   </RETURNS>
GtkWindow           *parent, GtkDialogFlags       flags, const gchar         *content_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_get_widget</NAME>
<RETURNS>GtkWidget  *   </RETURNS>
GtkAppChooserDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_set_heading</NAME>
<RETURNS>void           </RETURNS>
GtkAppChooserDialog *self, const gchar         *heading
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_dialog_get_heading</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkAppChooserDialog *self
</FUNCTION>
<STRUCT>
<NAME>GtkAppChooserDialogPrivate</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_APP_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_APP_CHOOSER_WIDGET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_APP_CHOOSER_WIDGET, GtkAppChooserWidgetClass))
</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>
<MACRO>
<NAME>GTK_IS_APP_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_IS_APP_CHOOSER_WIDGET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_APP_CHOOSER_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_APP_CHOOSER_WIDGET_GET_CLASS</NAME>
#define GTK_APP_CHOOSER_WIDGET_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_APP_CHOOSER_WIDGET, GtkAppChooserWidgetClass))
</MACRO>
<STRUCT>
<NAME>GtkAppChooserWidget</NAME>
struct _GtkAppChooserWidget {
  GtkWidget parent_instance;

  /*< private >*/
  GtkAppChooserWidgetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkAppChooserWidgetClass</NAME>
struct _GtkAppChooserWidgetClass {
  GtkWidgetClass parent_class;

  /*< public >*/

  void (* application_selected)  (GtkAppChooserWidget *self,
                                  GAppInfo            *app_info);

  void (* application_activated) (GtkAppChooserWidget *self,
                                  GAppInfo            *app_info);

  void (* populate_popup)        (GtkAppChooserWidget *self,
                                  GtkMenu             *menu,
                                  GAppInfo            *app_info);

  /*< private >*/

  /* padding for future class expansion */
  gpointer padding[16];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_new</NAME>
<RETURNS>GtkWidget  *   </RETURNS>
const gchar         *content_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_default</NAME>
<RETURNS>void           </RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_default</NAME>
<RETURNS>gboolean       </RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_recommended</NAME>
<RETURNS>void           </RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_recommended</NAME>
<RETURNS>gboolean       </RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_fallback</NAME>
<RETURNS>void           </RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_fallback</NAME>
<RETURNS>gboolean       </RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_other</NAME>
<RETURNS>void           </RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_other</NAME>
<RETURNS>gboolean       </RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_show_all</NAME>
<RETURNS>void           </RETURNS>
GtkAppChooserWidget *self, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_show_all</NAME>
<RETURNS>gboolean       </RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_set_default_text</NAME>
<RETURNS>void           </RETURNS>
GtkAppChooserWidget *self, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_app_chooser_widget_get_default_text</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkAppChooserWidget *self
</FUNCTION>
<STRUCT>
<NAME>GtkAppChooserWidgetPrivate</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[12];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_application_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_new</NAME>
<RETURNS>GtkApplication  * </RETURNS>
const gchar       *application_id, GApplicationFlags  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_add_window</NAME>
<RETURNS>void              </RETURNS>
GtkApplication    *application, GtkWindow         *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_remove_window</NAME>
<RETURNS>void              </RETURNS>
GtkApplication    *application, GtkWindow         *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_windows</NAME>
<RETURNS>GList  *          </RETURNS>
GtkApplication    *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_app_menu</NAME>
<RETURNS>GMenuModel  *     </RETURNS>
GtkApplication    *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_set_app_menu</NAME>
<RETURNS>void              </RETURNS>
GtkApplication    *application, GMenuModel        *app_menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_menubar</NAME>
<RETURNS>GMenuModel  *     </RETURNS>
GtkApplication    *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_set_menubar</NAME>
<RETURNS>void              </RETURNS>
GtkApplication    *application, GMenuModel        *menubar
</FUNCTION>
<ENUM>
<NAME>GtkApplicationInhibitFlags</NAME>
typedef enum
{
  GTK_APPLICATION_INHIBIT_LOGOUT  = (1 << 0),
  GTK_APPLICATION_INHIBIT_SWITCH  = (1 << 1),
  GTK_APPLICATION_INHIBIT_SUSPEND = (1 << 2),
  GTK_APPLICATION_INHIBIT_IDLE    = (1 << 3)
} GtkApplicationInhibitFlags;
</ENUM>
<FUNCTION>
<NAME>gtk_application_inhibit</NAME>
<RETURNS>guint             </RETURNS>
GtkApplication             *application, GtkWindow                  *window, GtkApplicationInhibitFlags  flags, const gchar                *reason
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_uninhibit</NAME>
<RETURNS>void              </RETURNS>
GtkApplication             *application, guint                       cookie
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_window_by_id</NAME>
<RETURNS>GtkWindow  *      </RETURNS>
GtkApplication             *application, guint                       id
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_active_window</NAME>
<RETURNS>GtkWindow  *      </RETURNS>
GtkApplication             *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_list_action_descriptions</NAME>
<RETURNS>gchar  **         </RETURNS>
GtkApplication       *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_accels_for_action</NAME>
<RETURNS>gchar  **         </RETURNS>
GtkApplication       *application, const gchar          *detailed_action_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_actions_for_accel</NAME>
<RETURNS>gchar  **         </RETURNS>
GtkApplication       *application, const gchar          *accel
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_set_accels_for_action</NAME>
<RETURNS>void              </RETURNS>
GtkApplication       *application, const gchar          *detailed_action_name, const gchar * const  *accels
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_prefers_app_menu</NAME>
<RETURNS>gboolean          </RETURNS>
GtkApplication       *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_application_get_menu_by_id</NAME>
<RETURNS>GMenu  *          </RETURNS>
GtkApplication       *application, const gchar          *id
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_APPLICATION_WINDOW</NAME>
#define GTK_TYPE_APPLICATION_WINDOW            (gtk_application_window_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_WINDOW</NAME>
#define GTK_APPLICATION_WINDOW(inst)           (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
                                                GTK_TYPE_APPLICATION_WINDOW, GtkApplicationWindow))
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_WINDOW_CLASS</NAME>
#define GTK_APPLICATION_WINDOW_CLASS(class)    (G_TYPE_CHECK_CLASS_CAST ((class),   \
                                                GTK_TYPE_APPLICATION_WINDOW, GtkApplicationWindowClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_APPLICATION_WINDOW</NAME>
#define GTK_IS_APPLICATION_WINDOW(inst)        (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
                                                GTK_TYPE_APPLICATION_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_IS_APPLICATION_WINDOW_CLASS</NAME>
#define GTK_IS_APPLICATION_WINDOW_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class),   \
                                                GTK_TYPE_APPLICATION_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_APPLICATION_WINDOW_GET_CLASS</NAME>
#define GTK_APPLICATION_WINDOW_GET_CLASS(inst) (G_TYPE_INSTANCE_GET_CLASS ((inst),  \
                                                GTK_TYPE_APPLICATION_WINDOW, GtkApplicationWindowClass))
</MACRO>
<STRUCT>
<NAME>GtkApplicationWindow</NAME>
struct _GtkApplicationWindow
{
  GtkWindow parent_instance;

  /*< private >*/
  GtkApplicationWindowPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkApplicationWindowClass</NAME>
struct _GtkApplicationWindowClass
{
  GtkWindowClass parent_class;

  /*< private >*/
  gpointer padding[14];
};
</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>
<STRUCT>
<NAME>GtkApplicationWindowPrivate</NAME>
</STRUCT>
<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_ASPECT_FRAME_CLASS</NAME>
#define GTK_ASPECT_FRAME_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ASPECT_FRAME, GtkAspectFrameClass))
</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>
<MACRO>
<NAME>GTK_IS_ASPECT_FRAME_CLASS</NAME>
#define GTK_IS_ASPECT_FRAME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ASPECT_FRAME))
</MACRO>
<MACRO>
<NAME>GTK_ASPECT_FRAME_GET_CLASS</NAME>
#define GTK_ASPECT_FRAME_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ASPECT_FRAME, GtkAspectFrameClass))
</MACRO>
<STRUCT>
<NAME>GtkAspectFrame</NAME>
struct _GtkAspectFrame
{
  GtkFrame parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkAspectFrameClass</NAME>
struct _GtkAspectFrameClass
{
  GtkFrameClass 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_aspect_frame_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar     *label, gfloat           xalign, gfloat           yalign, gfloat           ratio, gboolean         obey_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_aspect_frame_set</NAME>
<RETURNS>void        </RETURNS>
GtkAspectFrame  *aspect_frame, gfloat           xalign, gfloat           yalign, gfloat           ratio, gboolean         obey_child
</FUNCTION>
<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_ASSISTANT_CLASS</NAME>
#define GTK_ASSISTANT_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST    ((c), GTK_TYPE_ASSISTANT, GtkAssistantClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ASSISTANT</NAME>
#define GTK_IS_ASSISTANT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_ASSISTANT))
</MACRO>
<MACRO>
<NAME>GTK_IS_ASSISTANT_CLASS</NAME>
#define GTK_IS_ASSISTANT_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE    ((c), GTK_TYPE_ASSISTANT))
</MACRO>
<MACRO>
<NAME>GTK_ASSISTANT_GET_CLASS</NAME>
#define GTK_ASSISTANT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS  ((o), GTK_TYPE_ASSISTANT, GtkAssistantClass))
</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>
<STRUCT>
<NAME>GtkAssistant</NAME>
struct _GtkAssistant
{
  GtkWindow  parent;

  /*< private >*/
  GtkAssistantPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkAssistantClass</NAME>
struct _GtkAssistantClass
{
  GtkWindowClass parent_class;

  /*< public >*/

  void (* prepare) (GtkAssistant *assistant, GtkWidget *page);
  void (* apply)   (GtkAssistant *assistant);
  void (* close)   (GtkAssistant *assistant);
  void (* cancel)  (GtkAssistant *assistant);

  /*< 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);
};
</STRUCT>
<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_ASSISTANT_PAGE_CLASS</NAME>
#define GTK_ASSISTANT_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ASSISTANT_PAGE, GtkAssistantPageClass))
</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>
<MACRO>
<NAME>GTK_IS_ASSISTANT_PAGE_CLASS</NAME>
#define GTK_IS_ASSISTANT_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ASSISTANT_PAGE))
</MACRO>
<MACRO>
<NAME>GTK_ASSISTANT_PAGE_GET_CLASS</NAME>
#define GTK_ASSISTANT_PAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ASSISTANT_PAGE, GtkAssistantPageClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkAssistantPageFunc</NAME>
<RETURNS>gint </RETURNS>
gint current_page, gpointer data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_page_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_new</NAME>
<RETURNS>GtkWidget             *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_next_page</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_previous_page</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_current_page</NAME>
<RETURNS>gint                   </RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_current_page</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, gint                  page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_n_pages</NAME>
<RETURNS>gint                   </RETURNS>
GtkAssistant         *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_nth_page</NAME>
<RETURNS>GtkWidget             *</RETURNS>
GtkAssistant         *assistant, gint                  page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_prepend_page</NAME>
<RETURNS>gint                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_append_page</NAME>
<RETURNS>gint                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_insert_page</NAME>
<RETURNS>gint                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, gint                  position
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_remove_page</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, gint                  page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_forward_page_func</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, GtkAssistantPageFunc  page_func, gpointer              data, GDestroyNotify        destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_page_type</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, GtkAssistantPageType  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page_type</NAME>
<RETURNS>GtkAssistantPageType   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_page_title</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, const gchar          *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page_title</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_set_page_complete</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page, gboolean              complete
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page_complete</NAME>
<RETURNS>gboolean               </RETURNS>
GtkAssistant         *assistant, GtkWidget            *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_add_action_widget</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_remove_action_widget</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant         *assistant, GtkWidget            *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_update_buttons_state</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_commit</NAME>
<RETURNS>void                   </RETURNS>
GtkAssistant *assistant
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_page</NAME>
<RETURNS>GtkAssistantPage  *    </RETURNS>
GtkAssistant     *assistant, GtkWidget        *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_page_get_child</NAME>
<RETURNS>GtkWidget  *           </RETURNS>
GtkAssistantPage *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_assistant_get_pages</NAME>
<RETURNS>GListModel  *          </RETURNS>
GtkAssistant *assistant
</FUNCTION>
<STRUCT>
<NAME>GtkAssistantPage</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkAssistantPageClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkAssistantPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_BIN</NAME>
#define GTK_TYPE_BIN                  (gtk_bin_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BIN</NAME>
#define GTK_BIN(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BIN, GtkBin))
</MACRO>
<MACRO>
<NAME>GTK_BIN_CLASS</NAME>
#define GTK_BIN_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BIN, GtkBinClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BIN</NAME>
#define GTK_IS_BIN(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BIN))
</MACRO>
<MACRO>
<NAME>GTK_IS_BIN_CLASS</NAME>
#define GTK_IS_BIN_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BIN))
</MACRO>
<MACRO>
<NAME>GTK_BIN_GET_CLASS</NAME>
#define GTK_BIN_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BIN, GtkBinClass))
</MACRO>
<STRUCT>
<NAME>GtkBin</NAME>
struct _GtkBin
{
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkBinClass</NAME>
struct _GtkBinClass
{
  GtkContainerClass 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_bin_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_bin_get_child</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkBin *bin
</FUNCTION>
<STRUCT>
<NAME>GtkBindingSet</NAME>
struct _GtkBindingSet
{
  gchar           *set_name;
  gint             priority;
  GSList          *widget_path_pspecs;
  GSList          *widget_class_pspecs;
  GSList          *class_branch_pspecs;
  GtkBindingEntry *entries;
  GtkBindingEntry *current;
  guint            parsed : 1;
};
</STRUCT>
<STRUCT>
<NAME>GtkBindingEntry</NAME>
struct _GtkBindingEntry
{
  /* key portion */
  guint             keyval;
  GdkModifierType   modifiers;

  GtkBindingSet    *binding_set;
  guint             destroyed     : 1;
  guint             in_emission   : 1;
  guint             marks_unbound : 1;
  GtkBindingEntry  *set_next;
  GtkBindingEntry  *hash_next;
  GtkBindingSignal *signals;
};
</STRUCT>
<STRUCT>
<NAME>GtkBindingArg</NAME>
struct _GtkBindingArg
{
  GType      arg_type;
  union {
    glong    long_data;
    gdouble  double_data;
    gchar   *string_data;
  } d;
};
</STRUCT>
<STRUCT>
<NAME>GtkBindingSignal</NAME>
struct _GtkBindingSignal
{
  GtkBindingSignal *next;
  gchar            *signal_name;
  guint             n_args;
  GtkBindingArg    *args;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_binding_set_new</NAME>
<RETURNS>GtkBindingSet  *</RETURNS>
const gchar         *set_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_set_by_class</NAME>
<RETURNS>GtkBindingSet  *</RETURNS>
gpointer             object_class
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_set_find</NAME>
<RETURNS>GtkBindingSet  *</RETURNS>
const gchar         *set_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_bindings_activate</NAME>
<RETURNS>gboolean        </RETURNS>
GObject             *object, guint                keyval, GdkModifierType      modifiers
</FUNCTION>
<FUNCTION>
<NAME>gtk_bindings_activate_event</NAME>
<RETURNS>gboolean        </RETURNS>
GObject             *object, GdkEventKey         *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_set_activate</NAME>
<RETURNS>gboolean        </RETURNS>
GtkBindingSet       *binding_set, guint                keyval, GdkModifierType      modifiers, GObject             *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_entry_skip</NAME>
<RETURNS>void            </RETURNS>
GtkBindingSet       *binding_set, guint                keyval, GdkModifierType      modifiers
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_entry_add_signal</NAME>
<RETURNS>void            </RETURNS>
GtkBindingSet       *binding_set, guint                keyval, GdkModifierType      modifiers, const gchar         *signal_name, guint                n_args, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_entry_add_signall</NAME>
<RETURNS>void            </RETURNS>
GtkBindingSet       *binding_set, guint                keyval, GdkModifierType      modifiers, const gchar         *signal_name, GSList              *binding_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_entry_add_signal_from_string</NAME>
<RETURNS>GTokenType  </RETURNS>
GtkBindingSet       *binding_set, const gchar         *signal_desc
</FUNCTION>
<FUNCTION>
<NAME>gtk_binding_entry_remove</NAME>
<RETURNS>void            </RETURNS>
GtkBindingSet       *binding_set, guint                keyval, GdkModifierType      modifiers
</FUNCTION>
<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>
<FUNCTION>
<NAME>return</NAME>
<RETURNS>else</RETURNS>
GtkBitmask *) mask; } static inline void _gtk_bitmask_free (GtkBitmask *mask) { if (_gtk_bitmask_is_allocated (mask)) _gtk_allocated_bitmask_free (mask
</FUNCTION>
<FUNCTION>
<NAME>g_string_free</NAME>
<RETURNS>return  </RETURNS>
string, FALSE
</FUNCTION>
<FUNCTION>
<NAME>if</NAME>
<RETURNS>else  </RETURNS>
index_ < GTK_BITMASK_N_DIRECT_BITS) { gsize bits = _gtk_bitmask_to_bits (mask
</FUNCTION>
<VARIABLE>
<NAME>invert</NAME>
      gsize invert = (((gsize) 1) << end) - (((gsize) 1) << start);
</VARIABLE>
<VARIABLE>
<NAME>mask</NAME>
  return mask == _gtk_bitmask_from_bits (0);
</VARIABLE>
<USER_FUNCTION>
<NAME>GtkBookmarksChangedFunc</NAME>
<RETURNS>void </RETURNS>
gpointer data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BORDER</NAME>
#define GTK_TYPE_BORDER (gtk_border_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkBorder</NAME>
struct _GtkBorder
{
  gint16 left;
  gint16 right;
  gint16 top;
  gint16 bottom;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_border_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_border_new</NAME>
<RETURNS>GtkBorder  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_border_copy</NAME>
<RETURNS>GtkBorder  *</RETURNS>
const GtkBorder *border_
</FUNCTION>
<FUNCTION>
<NAME>gtk_border_free</NAME>
<RETURNS>void        </RETURNS>
GtkBorder       *border_
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BOX</NAME>
#define GTK_TYPE_BOX            (gtk_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BOX</NAME>
#define GTK_BOX(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BOX, GtkBox))
</MACRO>
<MACRO>
<NAME>GTK_BOX_CLASS</NAME>
#define GTK_BOX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_BOX, GtkBoxClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOX</NAME>
#define GTK_IS_BOX(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BOX))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOX_CLASS</NAME>
#define GTK_IS_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BOX))
</MACRO>
<MACRO>
<NAME>GTK_BOX_GET_CLASS</NAME>
#define GTK_BOX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BOX, GtkBoxClass))
</MACRO>
<STRUCT>
<NAME>GtkBox</NAME>
struct _GtkBox
{
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkBoxClass</NAME>
struct _GtkBoxClass
{
  GtkContainerClass 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_box_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_new</NAME>
<RETURNS>GtkWidget *  </RETURNS>
GtkOrientation  orientation, gint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_set_homogeneous</NAME>
<RETURNS>void         </RETURNS>
GtkBox         *box, gboolean        homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_get_homogeneous</NAME>
<RETURNS>gboolean     </RETURNS>
GtkBox         *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_set_spacing</NAME>
<RETURNS>void         </RETURNS>
GtkBox         *box, gint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_get_spacing</NAME>
<RETURNS>gint         </RETURNS>
GtkBox         *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_set_baseline_position</NAME>
<RETURNS>void         </RETURNS>
GtkBox             *box, GtkBaselinePosition position
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_get_baseline_position</NAME>
<RETURNS>GtkBaselinePosition  </RETURNS>
GtkBox         *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_box_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>GtkBuildableIface</NAME>
struct _GtkBuildableIface
{
  GTypeInterface g_iface;

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

  GObject *     (* get_internal_child)     (GtkBuildable  *buildable,
					    GtkBuilder    *builder,
					    const gchar   *childname);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_buildable_get_type</NAME>
<RETURNS>GType      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_set_name</NAME>
<RETURNS>void       </RETURNS>
GtkBuildable        *buildable, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_get_name</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkBuildable        *buildable
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_add_child</NAME>
<RETURNS>void       </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *type
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_set_buildable_property</NAME>
<RETURNS>void       </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, const gchar         *name, const GValue        *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_construct_child</NAME>
<RETURNS>GObject  * </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_custom_tag_start</NAME>
<RETURNS>gboolean   </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *tagname, GMarkupParser       *parser, gpointer            *data
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_custom_tag_end</NAME>
<RETURNS>void       </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *tagname, gpointer             data
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_custom_finished</NAME>
<RETURNS>void       </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, GObject             *child, const gchar         *tagname, gpointer             data
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_parser_finished</NAME>
<RETURNS>void       </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_buildable_get_internal_child</NAME>
<RETURNS>GObject  * </RETURNS>
GtkBuildable        *buildable, GtkBuilder          *builder, const gchar         *childname
</FUNCTION>
<STRUCT>
<NAME>GtkBuildable</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
} GtkBuilderError;
</ENUM>
<FUNCTION>
<NAME>gtk_builder_error_quark</NAME>
<RETURNS>GQuark  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkBuilder</NAME>
struct _GtkBuilder
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkBuilderClass</NAME>
struct _GtkBuilderClass
{
  GObjectClass parent_class;

  GType (* get_type_from_name) (GtkBuilder *builder,
                                const char *type_name);

  /* 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_builder_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new</NAME>
<RETURNS>GtkBuilder *  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_file</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, const gchar   *filename, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_resource</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, const gchar   *resource_path, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_from_string</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, const gchar   *buffer, gssize         length, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_file</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, const gchar   *filename, gchar        **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_resource</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, const gchar   *resource_path, gchar        **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_objects_from_string</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, const gchar   *buffer, gssize         length, gchar        **object_ids, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_object</NAME>
<RETURNS>GObject *     </RETURNS>
GtkBuilder    *builder, const gchar   *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_objects</NAME>
<RETURNS>GSList *      </RETURNS>
GtkBuilder    *builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_expose_object</NAME>
<RETURNS>void          </RETURNS>
GtkBuilder    *builder, const gchar   *name, GObject       *object
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_connect_signals</NAME>
<RETURNS>void          </RETURNS>
GtkBuilder    *builder, gpointer       user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_connect_signals_full</NAME>
<RETURNS>void          </RETURNS>
GtkBuilder    *builder, GtkBuilderConnectFunc func, gpointer       user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_set_translation_domain</NAME>
<RETURNS>void          </RETURNS>
GtkBuilder   	*builder, const gchar  	*domain
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_translation_domain</NAME>
<RETURNS>const gchar * </RETURNS>
GtkBuilder   	*builder
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_type_from_name</NAME>
<RETURNS>GType         </RETURNS>
GtkBuilder   	*builder, const char   	*type_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_value_from_string</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, GParamSpec   	*pspec, const gchar  	*string, GValue       	*value, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_value_from_string_type</NAME>
<RETURNS>gboolean      </RETURNS>
GtkBuilder    *builder, GType        	 type, const gchar  	*string, GValue       	*value, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_file</NAME>
<RETURNS>GtkBuilder  * </RETURNS>
const gchar   *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_resource</NAME>
<RETURNS>GtkBuilder  * </RETURNS>
const gchar   *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_new_from_string</NAME>
<RETURNS>GtkBuilder  * </RETURNS>
const gchar   *string, gssize         length
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_callback_symbol</NAME>
<RETURNS>void          </RETURNS>
GtkBuilder    *builder, const gchar   *callback_name, GCallback      callback_symbol
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_add_callback_symbols</NAME>
<RETURNS>void          </RETURNS>
GtkBuilder    *builder, const gchar   *first_callback_name, GCallback      first_callback_symbol, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_lookup_callback_symbol</NAME>
<RETURNS>GCallback     </RETURNS>
GtkBuilder    *builder, const gchar   *callback_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_set_application</NAME>
<RETURNS>void          </RETURNS>
GtkBuilder     *builder, GtkApplication *application
</FUNCTION>
<FUNCTION>
<NAME>gtk_builder_get_application</NAME>
<RETURNS>GtkApplication  * </RETURNS>
GtkBuilder     *builder
</FUNCTION>
<MACRO>
<NAME>GTK_BUILDER_WARN_INVALID_CHILD_TYPE</NAME>
#define GTK_BUILDER_WARN_INVALID_CHILD_TYPE(object, type) \
  g_warning ("'%s' is not a valid child type of '%s'", type, g_type_name (G_OBJECT_TYPE (object)))
</MACRO>
<FUNCTION>
<NAME>gtk_builder_extend_with_template</NAME>
<RETURNS>gboolean   </RETURNS>
GtkBuilder    *builder, GtkWidget     *widget, GType          template_type, const gchar   *buffer, gssize         length, GError       **error
</FUNCTION>
<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 >*/
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkButtonClass</NAME>
struct _GtkButtonClass
{
  GtkBinClass        parent_class;

  /*< public >*/

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

  /*< 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_button_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new</NAME>
<RETURNS>GtkWidget *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_with_label</NAME>
<RETURNS>GtkWidget *     </RETURNS>
const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_from_icon_name</NAME>
<RETURNS>GtkWidget *     </RETURNS>
const gchar    *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *     </RETURNS>
const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_clicked</NAME>
<RETURNS>void            </RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_relief</NAME>
<RETURNS>void                   </RETURNS>
GtkButton      *button, GtkReliefStyle  relief
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_relief</NAME>
<RETURNS>GtkReliefStyle         </RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_label</NAME>
<RETURNS>void                   </RETURNS>
GtkButton      *button, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_label</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_use_underline</NAME>
<RETURNS>void                   </RETURNS>
GtkButton      *button, gboolean        use_underline
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_use_underline</NAME>
<RETURNS>gboolean               </RETURNS>
GtkButton      *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_set_icon_name</NAME>
<RETURNS>void                   </RETURNS>
GtkButton      *button, const char     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_button_get_icon_name</NAME>
<RETURNS>const char  *          </RETURNS>
GtkButton      *button
</FUNCTION>
<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_CALENDAR_CLASS</NAME>
#define GTK_CALENDAR_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CALENDAR, GtkCalendarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CALENDAR</NAME>
#define GTK_IS_CALENDAR(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CALENDAR))
</MACRO>
<MACRO>
<NAME>GTK_IS_CALENDAR_CLASS</NAME>
#define GTK_IS_CALENDAR_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CALENDAR))
</MACRO>
<MACRO>
<NAME>GTK_CALENDAR_GET_CLASS</NAME>
#define GTK_CALENDAR_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CALENDAR, GtkCalendarClass))
</MACRO>
<ENUM>
<NAME>GtkCalendarDisplayOptions</NAME>
typedef enum
{
  GTK_CALENDAR_SHOW_HEADING		= 1 << 0,
  GTK_CALENDAR_SHOW_DAY_NAMES		= 1 << 1,
  GTK_CALENDAR_NO_MONTH_CHANGE		= 1 << 2,
  GTK_CALENDAR_SHOW_WEEK_NUMBERS	= 1 << 3,
  GTK_CALENDAR_SHOW_DETAILS		= 1 << 5
} GtkCalendarDisplayOptions;
</ENUM>
<USER_FUNCTION>
<NAME>GtkCalendarDetailFunc</NAME>
<RETURNS>gchar *</RETURNS>
GtkCalendar *calendar,
                                         guint        year,
                                         guint        month,
                                         guint        day,
                                         gpointer     user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkCalendar</NAME>
struct _GtkCalendar
{
  GtkWidget widget;

  GtkCalendarPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCalendarClass</NAME>
struct _GtkCalendarClass
{
  GtkWidgetClass parent_class;
  
  /* Signal handlers */
  void (* month_changed)		(GtkCalendar *calendar);
  void (* day_selected)			(GtkCalendar *calendar);
  void (* day_selected_double_click)	(GtkCalendar *calendar);
  void (* prev_month)			(GtkCalendar *calendar);
  void (* next_month)			(GtkCalendar *calendar);
  void (* prev_year)			(GtkCalendar *calendar);
  void (* next_year)			(GtkCalendar *calendar);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<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_month</NAME>
<RETURNS>void        </RETURNS>
GtkCalendar *calendar, guint	      month, guint	      year
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_select_day</NAME>
<RETURNS>void 	   </RETURNS>
GtkCalendar *calendar, guint	      day
</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_display_options</NAME>
<RETURNS>void 	   </RETURNS>
GtkCalendar    	      *calendar, GtkCalendarDisplayOptions flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_display_options</NAME>
<RETURNS>GtkCalendarDisplayOptions</RETURNS>
GtkCalendar   	      *calendar
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_date</NAME>
<RETURNS>void 	   </RETURNS>
GtkCalendar *calendar, guint	     *year, guint	     *month, guint	     *day
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_set_detail_func</NAME>
<RETURNS>void        </RETURNS>
GtkCalendar           *calendar, GtkCalendarDetailFunc  func, gpointer               data, GDestroyNotify         destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_set_detail_width_chars</NAME>
<RETURNS>void        </RETURNS>
GtkCalendar    *calendar, gint            chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_set_detail_height_rows</NAME>
<RETURNS>void        </RETURNS>
GtkCalendar    *calendar, gint            rows
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_detail_width_chars</NAME>
<RETURNS>gint        </RETURNS>
GtkCalendar    *calendar
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_detail_height_rows</NAME>
<RETURNS>gint        </RETURNS>
GtkCalendar    *calendar
</FUNCTION>
<FUNCTION>
<NAME>gtk_calendar_get_day_is_marked</NAME>
<RETURNS>gboolean    </RETURNS>
GtkCalendar    *calendar, guint           day
</FUNCTION>
<STRUCT>
<NAME>GtkCalendarPrivate</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;

  GtkCellAreaPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellAreaClass</NAME>
struct _GtkCellAreaClass
{
  /*< private >*/
  GInitiallyUnownedClass parent_class;

  /*< public >*/

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

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

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

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

  /*< private >*/

  /* 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_cell_area_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_add</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_remove</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_has_renderer</NAME>
<RETURNS>gboolean               </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_foreach</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellCallback       callback, gpointer              callback_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_foreach_alloc</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, const GdkRectangle   *cell_area, const GdkRectangle   *background_area, GtkCellAllocCallback  callback, gpointer              callback_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_event</NAME>
<RETURNS>gint                   </RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, GdkEvent             *event, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_snapshot</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, GtkSnapshot          *snapshot, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags, gboolean              paint_focus
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_cell_allocation</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, GtkCellRenderer      *renderer, const GdkRectangle   *cell_area, GdkRectangle         *allocation
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_cell_at_position</NAME>
<RETURNS>GtkCellRenderer       *</RETURNS>
GtkCellArea          *area, GtkCellAreaContext   *context, GtkWidget            *widget, const GdkRectangle   *cell_area, gint                  x, gint                  y, GdkRectangle         *alloc_area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_create_context</NAME>
<RETURNS>GtkCellAreaContext    *</RETURNS>
GtkCellArea        *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_copy_context</NAME>
<RETURNS>GtkCellAreaContext    *</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_request_mode</NAME>
<RETURNS>GtkSizeRequestMode     </RETURNS>
GtkCellArea        *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_width</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_height_for_width</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint                width, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_height</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_preferred_width_for_height</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context, GtkWidget          *widget, gint                height, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_current_path_string</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkCellArea        *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_apply_attributes</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkTreeModel       *tree_model, GtkTreeIter        *iter, gboolean            is_expander, gboolean            is_expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_connect</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *attribute, gint                column
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_disconnect</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *attribute
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_attribute_get_column</NAME>
<RETURNS>gint                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *attribute
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_class_install_cell_property</NAME>
<RETURNS>void                   </RETURNS>
GtkCellAreaClass   *aclass, guint               property_id, GParamSpec         *pspec
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_class_find_cell_property</NAME>
<RETURNS>GParamSpec *           </RETURNS>
GtkCellAreaClass   *aclass, const gchar        *property_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_class_list_cell_properties</NAME>
<RETURNS>GParamSpec **          </RETURNS>
GtkCellAreaClass   *aclass, guint                   *n_properties
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_add_with_properties</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar     *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_prop_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set_valist</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_property_name, va_list             var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get_valist</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *first_property_name, va_list             var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_set_property</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *property_name, const GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_cell_get_property</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, const gchar        *property_name, GValue             *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_is_activatable</NAME>
<RETURNS>gboolean               </RETURNS>
GtkCellArea         *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_activate</NAME>
<RETURNS>gboolean               </RETURNS>
GtkCellArea         *area, GtkCellAreaContext  *context, GtkWidget           *widget, const GdkRectangle  *cell_area, GtkCellRendererState flags, gboolean             edit_only
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_focus</NAME>
<RETURNS>gboolean               </RETURNS>
GtkCellArea         *area, GtkDirectionType     direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_set_focus_cell</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_focus_cell</NAME>
<RETURNS>GtkCellRenderer       *</RETURNS>
GtkCellArea          *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_add_focus_sibling</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer, GtkCellRenderer      *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_remove_focus_sibling</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer, GtkCellRenderer      *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_is_focus_sibling</NAME>
<RETURNS>gboolean               </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer, GtkCellRenderer      *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_focus_siblings</NAME>
<RETURNS>const GList  *         </RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_focus_from_sibling</NAME>
<RETURNS>GtkCellRenderer       *</RETURNS>
GtkCellArea          *area, GtkCellRenderer      *renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_edited_cell</NAME>
<RETURNS>GtkCellRenderer       *</RETURNS>
GtkCellArea          *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_get_edit_widget</NAME>
<RETURNS>GtkCellEditable       *</RETURNS>
GtkCellArea          *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_activate_cell</NAME>
<RETURNS>gboolean               </RETURNS>
GtkCellArea          *area, GtkWidget            *widget, GtkCellRenderer      *renderer, GdkEvent             *event, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_stop_editing</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea          *area, gboolean              canceled
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_inner_cell_area</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkWidget          *widget, const GdkRectangle *cell_area, GdkRectangle       *inner_area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_request_renderer</NAME>
<RETURNS>void                   </RETURNS>
GtkCellArea        *area, GtkCellRenderer    *renderer, GtkOrientation      orientation, GtkWidget          *widget, gint                for_size, gint               *minimum_size, gint               *natural_size
</FUNCTION>
<STRUCT>
<NAME>GtkCellAreaContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCellAreaPrivate</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_CELL_AREA_BOX_CLASS</NAME>
#define GTK_CELL_AREA_BOX_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBoxClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_AREA_BOX_CLASS</NAME>
#define GTK_IS_CELL_AREA_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_AREA_BOX))
</MACRO>
<MACRO>
<NAME>GTK_CELL_AREA_BOX_GET_CLASS</NAME>
#define GTK_CELL_AREA_BOX_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_AREA_BOX, GtkCellAreaBoxClass))
</MACRO>
<STRUCT>
<NAME>GtkCellAreaBox</NAME>
struct _GtkCellAreaBox
{
  /*< private >*/
  GtkCellArea parent_instance;

  GtkCellAreaBoxPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellAreaBoxClass</NAME>
struct _GtkCellAreaBoxClass
{
  /*< private >*/
  GtkCellAreaClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_area_box_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_new</NAME>
<RETURNS>GtkCellArea  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_pack_start</NAME>
<RETURNS>void          </RETURNS>
GtkCellAreaBox  *box, GtkCellRenderer *renderer, gboolean         expand, gboolean         align, gboolean         fixed
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_pack_end</NAME>
<RETURNS>void          </RETURNS>
GtkCellAreaBox  *box, GtkCellRenderer *renderer, gboolean         expand, gboolean         align, gboolean         fixed
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_get_spacing</NAME>
<RETURNS>gint          </RETURNS>
GtkCellAreaBox  *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_area_box_set_spacing</NAME>
<RETURNS>void          </RETURNS>
GtkCellAreaBox  *box, gint             spacing
</FUNCTION>
<STRUCT>
<NAME>GtkCellAreaBoxPrivate</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;

  GtkCellAreaContextPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellAreaContextClass</NAME>
struct _GtkCellAreaContextClass
{
  /*< private >*/
  GObjectClass parent_class;

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

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

  /*< public >*/

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

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

  /*< public >*/

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

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

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

  /*< public >*/

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

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

  /*< private >*/

  GtkCellRendererClassPrivate *priv;

  /* Padding for future expansion */
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_request_mode</NAME>
<RETURNS>GtkSizeRequestMode  </RETURNS>
GtkCellRenderer    *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_width</NAME>
<RETURNS>void                </RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint               *minimum_size, gint               *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_height_for_width</NAME>
<RETURNS>void                </RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint                width, gint               *minimum_height, gint               *natural_height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_height</NAME>
<RETURNS>void                </RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint               *minimum_size, gint               *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_width_for_height</NAME>
<RETURNS>void                </RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, gint                height, gint               *minimum_width, gint               *natural_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_preferred_size</NAME>
<RETURNS>void                </RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, GtkRequisition     *minimum_size, GtkRequisition     *natural_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_aligned_area</NAME>
<RETURNS>void                </RETURNS>
GtkCellRenderer    *cell, GtkWidget          *widget, GtkCellRendererState flags, const GdkRectangle *cell_area, GdkRectangle       *aligned_area
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_snapshot</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, GtkSnapshot          *snapshot, GtkWidget            *widget, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_activate</NAME>
<RETURNS>gboolean          </RETURNS>
GtkCellRenderer      *cell, GdkEvent             *event, GtkWidget            *widget, const gchar          *path, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_start_editing</NAME>
<RETURNS>GtkCellEditable  *</RETURNS>
GtkCellRenderer      *cell, GdkEvent             *event, GtkWidget            *widget, const gchar          *path, const GdkRectangle   *background_area, const GdkRectangle   *cell_area, GtkCellRendererState  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_fixed_size</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gint                  width, gint                  height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_fixed_size</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gint                 *width, gint                 *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_alignment</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gfloat                xalign, gfloat                yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_alignment</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gfloat               *xalign, gfloat               *yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_padding</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gint                  xpad, gint                  ypad
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_padding</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gint                 *xpad, gint                 *ypad
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_visible</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gboolean              visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_visible</NAME>
<RETURNS>gboolean          </RETURNS>
GtkCellRenderer      *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_set_sensitive</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gboolean              sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_sensitive</NAME>
<RETURNS>gboolean          </RETURNS>
GtkCellRenderer      *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_is_activatable</NAME>
<RETURNS>gboolean          </RETURNS>
GtkCellRenderer      *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_stop_editing</NAME>
<RETURNS>void              </RETURNS>
GtkCellRenderer      *cell, gboolean              canceled
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_get_state</NAME>
<RETURNS>GtkStateFlags    </RETURNS>
GtkCellRenderer      *cell, GtkWidget            *widget, GtkCellRendererState  cell_state
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_class_set_accessible_type</NAME>
<RETURNS>void  </RETURNS>
GtkCellRendererClass *renderer_class, GType                 type
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererClassPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_ACCEL</NAME>
#define GTK_TYPE_CELL_RENDERER_ACCEL            (gtk_cell_renderer_accel_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_ACCEL</NAME>
#define GTK_CELL_RENDERER_ACCEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_ACCEL, GtkCellRendererAccel))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_ACCEL_CLASS</NAME>
#define GTK_CELL_RENDERER_ACCEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_ACCEL, GtkCellRendererAccelClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_ACCEL_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_ACCEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_ACCEL))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_ACCEL_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_ACCEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_ACCEL, GtkCellRendererAccelClass))
</MACRO>
<ENUM>
<NAME>GtkCellRendererAccelMode</NAME>
typedef enum
{
  GTK_CELL_RENDERER_ACCEL_MODE_GTK,
  GTK_CELL_RENDERER_ACCEL_MODE_OTHER
} GtkCellRendererAccelMode;
</ENUM>
<STRUCT>
<NAME>GtkCellRendererAccel</NAME>
struct _GtkCellRendererAccel
{
  GtkCellRendererText parent;

  /*< private >*/
  GtkCellRendererAccelPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererAccelClass</NAME>
struct _GtkCellRendererAccelClass
{
  GtkCellRendererTextClass parent_class;

  void (* accel_edited)  (GtkCellRendererAccel *accel,
		 	  const gchar          *path_string,
			  guint                 accel_key,
			  GdkModifierType       accel_mods,
			  guint                 hardware_keycode);

  void (* accel_cleared) (GtkCellRendererAccel *accel,
			  const gchar          *path_string);

  /* Padding for future expansion */
  void (*_gtk_reserved0) (void);
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<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>GtkCellRendererAccelPrivate</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_CELL_RENDERER_COMBO_CLASS</NAME>
#define GTK_CELL_RENDERER_COMBO_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_COMBO, GtkCellRendererComboClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_COMBO_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_COMBO_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_COMBO))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_COMBO_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_COMBO_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_COMBO, GtkCellRendererTextClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererCombo</NAME>
struct _GtkCellRendererCombo
{
  GtkCellRendererText parent;

  /*< private >*/
  GtkCellRendererComboPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererComboClass</NAME>
struct _GtkCellRendererComboClass
{
  GtkCellRendererTextClass parent;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_combo_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_combo_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererComboPrivate</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_CELL_RENDERER_PIXBUF_CLASS</NAME>
#define GTK_CELL_RENDERER_PIXBUF_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_PIXBUF, GtkCellRendererPixbufClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_PIXBUF_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_PIXBUF_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_PIXBUF))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_PIXBUF_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_PIXBUF_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_PIXBUF, GtkCellRendererPixbufClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererPixbuf</NAME>
struct _GtkCellRendererPixbuf
{
  GtkCellRenderer parent;

  /*< private >*/
  GtkCellRendererPixbufPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererPixbufClass</NAME>
struct _GtkCellRendererPixbufClass
{
  GtkCellRendererClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_pixbuf_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_pixbuf_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererPixbufPrivate</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_CELL_RENDERER_PROGRESS_CLASS</NAME>
#define GTK_CELL_RENDERER_PROGRESS_CLASS(klass)	  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_PROGRESS, GtkCellRendererProgressClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_PROGRESS_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_PROGRESS))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_PROGRESS_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_PROGRESS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_PROGRESS, GtkCellRendererProgressClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererProgress</NAME>
struct _GtkCellRendererProgress
{
  GtkCellRenderer parent_instance;

  /*< private >*/
  GtkCellRendererProgressPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererProgressClass</NAME>
struct _GtkCellRendererProgressClass
{
  GtkCellRendererClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_progress_get_type</NAME>
<RETURNS>GType 		 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_progress_new</NAME>
<RETURNS>GtkCellRenderer * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererProgressPrivate</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_CELL_RENDERER_SPIN_CLASS</NAME>
#define GTK_CELL_RENDERER_SPIN_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_SPIN, GtkCellRendererSpinClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_SPIN_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_SPIN_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_SPIN))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_SPIN_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_SPIN_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_SPIN, GtkCellRendererTextClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererSpin</NAME>
struct _GtkCellRendererSpin
{
  GtkCellRendererText parent;

  /*< private >*/
  GtkCellRendererSpinPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererSpinClass</NAME>
struct _GtkCellRendererSpinClass
{
  GtkCellRendererTextClass parent;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_spin_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_spin_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererSpinPrivate</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_CELL_RENDERER_SPINNER_CLASS</NAME>
#define GTK_CELL_RENDERER_SPINNER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_SPINNER, GtkCellRendererSpinnerClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_SPINNER_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_SPINNER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_SPINNER))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_SPINNER_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_SPINNER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_SPINNER, GtkCellRendererSpinnerClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererSpinner</NAME>
struct _GtkCellRendererSpinner
{
  GtkCellRenderer                parent;

  /*< private >*/
  GtkCellRendererSpinnerPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererSpinnerClass</NAME>
struct _GtkCellRendererSpinnerClass
{
  GtkCellRendererClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_spinner_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_spinner_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererSpinnerPrivate</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;

  /*< private >*/
  GtkCellRendererTextPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererTextClass</NAME>
struct _GtkCellRendererTextClass
{
  GtkCellRendererClass parent_class;

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_text_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_text_new</NAME>
<RETURNS>GtkCellRenderer  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_renderer_text_set_fixed_height_from_font</NAME>
<RETURNS>void              </RETURNS>
GtkCellRendererText *renderer, gint                 number_of_rows
</FUNCTION>
<STRUCT>
<NAME>GtkCellRendererTextPrivate</NAME>
</STRUCT>
<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_CELL_RENDERER_TOGGLE_CLASS</NAME>
#define GTK_CELL_RENDERER_TOGGLE_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_TOGGLE, GtkCellRendererToggleClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_TOGGLE_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_TOGGLE_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_TOGGLE))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_TOGGLE_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_TOGGLE_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_TOGGLE, GtkCellRendererToggleClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererToggle</NAME>
struct _GtkCellRendererToggle
{
  GtkCellRenderer parent;

  /*< private >*/
  GtkCellRendererTogglePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellRendererToggleClass</NAME>
struct _GtkCellRendererToggleClass
{
  GtkCellRendererClass parent_class;

  void (* toggled) (GtkCellRendererToggle *cell_renderer_toggle,
		    const gchar                 *path);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_cell_renderer_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>GtkCellRendererTogglePrivate</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_CELL_VIEW_CLASS</NAME>
#define GTK_CELL_VIEW_CLASS(vtable)       (G_TYPE_CHECK_CLASS_CAST ((vtable), GTK_TYPE_CELL_VIEW, GtkCellViewClass))
</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>
<MACRO>
<NAME>GTK_IS_CELL_VIEW_CLASS</NAME>
#define GTK_IS_CELL_VIEW_CLASS(vtable)    (G_TYPE_CHECK_CLASS_TYPE ((vtable), GTK_TYPE_CELL_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_CELL_VIEW_GET_CLASS</NAME>
#define GTK_CELL_VIEW_GET_CLASS(inst)     (G_TYPE_INSTANCE_GET_CLASS ((inst), GTK_TYPE_CELL_VIEW, GtkCellViewClass))
</MACRO>
<STRUCT>
<NAME>GtkCellView</NAME>
struct _GtkCellView
{
  GtkWidget parent_instance;

  /*< private >*/
  GtkCellViewPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCellViewClass</NAME>
struct _GtkCellViewClass
{
  GtkWidgetClass 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_cell_view_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new</NAME>
<RETURNS>GtkWidget         *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_context</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GtkCellArea        *area, GtkCellAreaContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_text</NAME>
<RETURNS>GtkWidget         *</RETURNS>
const gchar     *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_markup</NAME>
<RETURNS>GtkWidget         *</RETURNS>
const gchar     *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_new_with_texture</NAME>
<RETURNS>GtkWidget         *</RETURNS>
GdkTexture      *texture
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_model</NAME>
<RETURNS>void               </RETURNS>
GtkCellView     *cell_view, GtkTreeModel    *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_model</NAME>
<RETURNS>GtkTreeModel      *</RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_displayed_row</NAME>
<RETURNS>void               </RETURNS>
GtkCellView     *cell_view, GtkTreePath     *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_displayed_row</NAME>
<RETURNS>GtkTreePath       *</RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_draw_sensitive</NAME>
<RETURNS>gboolean           </RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_draw_sensitive</NAME>
<RETURNS>void               </RETURNS>
GtkCellView     *cell_view, gboolean         draw_sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_get_fit_model</NAME>
<RETURNS>gboolean           </RETURNS>
GtkCellView     *cell_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_cell_view_set_fit_model</NAME>
<RETURNS>void               </RETURNS>
GtkCellView     *cell_view, gboolean         fit_model
</FUNCTION>
<STRUCT>
<NAME>GtkCellViewPrivate</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_CHECK_BUTTON</NAME>
#define GTK_TYPE_CHECK_BUTTON                  (gtk_check_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CHECK_BUTTON</NAME>
#define GTK_CHECK_BUTTON(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButton))
</MACRO>
<MACRO>
<NAME>GTK_CHECK_BUTTON_CLASS</NAME>
#define GTK_CHECK_BUTTON_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CHECK_BUTTON</NAME>
#define GTK_IS_CHECK_BUTTON(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_CHECK_BUTTON_CLASS</NAME>
#define GTK_IS_CHECK_BUTTON_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CHECK_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_CHECK_BUTTON_GET_CLASS</NAME>
#define GTK_CHECK_BUTTON_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CHECK_BUTTON, GtkCheckButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkCheckButton</NAME>
struct _GtkCheckButton
{
  GtkToggleButton toggle_button;
};
</STRUCT>
<STRUCT>
<NAME>GtkCheckButtonClass</NAME>
struct _GtkCheckButtonClass
{
  GtkToggleButtonClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_check_button_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_new_with_label</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_draw_indicator</NAME>
<RETURNS>void        </RETURNS>
GtkCheckButton *check_button, gboolean        draw_indicator
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_get_draw_indicator</NAME>
<RETURNS>gboolean    </RETURNS>
GtkCheckButton *check_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_set_inconsistent</NAME>
<RETURNS>void        </RETURNS>
GtkCheckButton *check_button, gboolean        inconsistent
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_button_get_inconsistent</NAME>
<RETURNS>gboolean    </RETURNS>
GtkCheckButton *check_button
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CHECK_MENU_ITEM</NAME>
#define GTK_TYPE_CHECK_MENU_ITEM            (gtk_check_menu_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CHECK_MENU_ITEM</NAME>
#define GTK_CHECK_MENU_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CHECK_MENU_ITEM, GtkCheckMenuItem))
</MACRO>
<MACRO>
<NAME>GTK_CHECK_MENU_ITEM_CLASS</NAME>
#define GTK_CHECK_MENU_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CHECK_MENU_ITEM, GtkCheckMenuItemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CHECK_MENU_ITEM</NAME>
#define GTK_IS_CHECK_MENU_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CHECK_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_CHECK_MENU_ITEM_CLASS</NAME>
#define GTK_IS_CHECK_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CHECK_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_CHECK_MENU_ITEM_GET_CLASS</NAME>
#define GTK_CHECK_MENU_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CHECK_MENU_ITEM, GtkCheckMenuItemClass))
</MACRO>
<STRUCT>
<NAME>GtkCheckMenuItem</NAME>
struct _GtkCheckMenuItem
{
  GtkMenuItem menu_item;

  /*< private >*/
  GtkCheckMenuItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCheckMenuItemClass</NAME>
struct _GtkCheckMenuItemClass
{
  GtkMenuItemClass parent_class;

  /*< public >*/

  void (* toggled)	        (GtkCheckMenuItem *check_menu_item);

  /*< 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_check_menu_item_get_type</NAME>
<RETURNS>GType 	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_new_with_label</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_new_with_mnemonic</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_set_active</NAME>
<RETURNS>void        </RETURNS>
GtkCheckMenuItem *check_menu_item, gboolean          is_active
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_get_active</NAME>
<RETURNS>gboolean    </RETURNS>
GtkCheckMenuItem *check_menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_toggled</NAME>
<RETURNS>void        </RETURNS>
GtkCheckMenuItem *check_menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_set_inconsistent</NAME>
<RETURNS>void        </RETURNS>
GtkCheckMenuItem *check_menu_item, gboolean          setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_get_inconsistent</NAME>
<RETURNS>gboolean    </RETURNS>
GtkCheckMenuItem *check_menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_set_draw_as_radio</NAME>
<RETURNS>void        </RETURNS>
GtkCheckMenuItem *check_menu_item, gboolean          draw_as_radio
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_menu_item_get_draw_as_radio</NAME>
<RETURNS>gboolean    </RETURNS>
GtkCheckMenuItem *check_menu_item
</FUNCTION>
<STRUCT>
<NAME>GtkCheckMenuItemPrivate</NAME>
</STRUCT>
<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_COLOR_BUTTON_CLASS</NAME>
#define GTK_COLOR_BUTTON_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_BUTTON, GtkColorButtonClass))
</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>
<MACRO>
<NAME>GTK_IS_COLOR_BUTTON_CLASS</NAME>
#define GTK_IS_COLOR_BUTTON_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_BUTTON_GET_CLASS</NAME>
#define GTK_COLOR_BUTTON_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_BUTTON, GtkColorButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkColorButton</NAME>
struct _GtkColorButton {
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkColorButtonClass</NAME>
struct _GtkColorButtonClass {
  GtkWidgetClass parent_class;

  void (* color_set) (GtkColorButton *cp);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_color_button_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_new</NAME>
<RETURNS>GtkWidget  *  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_new_with_rgba</NAME>
<RETURNS>GtkWidget  *  </RETURNS>
const GdkRGBA  *rgba
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_set_title</NAME>
<RETURNS>void          </RETURNS>
GtkColorButton *button, const gchar    *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_button_get_title</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkColorButton *button
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_COLOR_CHOOSER</NAME>
#define GTK_TYPE_COLOR_CHOOSER                  (gtk_color_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER</NAME>
#define GTK_COLOR_CHOOSER(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_CHOOSER, GtkColorChooser))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_CHOOSER</NAME>
#define GTK_IS_COLOR_CHOOSER(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_CHOOSER))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_GET_IFACE</NAME>
#define GTK_COLOR_CHOOSER_GET_IFACE(inst)       (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_COLOR_CHOOSER, GtkColorChooserInterface))
</MACRO>
<STRUCT>
<NAME>GtkColorChooserInterface</NAME>
struct _GtkColorChooserInterface
{
  GTypeInterface base_interface;

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

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

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

  /* Padding */
  gpointer padding[12];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_color_chooser_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_get_rgba</NAME>
<RETURNS>void      </RETURNS>
GtkColorChooser *chooser, GdkRGBA         *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_set_rgba</NAME>
<RETURNS>void      </RETURNS>
GtkColorChooser *chooser, const GdkRGBA   *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_get_use_alpha</NAME>
<RETURNS>gboolean  </RETURNS>
GtkColorChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_set_use_alpha</NAME>
<RETURNS>void      </RETURNS>
GtkColorChooser *chooser, gboolean         use_alpha
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_add_palette</NAME>
<RETURNS>void      </RETURNS>
GtkColorChooser *chooser, GtkOrientation   orientation, gint             colors_per_line, gint             n_colors, GdkRGBA         *colors
</FUNCTION>
<STRUCT>
<NAME>GtkColorChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_CHOOSER_DIALOG</NAME>
#define GTK_TYPE_COLOR_CHOOSER_DIALOG              (gtk_color_chooser_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_DIALOG</NAME>
#define GTK_COLOR_CHOOSER_DIALOG(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_CHOOSER_DIALOG, GtkColorChooserDialog))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_COLOR_CHOOSER_DIALOG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_CHOOSER_DIALOG, GtkColorChooserDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_COLOR_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_IS_COLOR_CHOOSER_DIALOG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_CHOOSER_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_DIALOG_GET_CLASS</NAME>
#define GTK_COLOR_CHOOSER_DIALOG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_CHOOSER_DIALOG, GtkColorChooserDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkColorChooserDialog</NAME>
struct _GtkColorChooserDialog
{
  GtkDialog parent_instance;

  /*< private >*/
  GtkColorChooserDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkColorChooserDialogClass</NAME>
struct _GtkColorChooserDialogClass
{
  GtkDialogClass 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_color_chooser_dialog_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_color_chooser_dialog_new</NAME>
<RETURNS>GtkWidget  * </RETURNS>
const gchar *title, GtkWindow   *parent
</FUNCTION>
<STRUCT>
<NAME>GtkColorChooserDialogPrivate</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_COLOR_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_COLOR_CHOOSER_WIDGET_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_CHOOSER_WIDGET, GtkColorChooserWidgetClass))
</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>
<MACRO>
<NAME>GTK_IS_COLOR_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_IS_COLOR_CHOOSER_WIDGET_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_CHOOSER_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_CHOOSER_WIDGET_GET_CLASS</NAME>
#define GTK_COLOR_CHOOSER_WIDGET_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_CHOOSER_WIDGET, GtkColorChooserWidgetClass))
</MACRO>
<STRUCT>
<NAME>GtkColorChooserWidget</NAME>
struct _GtkColorChooserWidget
{
  GtkBox parent_instance;

  /*< private >*/
  GtkColorChooserWidgetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkColorChooserWidgetClass</NAME>
struct _GtkColorChooserWidgetClass
{
  GtkBoxClass parent_class;

  /*< 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);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<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>GtkColorChooserWidgetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_PICKER_KWIN</NAME>
#define GTK_TYPE_COLOR_PICKER_KWIN gtk_color_picker_kwin_get_type ()
</MACRO>
<FUNCTION>
<NAME>gtk_color_picker_kwin_new</NAME>
<RETURNS>GtkColorPicker  * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkColorPickerKwin</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_PICKER_PORTAL</NAME>
#define GTK_TYPE_COLOR_PICKER_PORTAL gtk_color_picker_portal_get_type ()
</MACRO>
<FUNCTION>
<NAME>gtk_color_picker_portal_new</NAME>
<RETURNS>GtkColorPicker  * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkColorPickerPortal</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_PICKER</NAME>
#define GTK_TYPE_COLOR_PICKER             (gtk_color_picker_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_PICKER</NAME>
#define GTK_COLOR_PICKER(o)               (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_COLOR_PICKER, GtkColorPicker))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_PICKER</NAME>
#define GTK_IS_COLOR_PICKER(o)            (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_COLOR_PICKER))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_PICKER_GET_INTERFACE</NAME>
#define GTK_COLOR_PICKER_GET_INTERFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), GTK_TYPE_COLOR_PICKER, GtkColorPickerInterface))
</MACRO>
<STRUCT>
<NAME>GtkColorPickerInterface</NAME>
struct _GtkColorPickerInterface {
  GTypeInterface g_iface;

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

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

  /*< public >*/

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

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_combo_box_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new</NAME>
<RETURNS>GtkWidget     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new_with_entry</NAME>
<RETURNS>GtkWidget     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new_with_model</NAME>
<RETURNS>GtkWidget     *</RETURNS>
GtkTreeModel *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_new_with_model_and_entry</NAME>
<RETURNS>GtkWidget     *</RETURNS>
GtkTreeModel *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_active</NAME>
<RETURNS>gint           </RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active</NAME>
<RETURNS>void           </RETURNS>
GtkComboBox     *combo_box, gint             index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_active_iter</NAME>
<RETURNS>gboolean       </RETURNS>
GtkComboBox     *combo_box, GtkTreeIter     *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active_iter</NAME>
<RETURNS>void           </RETURNS>
GtkComboBox     *combo_box, GtkTreeIter     *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_model</NAME>
<RETURNS>void           </RETURNS>
GtkComboBox     *combo_box, GtkTreeModel    *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_model</NAME>
<RETURNS>GtkTreeModel  *</RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_row_separator_func</NAME>
<RETURNS>GtkTreeViewRowSeparatorFunc  </RETURNS>
GtkComboBox                *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_row_separator_func</NAME>
<RETURNS>void                         </RETURNS>
GtkComboBox                *combo_box, GtkTreeViewRowSeparatorFunc func, gpointer                    data, GDestroyNotify              destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_button_sensitivity</NAME>
<RETURNS>void                </RETURNS>
GtkComboBox        *combo_box, GtkSensitivityType  sensitivity
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_button_sensitivity</NAME>
<RETURNS>GtkSensitivityType  </RETURNS>
GtkComboBox        *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_has_entry</NAME>
<RETURNS>gboolean            </RETURNS>
GtkComboBox        *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_entry_text_column</NAME>
<RETURNS>void                </RETURNS>
GtkComboBox        *combo_box, gint                text_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_entry_text_column</NAME>
<RETURNS>gint                </RETURNS>
GtkComboBox        *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_popup_fixed_width</NAME>
<RETURNS>void                </RETURNS>
GtkComboBox      *combo_box, gboolean          fixed
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_popup_fixed_width</NAME>
<RETURNS>gboolean            </RETURNS>
GtkComboBox      *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_popup</NAME>
<RETURNS>void           </RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_popup_for_device</NAME>
<RETURNS>void           </RETURNS>
GtkComboBox     *combo_box, GdkDevice       *device
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_popdown</NAME>
<RETURNS>void           </RETURNS>
GtkComboBox     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_popup_accessible</NAME>
<RETURNS>AtkObject *    </RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_id_column</NAME>
<RETURNS>gint           </RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_id_column</NAME>
<RETURNS>void           </RETURNS>
GtkComboBox *combo_box, gint         id_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_get_active_id</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkComboBox *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_set_active_id</NAME>
<RETURNS>gboolean       </RETURNS>
GtkComboBox *combo_box, const gchar *active_id
</FUNCTION>
<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_COMBO_BOX_TEXT_CLASS</NAME>
#define GTK_COMBO_BOX_TEXT_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COMBO_BOX_TEXT, GtkComboBoxTextClass))
</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>
<MACRO>
<NAME>GTK_IS_COMBO_BOX_TEXT_CLASS</NAME>
#define GTK_IS_COMBO_BOX_TEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COMBO_BOX_TEXT))
</MACRO>
<MACRO>
<NAME>GTK_COMBO_BOX_TEXT_GET_CLASS</NAME>
#define GTK_COMBO_BOX_TEXT_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COMBO_BOX_TEXT, GtkComboBoxTextClass))
</MACRO>
<STRUCT>
<NAME>GtkComboBoxText</NAME>
struct _GtkComboBoxText
{
  /*< private >*/
  GtkComboBox parent_instance;

  GtkComboBoxTextPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkComboBoxTextClass</NAME>
struct _GtkComboBoxTextClass
{
  GtkComboBoxClass 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_combo_box_text_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_new</NAME>
<RETURNS>GtkWidget *    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_new_with_entry</NAME>
<RETURNS>GtkWidget *    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_append_text</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_insert_text</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box, gint                 position, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_prepend_text</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_remove</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box, gint                 position
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_remove_all</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_get_active_text</NAME>
<RETURNS>gchar         *</RETURNS>
GtkComboBoxText     *combo_box
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_insert</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box, gint                 position, const gchar         *id, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_append</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box, const gchar         *id, const gchar         *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_combo_box_text_prepend</NAME>
<RETURNS>void           </RETURNS>
GtkComboBoxText     *combo_box, const gchar         *id, const gchar         *text
</FUNCTION>
<STRUCT>
<NAME>GtkComboBoxTextPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkComposeTable</NAME>
struct _GtkComposeTable
{
  guint16 *data;
  gint max_seq_len;
  gint n_seqs;
  guint32 id;
};
</STRUCT>
<STRUCT>
<NAME>GtkComposeTableCompact</NAME>
struct _GtkComposeTableCompact
{
  const guint16 *data;
  gint max_seq_len;
  gint n_index_size;
  gint n_index_stride;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_compose_table_new_with_file</NAME>
<RETURNS>GtkComposeTable  * </RETURNS>
const gchar   *compose_file
</FUNCTION>
<FUNCTION>
<NAME>gtk_compose_table_list_add_array</NAME>
<RETURNS>GSList  *</RETURNS>
GSList        *compose_tables, const guint16 *data, gint           max_seq_len, gint           n_seqs
</FUNCTION>
<FUNCTION>
<NAME>gtk_compose_table_list_add_file</NAME>
<RETURNS>GSList  *</RETURNS>
GSList        *compose_tables, const gchar   *compose_file
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CONTAINER</NAME>
#define GTK_TYPE_CONTAINER              (gtk_container_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER</NAME>
#define GTK_CONTAINER(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER, GtkContainer))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_CLASS</NAME>
#define GTK_CONTAINER_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER, GtkContainerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER</NAME>
#define GTK_IS_CONTAINER(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER_CLASS</NAME>
#define GTK_IS_CONTAINER_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_GET_CLASS</NAME>
#define GTK_CONTAINER_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CONTAINER, GtkContainerClass))
</MACRO>
<STRUCT>
<NAME>GtkContainer</NAME>
struct _GtkContainer
{
  GtkWidget widget;
};
</STRUCT>
<STRUCT>
<NAME>GtkContainerClass</NAME>
struct _GtkContainerClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  void    (*add)       		(GtkContainer	 *container,
				 GtkWidget	 *widget);
  void    (*remove)    		(GtkContainer	 *container,
				 GtkWidget	 *widget);
  void    (*forall)    		(GtkContainer	 *container,
				 GtkCallback	  callback,
				 gpointer	  callback_data);
  void    (*set_focus_child)	(GtkContainer	 *container,
				 GtkWidget	 *child);
  GType   (*child_type)		(GtkContainer	 *container);
  GtkWidgetPath * (*get_path_for_child) (GtkContainer *container,
                                         GtkWidget    *child);


  /*< 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);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_container_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_add</NAME>
<RETURNS>void     </RETURNS>
GtkContainer	   *container, GtkWidget	   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_remove</NAME>
<RETURNS>void     </RETURNS>
GtkContainer	   *container, GtkWidget	   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_foreach</NAME>
<RETURNS>void      </RETURNS>
GtkContainer       *container, GtkCallback         callback, gpointer            callback_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_get_children</NAME>
<RETURNS>GList *   </RETURNS>
GtkContainer       *container
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_set_focus_vadjustment</NAME>
<RETURNS>void    </RETURNS>
GtkContainer     *container, GtkAdjustment    *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_get_focus_vadjustment</NAME>
<RETURNS>GtkAdjustment  *</RETURNS>
GtkContainer *container
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_set_focus_hadjustment</NAME>
<RETURNS>void    </RETURNS>
GtkContainer     *container, GtkAdjustment    *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_get_focus_hadjustment</NAME>
<RETURNS>GtkAdjustment  *</RETURNS>
GtkContainer *container
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_child_type</NAME>
<RETURNS>GType    </RETURNS>
GtkContainer     *container
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_forall</NAME>
<RETURNS>void     </RETURNS>
GtkContainer *container, GtkCallback   callback, gpointer	    callback_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_container_get_path_for_child</NAME>
<RETURNS>GtkWidgetPath  * </RETURNS>
GtkContainer      *container, GtkWidget         *child
</FUNCTION>
<STRUCT>
<NAME>GtkContainerPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_css_boxes_init</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes, GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_init_content_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes, GtkCssStyle *style, double       x, double       y, double       width, double       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_init_border_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes, GtkCssStyle *style, double       x, double       y, double       width, double       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_rect_grow</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect *dest, GskRoundedRect *src, GtkCssStyle    *style, int             top_property, int             right_property, int             bottom_property, int             left_property
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_rect_shrink</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect *dest, GskRoundedRect *src, GtkCssStyle    *style, int             top_property, int             right_property, int             bottom_property, int             left_property
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_rect</NAME>
<RETURNS>const graphene_rect_t  *</RETURNS>
GtkCssBoxes *boxes, GtkCssArea   area
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_border_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_padding_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_content_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_margin_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_outline_rect</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_margin_rect</NAME>
<RETURNS>const graphene_rect_t  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_border_rect</NAME>
<RETURNS>const graphene_rect_t  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_padding_rect</NAME>
<RETURNS>const graphene_rect_t  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_content_rect</NAME>
<RETURNS>const graphene_rect_t  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_outline_rect</NAME>
<RETURNS>const graphene_rect_t  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_clamp_border_radius</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_apply_border_radius</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect    *box, const GtkCssValue *top_left, const GtkCssValue *top_right, const GtkCssValue *bottom_right, const GtkCssValue *bottom_left
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_shrink_border_radius</NAME>
<RETURNS>void</RETURNS>
graphene_size_t       *dest, const graphene_size_t *src, double                 width, double                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_shrink_corners</NAME>
<RETURNS>void</RETURNS>
GskRoundedRect       *dest, const GskRoundedRect *src
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_border_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_padding_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_content_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_compute_outline_box</NAME>
<RETURNS>void</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_box</NAME>
<RETURNS>const GskRoundedRect  *</RETURNS>
GtkCssBoxes *boxes, GtkCssArea  area
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_border_box</NAME>
<RETURNS>const GskRoundedRect  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_padding_box</NAME>
<RETURNS>const GskRoundedRect  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_content_box</NAME>
<RETURNS>const GskRoundedRect  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_boxes_get_outline_box</NAME>
<RETURNS>const GskRoundedRect  *</RETURNS>
GtkCssBoxes *boxes
</FUNCTION>
<MACRO>
<NAME>GTK_CSS_AREA_MARGIN_BOX</NAME>
#define GTK_CSS_AREA_MARGIN_BOX (3)
</MACRO>
<MACRO>
<NAME>GTK_CSS_AREA_OUTLINE_BOX</NAME>
#define GTK_CSS_AREA_OUTLINE_BOX (4)
</MACRO>
<MACRO>
<NAME>GTK_CSS_AREA_N_BOXES</NAME>
#define GTK_CSS_AREA_N_BOXES (5)
</MACRO>
<STRUCT>
<NAME>GtkCssBoxes</NAME>
struct _GtkCssBoxes
{
  GtkCssStyle *style;
  GskRoundedRect box[GTK_CSS_AREA_N_BOXES];
  gboolean has_rect[GTK_CSS_AREA_N_BOXES]; /* TRUE if we have initialized just the bounds rect */
  gboolean has_box[GTK_CSS_AREA_N_BOXES]; /* TRUE if we have initialized the whole box */
};
</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_CSS_PROVIDER_CLASS</NAME>
#define GTK_CSS_PROVIDER_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST    ((c), GTK_TYPE_CSS_PROVIDER, GtkCssProviderClass))
</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>
<MACRO>
<NAME>GTK_IS_CSS_PROVIDER_CLASS</NAME>
#define GTK_IS_CSS_PROVIDER_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE    ((c), GTK_TYPE_CSS_PROVIDER))
</MACRO>
<MACRO>
<NAME>GTK_CSS_PROVIDER_GET_CLASS</NAME>
#define GTK_CSS_PROVIDER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS  ((o), GTK_TYPE_CSS_PROVIDER, GtkCssProviderClass))
</MACRO>
<STRUCT>
<NAME>GtkCssProvider</NAME>
struct _GtkCssProvider
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkCssProviderClass</NAME>
struct _GtkCssProviderClass
{
  GObjectClass parent_class;

  void (* parsing_error)                        (GtkCssProvider  *provider,
                                                 GtkCssSection   *section,
                                                 const GError *   error);

  /* Padding for future expansion */
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_css_provider_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_new</NAME>
<RETURNS>GtkCssProvider  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_to_string</NAME>
<RETURNS>char  *           </RETURNS>
GtkCssProvider  *provider
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_data</NAME>
<RETURNS>void              </RETURNS>
GtkCssProvider  *css_provider, const gchar     *data, gssize           length
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_file</NAME>
<RETURNS>void              </RETURNS>
GtkCssProvider  *css_provider, GFile           *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_path</NAME>
<RETURNS>void              </RETURNS>
GtkCssProvider  *css_provider, const gchar     *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_from_resource</NAME>
<RETURNS>void              </RETURNS>
GtkCssProvider *css_provider, const gchar    *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_provider_load_named</NAME>
<RETURNS>void              </RETURNS>
GtkCssProvider  *provider, const char      *name, const char      *variant
</FUNCTION>
<STRUCT>
<NAME>GtkCssProviderPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CUSTOM_LAYOUT</NAME>
#define GTK_TYPE_CUSTOM_LAYOUT (gtk_custom_layout_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkCustomRequestModeFunc</NAME>
<RETURNS>GtkSizeRequestMode </RETURNS>
GtkWidget *widget
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkCustomMeasureFunc</NAME>
<RETURNS>void </RETURNS>
GtkWidget      *widget,
                                       GtkOrientation  orientation,
                                       int             for_size,
                                       int            *minimum,
                                       int            *natural,
                                       int            *minimum_baseline,
                                       int            *natural_baseline
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkCustomAllocateFunc</NAME>
<RETURNS>void </RETURNS>
GtkWidget    *widget,
                                        int           width,
                                        int           height,
                                        int           baseline
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_custom_layout_new</NAME>
<RETURNS>GtkLayoutManager  *      </RETURNS>
GtkCustomRequestModeFunc request_mode, GtkCustomMeasureFunc     measure, GtkCustomAllocateFunc    allocate
</FUNCTION>
<STRUCT>
<NAME>GtkCustomLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG</NAME>
#define GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG                  (gtk_custom_paper_unix_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CUSTOM_PAPER_UNIX_DIALOG</NAME>
#define GTK_CUSTOM_PAPER_UNIX_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG, GtkCustomPaperUnixDialog))
</MACRO>
<MACRO>
<NAME>GTK_CUSTOM_PAPER_UNIX_DIALOG_CLASS</NAME>
#define GTK_CUSTOM_PAPER_UNIX_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG, GtkCustomPaperUnixDialogClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CUSTOM_PAPER_UNIX_DIALOG</NAME>
#define GTK_IS_CUSTOM_PAPER_UNIX_DIALOG(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_IS_CUSTOM_PAPER_UNIX_DIALOG_CLASS</NAME>
#define GTK_IS_CUSTOM_PAPER_UNIX_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_CUSTOM_PAPER_UNIX_DIALOG_GET_CLASS</NAME>
#define GTK_CUSTOM_PAPER_UNIX_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CUSTOM_PAPER_UNIX_DIALOG, GtkCustomPaperUnixDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkCustomPaperUnixDialog</NAME>
struct _GtkCustomPaperUnixDialog
{
  GtkDialog parent_instance;

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

  /*< private >*/

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

  /*< public >*/

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

  /* Keybinding signals */

  void (* close)    (GtkDialog *dialog);

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_dialog_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_new_with_buttons</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar     *title, GtkWindow       *parent, GtkDialogFlags   flags, const gchar     *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_action_widget</NAME>
<RETURNS>void        </RETURNS>
GtkDialog   *dialog, GtkWidget   *child, gint         response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_button</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkDialog   *dialog, const gchar *button_text, gint         response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_add_buttons</NAME>
<RETURNS>void        </RETURNS>
GtkDialog   *dialog, const gchar *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_set_response_sensitive</NAME>
<RETURNS>void  </RETURNS>
GtkDialog *dialog, gint       response_id, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_set_default_response</NAME>
<RETURNS>void  </RETURNS>
GtkDialog *dialog, gint       response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_widget_for_response</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkDialog *dialog, gint       response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_response_for_widget</NAME>
<RETURNS>gint  </RETURNS>
GtkDialog *dialog, GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_response</NAME>
<RETURNS>void  </RETURNS>
GtkDialog *dialog, gint       response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_run</NAME>
<RETURNS>gint  </RETURNS>
GtkDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_content_area</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GtkDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_dialog_get_header_bar</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GtkDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_get_data</NAME>
<RETURNS>void  </RETURNS>
GtkWidget      *widget, GdkDrop        *drop, GdkAtom         target
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_get_source_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_highlight</NAME>
<RETURNS>void  </RETURNS>
GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_unhighlight</NAME>
<RETURNS>void  </RETURNS>
GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_begin</NAME>
<RETURNS>GdkDrag  *</RETURNS>
GtkWidget         *widget, GdkDevice         *device, GdkContentFormats *targets, GdkDragAction      actions, gint               x, gint               y
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_cancel</NAME>
<RETURNS>void  </RETURNS>
GdkDrag *drag
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_set_icon_widget</NAME>
<RETURNS>void  </RETURNS>
GdkDrag        *drag, GtkWidget      *widget, gint            hot_x, gint            hot_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_set_icon_paintable</NAME>
<RETURNS>void  </RETURNS>
GdkDrag     *drag, GdkPaintable   *paintable, int             hot_x, int             hot_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_set_icon_name</NAME>
<RETURNS>void  </RETURNS>
GdkDrag        *drag, const gchar    *icon_name, gint            hot_x, gint            hot_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_set_icon_gicon</NAME>
<RETURNS>void  </RETURNS>
GdkDrag        *drag, GIcon          *icon, gint            hot_x, gint            hot_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_set_icon_default</NAME>
<RETURNS>void  </RETURNS>
GdkDrag       *drag
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_check_threshold</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWidget *widget, gint       start_x, gint       start_y, gint       current_x, gint       current_y
</FUNCTION>
<ENUM>
<NAME>GtkDestDefaults</NAME>
typedef enum {
  GTK_DEST_DEFAULT_MOTION     = 1 << 0,
  GTK_DEST_DEFAULT_HIGHLIGHT  = 1 << 1,
  GTK_DEST_DEFAULT_DROP       = 1 << 2,
  GTK_DEST_DEFAULT_ALL        = 0x07
} GtkDestDefaults;
</ENUM>
<FUNCTION>
<NAME>gtk_drag_dest_set</NAME>
<RETURNS>void  </RETURNS>
GtkWidget            *widget, GtkDestDefaults       flags, GdkContentFormats    *targets, GdkDragAction         actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_unset</NAME>
<RETURNS>void  </RETURNS>
GtkWidget          *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_find_target</NAME>
<RETURNS>const char  *            </RETURNS>
GtkWidget              *widget, GdkDrop                *drop, GdkContentFormats      *target_list
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_get_target_list</NAME>
<RETURNS>GdkContentFormats *      </RETURNS>
GtkWidget              *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_set_target_list</NAME>
<RETURNS>void            </RETURNS>
GtkWidget      *widget, GdkContentFormats  *target_list
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_add_text_targets</NAME>
<RETURNS>void            </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_add_image_targets</NAME>
<RETURNS>void            </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_add_uri_targets</NAME>
<RETURNS>void            </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_set_track_motion</NAME>
<RETURNS>void            </RETURNS>
GtkWidget *widget, gboolean   track_motion
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_dest_get_track_motion</NAME>
<RETURNS>gboolean        </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set</NAME>
<RETURNS>void  </RETURNS>
GtkWidget            *widget, GdkModifierType       start_button_mask, GdkContentFormats    *targets, GdkDragAction         actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_unset</NAME>
<RETURNS>void  </RETURNS>
GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_get_target_list</NAME>
<RETURNS>GdkContentFormats  *     </RETURNS>
GtkWidget         *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set_target_list</NAME>
<RETURNS>void                     </RETURNS>
GtkWidget         *widget, GdkContentFormats *target_list
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_add_text_targets</NAME>
<RETURNS>void            </RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_add_image_targets</NAME>
<RETURNS>void            </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_add_uri_targets</NAME>
<RETURNS>void            </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set_icon_name</NAME>
<RETURNS>void  </RETURNS>
GtkWidget       *widget, const gchar     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set_icon_gicon</NAME>
<RETURNS>void  </RETURNS>
GtkWidget       *widget, GIcon           *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_drag_source_set_icon_paintable</NAME>
<RETURNS>void  </RETURNS>
GtkWidget       *widget, GdkPaintable    *paintable
</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;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</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_EDITABLE</NAME>
#define GTK_TYPE_EDITABLE             (gtk_editable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_EDITABLE</NAME>
#define GTK_EDITABLE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_EDITABLE, GtkEditable))
</MACRO>
<MACRO>
<NAME>GTK_IS_EDITABLE</NAME>
#define GTK_IS_EDITABLE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EDITABLE))
</MACRO>
<MACRO>
<NAME>GTK_EDITABLE_GET_IFACE</NAME>
#define GTK_EDITABLE_GET_IFACE(inst)  (G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_EDITABLE, GtkEditableInterface))
</MACRO>
<STRUCT>
<NAME>GtkEditableInterface</NAME>
struct _GtkEditableInterface
{
  GTypeInterface                   base_iface;

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

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

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

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

  /*< private >*/

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

  /* Signals */

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

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

  /* Virtual Methods */

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

  guint        (*get_length)             (GtkEntryBuffer *buffer);

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
  void (*_gtk_reserved5) (void);
  void (*_gtk_reserved6) (void);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_entry_buffer_get_type</NAME>
<RETURNS>GType                      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_new</NAME>
<RETURNS>GtkEntryBuffer *           </RETURNS>
const gchar     *initial_chars, gint             n_initial_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_bytes</NAME>
<RETURNS>gsize                      </RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_length</NAME>
<RETURNS>guint                      </RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_text</NAME>
<RETURNS>const gchar *              </RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_set_text</NAME>
<RETURNS>void                       </RETURNS>
GtkEntryBuffer  *buffer, const gchar     *chars, gint             n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_set_max_length</NAME>
<RETURNS>void                       </RETURNS>
GtkEntryBuffer  *buffer, gint             max_length
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_get_max_length</NAME>
<RETURNS>gint                       </RETURNS>
GtkEntryBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_insert_text</NAME>
<RETURNS>guint                      </RETURNS>
GtkEntryBuffer  *buffer, guint            position, const gchar     *chars, gint             n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_delete_text</NAME>
<RETURNS>guint                      </RETURNS>
GtkEntryBuffer  *buffer, guint            position, gint             n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_emit_inserted_text</NAME>
<RETURNS>void                       </RETURNS>
GtkEntryBuffer  *buffer, guint            position, const gchar     *chars, guint            n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_buffer_emit_deleted_text</NAME>
<RETURNS>void                       </RETURNS>
GtkEntryBuffer  *buffer, guint            position, guint            n_chars
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_ENTRY_COMPLETION</NAME>
#define GTK_TYPE_ENTRY_COMPLETION            (gtk_entry_completion_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_COMPLETION</NAME>
#define GTK_ENTRY_COMPLETION(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ENTRY_COMPLETION, GtkEntryCompletion))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_COMPLETION_CLASS</NAME>
#define GTK_ENTRY_COMPLETION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ENTRY_COMPLETION, GtkEntryCompletionClass))
</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>
<MACRO>
<NAME>GTK_IS_ENTRY_COMPLETION_CLASS</NAME>
#define GTK_IS_ENTRY_COMPLETION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ENTRY_COMPLETION))
</MACRO>
<MACRO>
<NAME>GTK_ENTRY_COMPLETION_GET_CLASS</NAME>
#define GTK_ENTRY_COMPLETION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ENTRY_COMPLETION, GtkEntryCompletionClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkEntryCompletionMatchFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkEntryCompletion *completion,
                                                  const gchar        *key,
                                                  GtkTreeIter        *iter,
                                                  gpointer            user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkEntryCompletion</NAME>
struct _GtkEntryCompletion
{
  GObject parent_instance;

  /*< private >*/
  GtkEntryCompletionPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkEntryCompletionClass</NAME>
struct _GtkEntryCompletionClass
{
  GObjectClass parent_class;

  gboolean (* match_selected)   (GtkEntryCompletion *completion,
                                 GtkTreeModel       *model,
                                 GtkTreeIter        *iter);
  void     (* action_activated) (GtkEntryCompletion *completion,
                                 gint                index_);
  gboolean (* insert_prefix)    (GtkEntryCompletion *completion,
                                 const gchar        *prefix);
  gboolean (* cursor_on_match)  (GtkEntryCompletion *completion,
                                 GtkTreeModel       *model,
                                 GtkTreeIter        *iter);
  void     (* no_matches)       (GtkEntryCompletion *completion);

  /* Padding for future expansion */
  void (*_gtk_reserved0) (void);
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_entry_completion_get_type</NAME>
<RETURNS>GType                </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_new</NAME>
<RETURNS>GtkEntryCompletion  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_new_with_area</NAME>
<RETURNS>GtkEntryCompletion  *</RETURNS>
GtkCellArea                 *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_entry</NAME>
<RETURNS>GtkWidget           *</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_model</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, GtkTreeModel                *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_model</NAME>
<RETURNS>GtkTreeModel        *</RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_match_func</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, GtkEntryCompletionMatchFunc  func, gpointer                     func_data, GDestroyNotify               func_notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_minimum_key_length</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gint                         length
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_minimum_key_length</NAME>
<RETURNS>gint                 </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_compute_prefix</NAME>
<RETURNS>gchar  *             </RETURNS>
GtkEntryCompletion          *completion, const char                  *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_complete</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_insert_prefix</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_insert_action_text</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gint                         index_, const gchar                 *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_insert_action_markup</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gint                         index_, const gchar                 *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_delete_action</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gint                         index_
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_inline_completion</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gboolean                     inline_completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_inline_completion</NAME>
<RETURNS>gboolean             </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_inline_selection</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gboolean                     inline_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_inline_selection</NAME>
<RETURNS>gboolean             </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_popup_completion</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gboolean                     popup_completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_popup_completion</NAME>
<RETURNS>gboolean             </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_popup_set_width</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gboolean                     popup_set_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_popup_set_width</NAME>
<RETURNS>gboolean             </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_popup_single_match</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gboolean                     popup_single_match
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_popup_single_match</NAME>
<RETURNS>gboolean             </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_completion_prefix</NAME>
<RETURNS>const gchar          *</RETURNS>
GtkEntryCompletion *completion
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_set_text_column</NAME>
<RETURNS>void                 </RETURNS>
GtkEntryCompletion          *completion, gint                         column
</FUNCTION>
<FUNCTION>
<NAME>gtk_entry_completion_get_text_column</NAME>
<RETURNS>gint                 </RETURNS>
GtkEntryCompletion          *completion
</FUNCTION>
<STRUCT>
<NAME>GtkEntryCompletionPrivate</NAME>
</STRUCT>
<ENUM>
<NAME>GtkAlign</NAME>
typedef enum
{
  GTK_ALIGN_FILL,
  GTK_ALIGN_START,
  GTK_ALIGN_END,
  GTK_ALIGN_CENTER,
  GTK_ALIGN_BASELINE
} GtkAlign;
</ENUM>
<ENUM>
<NAME>GtkArrowType</NAME>
typedef enum
{
  GTK_ARROW_UP,
  GTK_ARROW_DOWN,
  GTK_ARROW_LEFT,
  GTK_ARROW_RIGHT,
  GTK_ARROW_NONE
} GtkArrowType;
</ENUM>
<ENUM>
<NAME>GtkBaselinePosition</NAME>
typedef enum
{
  GTK_BASELINE_POSITION_TOP,
  GTK_BASELINE_POSITION_CENTER,
  GTK_BASELINE_POSITION_BOTTOM
} GtkBaselinePosition;
</ENUM>
<ENUM>
<NAME>GtkDeleteType</NAME>
typedef enum
{
  GTK_DELETE_CHARS,
  GTK_DELETE_WORD_ENDS,
  GTK_DELETE_WORDS,
  GTK_DELETE_DISPLAY_LINES,
  GTK_DELETE_DISPLAY_LINE_ENDS,
  GTK_DELETE_PARAGRAPH_ENDS,
  GTK_DELETE_PARAGRAPHS,
  GTK_DELETE_WHITESPACE
} GtkDeleteType;
</ENUM>
<ENUM>
<NAME>GtkDirectionType</NAME>
typedef enum
{
  GTK_DIR_TAB_FORWARD,
  GTK_DIR_TAB_BACKWARD,
  GTK_DIR_UP,
  GTK_DIR_DOWN,
  GTK_DIR_LEFT,
  GTK_DIR_RIGHT
} GtkDirectionType;
</ENUM>
<ENUM>
<NAME>GtkIconSize</NAME>
typedef enum
{
  GTK_ICON_SIZE_INHERIT,
  GTK_ICON_SIZE_NORMAL,
  GTK_ICON_SIZE_LARGE
} GtkIconSize;
</ENUM>
<ENUM>
<NAME>GtkSensitivityType</NAME>
typedef enum
{
  GTK_SENSITIVITY_AUTO,
  GTK_SENSITIVITY_ON,
  GTK_SENSITIVITY_OFF
} GtkSensitivityType;
</ENUM>
<ENUM>
<NAME>GtkTextDirection</NAME>
typedef enum
{
  GTK_TEXT_DIR_NONE,
  GTK_TEXT_DIR_LTR,
  GTK_TEXT_DIR_RTL
} GtkTextDirection;
</ENUM>
<ENUM>
<NAME>GtkJustification</NAME>
typedef enum
{
  GTK_JUSTIFY_LEFT,
  GTK_JUSTIFY_RIGHT,
  GTK_JUSTIFY_CENTER,
  GTK_JUSTIFY_FILL
} GtkJustification;
</ENUM>
<ENUM>
<NAME>GtkMenuDirectionType</NAME>
typedef enum
{
  GTK_MENU_DIR_PARENT,
  GTK_MENU_DIR_CHILD,
  GTK_MENU_DIR_NEXT,
  GTK_MENU_DIR_PREV
} GtkMenuDirectionType;
</ENUM>
<ENUM>
<NAME>GtkMessageType</NAME>
typedef enum
{
  GTK_MESSAGE_INFO,
  GTK_MESSAGE_WARNING,
  GTK_MESSAGE_QUESTION,
  GTK_MESSAGE_ERROR,
  GTK_MESSAGE_OTHER
} GtkMessageType;
</ENUM>
<ENUM>
<NAME>GtkMovementStep</NAME>
typedef enum
{
  GTK_MOVEMENT_LOGICAL_POSITIONS,
  GTK_MOVEMENT_VISUAL_POSITIONS,
  GTK_MOVEMENT_WORDS,
  GTK_MOVEMENT_DISPLAY_LINES,
  GTK_MOVEMENT_DISPLAY_LINE_ENDS,
  GTK_MOVEMENT_PARAGRAPHS,
  GTK_MOVEMENT_PARAGRAPH_ENDS,
  GTK_MOVEMENT_PAGES,
  GTK_MOVEMENT_BUFFER_ENDS,
  GTK_MOVEMENT_HORIZONTAL_PAGES
} GtkMovementStep;
</ENUM>
<ENUM>
<NAME>GtkScrollStep</NAME>
typedef enum
{
  GTK_SCROLL_STEPS,
  GTK_SCROLL_PAGES,
  GTK_SCROLL_ENDS,
  GTK_SCROLL_HORIZONTAL_STEPS,
  GTK_SCROLL_HORIZONTAL_PAGES,
  GTK_SCROLL_HORIZONTAL_ENDS
} GtkScrollStep;
</ENUM>
<ENUM>
<NAME>GtkOrientation</NAME>
typedef enum
{
  GTK_ORIENTATION_HORIZONTAL,
  GTK_ORIENTATION_VERTICAL
} GtkOrientation;
</ENUM>
<ENUM>
<NAME>GtkOverflow</NAME>
typedef enum
{
  GTK_OVERFLOW_VISIBLE,
  GTK_OVERFLOW_HIDDEN
} GtkOverflow;
</ENUM>
<ENUM>
<NAME>GtkPackType</NAME>
typedef enum
{
  GTK_PACK_START,
  GTK_PACK_END
} GtkPackType;
</ENUM>
<ENUM>
<NAME>GtkPositionType</NAME>
typedef enum
{
  GTK_POS_LEFT,
  GTK_POS_RIGHT,
  GTK_POS_TOP,
  GTK_POS_BOTTOM
} GtkPositionType;
</ENUM>
<ENUM>
<NAME>GtkReliefStyle</NAME>
typedef enum
{
  GTK_RELIEF_NORMAL,
  GTK_RELIEF_NONE
} GtkReliefStyle;
</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>GtkShadowType</NAME>
typedef enum
{
  GTK_SHADOW_NONE,
  GTK_SHADOW_IN,
  GTK_SHADOW_OUT,
  GTK_SHADOW_ETCHED_IN,
  GTK_SHADOW_ETCHED_OUT
} GtkShadowType;
</ENUM>
<ENUM>
<NAME>GtkToolbarStyle</NAME>
typedef enum
{
  GTK_TOOLBAR_ICONS,
  GTK_TOOLBAR_TEXT,
  GTK_TOOLBAR_BOTH,
  GTK_TOOLBAR_BOTH_HORIZ
} GtkToolbarStyle;
</ENUM>
<ENUM>
<NAME>GtkWrapMode</NAME>
typedef enum
{
  GTK_WRAP_NONE,
  GTK_WRAP_CHAR,
  GTK_WRAP_WORD,
  GTK_WRAP_WORD_CHAR
} GtkWrapMode;
</ENUM>
<ENUM>
<NAME>GtkSortType</NAME>
typedef enum
{
  GTK_SORT_ASCENDING,
  GTK_SORT_DESCENDING
} GtkSortType;
</ENUM>
<ENUM>
<NAME>GtkPrintPages</NAME>
typedef enum
{
  GTK_PRINT_PAGES_ALL,
  GTK_PRINT_PAGES_CURRENT,
  GTK_PRINT_PAGES_RANGES,
  GTK_PRINT_PAGES_SELECTION
} GtkPrintPages;
</ENUM>
<ENUM>
<NAME>GtkPageSet</NAME>
typedef enum
{
  GTK_PAGE_SET_ALL,
  GTK_PAGE_SET_EVEN,
  GTK_PAGE_SET_ODD
} GtkPageSet;
</ENUM>
<ENUM>
<NAME>GtkNumberUpLayout</NAME>
typedef enum
{
  GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM, /*< nick=lrtb >*/
  GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP, /*< nick=lrbt >*/
  GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM, /*< nick=rltb >*/
  GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP, /*< nick=rlbt >*/
  GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT, /*< nick=tblr >*/
  GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT, /*< nick=tbrl >*/
  GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT, /*< nick=btlr >*/
  GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT  /*< nick=btrl >*/
} GtkNumberUpLayout;
</ENUM>
<ENUM>
<NAME>GtkPageOrientation</NAME>
typedef enum
{
  GTK_PAGE_ORIENTATION_PORTRAIT,
  GTK_PAGE_ORIENTATION_LANDSCAPE,
  GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT,
  GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
} GtkPageOrientation;
</ENUM>
<ENUM>
<NAME>GtkPrintQuality</NAME>
typedef enum
{
  GTK_PRINT_QUALITY_LOW,
  GTK_PRINT_QUALITY_NORMAL,
  GTK_PRINT_QUALITY_HIGH,
  GTK_PRINT_QUALITY_DRAFT
} GtkPrintQuality;
</ENUM>
<ENUM>
<NAME>GtkPrintDuplex</NAME>
typedef enum
{
  GTK_PRINT_DUPLEX_SIMPLEX,
  GTK_PRINT_DUPLEX_HORIZONTAL,
  GTK_PRINT_DUPLEX_VERTICAL
} GtkPrintDuplex;
</ENUM>
<ENUM>
<NAME>GtkUnit</NAME>
typedef enum
{
  GTK_UNIT_NONE,
  GTK_UNIT_POINTS,
  GTK_UNIT_INCH,
  GTK_UNIT_MM
} GtkUnit;
</ENUM>
<MACRO>
<NAME>GTK_UNIT_PIXEL</NAME>
#define GTK_UNIT_PIXEL GTK_UNIT_NONE
</MACRO>
<ENUM>
<NAME>GtkTreeViewGridLines</NAME>
typedef enum
{
  GTK_TREE_VIEW_GRID_LINES_NONE,
  GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
  GTK_TREE_VIEW_GRID_LINES_VERTICAL,
  GTK_TREE_VIEW_GRID_LINES_BOTH
} GtkTreeViewGridLines;
</ENUM>
<ENUM>
<NAME>GtkDragResult</NAME>
typedef enum
{
  GTK_DRAG_RESULT_SUCCESS,
  GTK_DRAG_RESULT_NO_TARGET,
  GTK_DRAG_RESULT_USER_CANCELLED,
  GTK_DRAG_RESULT_TIMEOUT_EXPIRED,
  GTK_DRAG_RESULT_GRAB_BROKEN,
  GTK_DRAG_RESULT_ERROR
} GtkDragResult;
</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
} GtkStateFlags;
</ENUM>
<ENUM>
<NAME>GtkBorderStyle</NAME>
typedef enum {
  GTK_BORDER_STYLE_NONE,
  GTK_BORDER_STYLE_SOLID,
  GTK_BORDER_STYLE_INSET,
  GTK_BORDER_STYLE_OUTSET,
  GTK_BORDER_STYLE_HIDDEN,
  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
} GtkInputPurpose;
</ENUM>
<ENUM>
<NAME>GtkInputHints</NAME>
typedef enum
{
  GTK_INPUT_HINT_NONE                = 0,
  GTK_INPUT_HINT_SPELLCHECK          = 1 << 0,
  GTK_INPUT_HINT_NO_SPELLCHECK       = 1 << 1,
  GTK_INPUT_HINT_WORD_COMPLETION     = 1 << 2,
  GTK_INPUT_HINT_LOWERCASE           = 1 << 3,
  GTK_INPUT_HINT_UPPERCASE_CHARS     = 1 << 4,
  GTK_INPUT_HINT_UPPERCASE_WORDS     = 1 << 5,
  GTK_INPUT_HINT_UPPERCASE_SENTENCES = 1 << 6,
  GTK_INPUT_HINT_INHIBIT_OSK         = 1 << 7,
  GTK_INPUT_HINT_VERTICAL_WRITING    = 1 << 8,
  GTK_INPUT_HINT_EMOJI               = 1 << 9,
  GTK_INPUT_HINT_NO_EMOJI            = 1 << 10
} GtkInputHints;
</ENUM>
<ENUM>
<NAME>GtkPropagationPhase</NAME>
typedef enum
{
  GTK_PHASE_NONE,
  GTK_PHASE_CAPTURE,
  GTK_PHASE_BUBBLE,
  GTK_PHASE_TARGET
} GtkPropagationPhase;
</ENUM>
<ENUM>
<NAME>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>GtkPopoverConstraint</NAME>
typedef enum
{
  GTK_POPOVER_CONSTRAINT_NONE,
  GTK_POPOVER_CONSTRAINT_WINDOW
} GtkPopoverConstraint;
</ENUM>
<ENUM>
<NAME>GtkPlacesOpenFlags</NAME>
typedef enum {
  GTK_PLACES_OPEN_NORMAL     = 1 << 0,
  GTK_PLACES_OPEN_NEW_TAB    = 1 << 1,
  GTK_PLACES_OPEN_NEW_WINDOW = 1 << 2
} GtkPlacesOpenFlags;
</ENUM>
<ENUM>
<NAME>GtkPickFlags</NAME>
typedef enum {
  GTK_PICK_DEFAULT        = 0,
  GTK_PICK_INSENSITIVE    = 1 << 0,
  GTK_PICK_NON_TARGETABLE = 1 << 1
} GtkPickFlags;
</ENUM>
<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_handle_event</NAME>
<RETURNS>gboolean      </RETURNS>
GtkEventController *controller, const GdkEvent     *event
</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>
<STRUCT>
<NAME>GtkEventControllerClass</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>
<FUNCTION>
<NAME>gtk_event_controller_key_get_focus_origin</NAME>
<RETURNS>GtkWidget  *         </RETURNS>
GtkEventControllerKey *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_key_get_focus_target</NAME>
<RETURNS>GtkWidget  *         </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_get_pointer_origin</NAME>
<RETURNS>GtkWidget  *         </RETURNS>
GtkEventControllerMotion *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_event_controller_motion_get_pointer_target</NAME>
<RETURNS>GtkWidget  *         </RETURNS>
GtkEventControllerMotion *controller
</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_EXPANDER_CLASS</NAME>
#define GTK_EXPANDER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_EXPANDER, GtkExpanderClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_EXPANDER</NAME>
#define GTK_IS_EXPANDER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_EXPANDER))
</MACRO>
<MACRO>
<NAME>GTK_IS_EXPANDER_CLASS</NAME>
#define GTK_IS_EXPANDER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_EXPANDER))
</MACRO>
<MACRO>
<NAME>GTK_EXPANDER_GET_CLASS</NAME>
#define GTK_EXPANDER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_EXPANDER, GtkExpanderClass))
</MACRO>
<STRUCT>
<NAME>GtkExpander</NAME>
struct _GtkExpander
{
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkExpanderClass</NAME>
struct _GtkExpanderClass
{
  GtkContainerClass parent_class;

  /*< public >*/

  /* Key binding signal; to get notification on the expansion
   * state connect to notify:expanded.
   */
  void        (* activate) (GtkExpander *expander);

  /*< 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_expander_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_new</NAME>
<RETURNS>GtkWidget             *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_new_with_mnemonic</NAME>
<RETURNS>GtkWidget             *</RETURNS>
const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_expanded</NAME>
<RETURNS>void                   </RETURNS>
GtkExpander *expander, gboolean     expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_expanded</NAME>
<RETURNS>gboolean               </RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_label</NAME>
<RETURNS>void                   </RETURNS>
GtkExpander *expander, const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_label</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_use_underline</NAME>
<RETURNS>void                   </RETURNS>
GtkExpander *expander, gboolean     use_underline
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_use_underline</NAME>
<RETURNS>gboolean               </RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_use_markup</NAME>
<RETURNS>void                   </RETURNS>
GtkExpander *expander, gboolean    use_markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_use_markup</NAME>
<RETURNS>gboolean               </RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_label_widget</NAME>
<RETURNS>void                   </RETURNS>
GtkExpander *expander, GtkWidget   *label_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_label_widget</NAME>
<RETURNS>GtkWidget             *</RETURNS>
GtkExpander *expander
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_set_resize_toplevel</NAME>
<RETURNS>void                   </RETURNS>
GtkExpander *expander, gboolean     resize_toplevel
</FUNCTION>
<FUNCTION>
<NAME>gtk_expander_get_resize_toplevel</NAME>
<RETURNS>gboolean               </RETURNS>
GtkExpander *expander
</FUNCTION>
<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,
  GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER
} GtkFileChooserAction;
</ENUM>
<ENUM>
<NAME>GtkFileChooserConfirmation</NAME>
typedef enum
{
  GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM,
  GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME,
  GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN
} GtkFileChooserConfirmation;
</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_local_only</NAME>
<RETURNS>void                  </RETURNS>
GtkFileChooser       *chooser, gboolean              local_only
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_local_only</NAME>
<RETURNS>gboolean              </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_show_hidden</NAME>
<RETURNS>void                  </RETURNS>
GtkFileChooser       *chooser, gboolean              show_hidden
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_show_hidden</NAME>
<RETURNS>gboolean              </RETURNS>
GtkFileChooser       *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_do_overwrite_confirmation</NAME>
<RETURNS>void                  </RETURNS>
GtkFileChooser *chooser, gboolean        do_overwrite_confirmation
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_do_overwrite_confirmation</NAME>
<RETURNS>gboolean              </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_create_folders</NAME>
<RETURNS>void                  </RETURNS>
GtkFileChooser       *chooser, gboolean               create_folders
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_create_folders</NAME>
<RETURNS>gboolean              </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_current_name</NAME>
<RETURNS>void         </RETURNS>
GtkFileChooser *chooser, const gchar    *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_current_name</NAME>
<RETURNS>gchar  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_filename</NAME>
<RETURNS>gchar  *  </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_filename</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_select_filename</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_unselect_filename</NAME>
<RETURNS>void      </RETURNS>
GtkFileChooser *chooser, const char     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_select_all</NAME>
<RETURNS>void      </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_unselect_all</NAME>
<RETURNS>void      </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_filenames</NAME>
<RETURNS>GSList  * </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_current_folder</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const gchar    *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_current_folder</NAME>
<RETURNS>gchar  *  </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_uri</NAME>
<RETURNS>gchar  *  </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_select_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_unselect_uri</NAME>
<RETURNS>void      </RETURNS>
GtkFileChooser *chooser, const char     *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_uris</NAME>
<RETURNS>GSList  * </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_current_folder_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const gchar    *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_current_folder_uri</NAME>
<RETURNS>gchar  *  </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_file</NAME>
<RETURNS>GFile  *  </RETURNS>
GtkFileChooser  *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_file</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser  *chooser, GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_select_file</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser  *chooser, GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_unselect_file</NAME>
<RETURNS>void      </RETURNS>
GtkFileChooser  *chooser, GFile           *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_files</NAME>
<RETURNS>GSList  * </RETURNS>
GtkFileChooser  *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_current_folder_file</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser  *chooser, GFile           *file, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_current_folder_file</NAME>
<RETURNS>GFile  *  </RETURNS>
GtkFileChooser  *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_preview_widget</NAME>
<RETURNS>void        </RETURNS>
GtkFileChooser *chooser, GtkWidget      *preview_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_preview_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_preview_widget_active</NAME>
<RETURNS>void        </RETURNS>
GtkFileChooser *chooser, gboolean        active
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_preview_widget_active</NAME>
<RETURNS>gboolean    </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_use_preview_label</NAME>
<RETURNS>void        </RETURNS>
GtkFileChooser *chooser, gboolean        use_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_use_preview_label</NAME>
<RETURNS>gboolean    </RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_preview_filename</NAME>
<RETURNS>char   *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_preview_uri</NAME>
<RETURNS>char   *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_preview_file</NAME>
<RETURNS>GFile  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_extra_widget</NAME>
<RETURNS>void        </RETURNS>
GtkFileChooser *chooser, GtkWidget      *extra_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_extra_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_add_filter</NAME>
<RETURNS>void     </RETURNS>
GtkFileChooser *chooser, GtkFileFilter  *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_remove_filter</NAME>
<RETURNS>void     </RETURNS>
GtkFileChooser *chooser, GtkFileFilter  *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_list_filters</NAME>
<RETURNS>GSList  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_filter</NAME>
<RETURNS>void            </RETURNS>
GtkFileChooser *chooser, GtkFileFilter  *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_filter</NAME>
<RETURNS>GtkFileFilter  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_add_shortcut_folder</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *folder, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_remove_shortcut_folder</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *folder, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_list_shortcut_folders</NAME>
<RETURNS>GSList  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_add_shortcut_folder_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *uri, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_remove_shortcut_folder_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GtkFileChooser *chooser, const char     *uri, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_list_shortcut_folder_uris</NAME>
<RETURNS>GSList  *</RETURNS>
GtkFileChooser *chooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_add_choice</NAME>
<RETURNS>void         </RETURNS>
GtkFileChooser  *chooser, const char      *id, const char      *label, const char     **options, const char     **option_labels
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_remove_choice</NAME>
<RETURNS>void         </RETURNS>
GtkFileChooser  *chooser, const char      *id
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_set_choice</NAME>
<RETURNS>void         </RETURNS>
GtkFileChooser  *chooser, const char      *id, const char      *option
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_get_choice</NAME>
<RETURNS>const char  *</RETURNS>
GtkFileChooser  *chooser, const char      *id
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_BUTTON</NAME>
#define GTK_TYPE_FILE_CHOOSER_BUTTON            (gtk_file_chooser_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_BUTTON</NAME>
#define GTK_FILE_CHOOSER_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_BUTTON, GtkFileChooserButton))
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_BUTTON_CLASS</NAME>
#define GTK_FILE_CHOOSER_BUTTON_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_BUTTON, GtkFileChooserButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_BUTTON</NAME>
#define GTK_IS_FILE_CHOOSER_BUTTON(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_BUTTON_CLASS</NAME>
#define GTK_IS_FILE_CHOOSER_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_BUTTON_GET_CLASS</NAME>
#define GTK_FILE_CHOOSER_BUTTON_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_BUTTON, GtkFileChooserButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserButton</NAME>
struct _GtkFileChooserButton
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFileChooserButtonClass</NAME>
struct _GtkFileChooserButtonClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  void (* file_set) (GtkFileChooserButton *fc);

  /*< 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_file_chooser_button_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_new</NAME>
<RETURNS>GtkWidget  *           </RETURNS>
const gchar          *title, GtkFileChooserAction  action
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_new_with_dialog</NAME>
<RETURNS>GtkWidget  *           </RETURNS>
GtkWidget            *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_get_title</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkFileChooserButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_set_title</NAME>
<RETURNS>void                   </RETURNS>
GtkFileChooserButton *button, const gchar          *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_get_width_chars</NAME>
<RETURNS>gint                   </RETURNS>
GtkFileChooserButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_button_set_width_chars</NAME>
<RETURNS>void                   </RETURNS>
GtkFileChooserButton *button, gint                  n_chars
</FUNCTION>
<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_FILE_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_FILE_CHOOSER_DIALOG_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_DIALOG, GtkFileChooserDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_IS_FILE_CHOOSER_DIALOG_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_DIALOG_GET_CLASS</NAME>
#define GTK_FILE_CHOOSER_DIALOG_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_DIALOG, GtkFileChooserDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserDialog</NAME>
struct _GtkFileChooserDialog
{
  GtkDialog parent_instance;

  GtkFileChooserDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkFileChooserDialogClass</NAME>
struct _GtkFileChooserDialogClass
{
  GtkDialogClass 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_file_chooser_dialog_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_dialog_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
const gchar          *title, GtkWindow            *parent, GtkFileChooserAction  action, const gchar          *first_button_text, ...
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooserDialogPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_EMBED</NAME>
#define GTK_TYPE_FILE_CHOOSER_EMBED             (_gtk_file_chooser_embed_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_EMBED</NAME>
#define GTK_FILE_CHOOSER_EMBED(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_EMBED, GtkFileChooserEmbed))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_EMBED</NAME>
#define GTK_IS_FILE_CHOOSER_EMBED(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_EMBED))
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_EMBED_GET_IFACE</NAME>
#define GTK_FILE_CHOOSER_EMBED_GET_IFACE(obj)   (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_FILE_CHOOSER_EMBED, GtkFileChooserEmbedIface))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserEmbedIface</NAME>
struct _GtkFileChooserEmbedIface
{
  GTypeInterface base_iface;

  /* Methods
   */
  void (*get_default_size)        (GtkFileChooserEmbed *chooser_embed,
				   gint                *default_width,
				   gint                *default_height);

  gboolean (*should_respond)      (GtkFileChooserEmbed *chooser_embed);

  void (*initial_focus)           (GtkFileChooserEmbed *chooser_embed);
  /* Signals
   */
  void (*default_size_changed)    (GtkFileChooserEmbed *chooser_embed);
  void (*response_requested)      (GtkFileChooserEmbed *chooser_embed);
};
</STRUCT>
<STRUCT>
<NAME>GtkFileChooserEmbed</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_ENTRY</NAME>
#define GTK_TYPE_FILE_CHOOSER_ENTRY    (_gtk_file_chooser_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_ENTRY</NAME>
#define GTK_FILE_CHOOSER_ENTRY(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_ENTRY, GtkFileChooserEntry))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_ENTRY</NAME>
#define GTK_IS_FILE_CHOOSER_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_CHOOSER_ENTRY))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserEntry</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_NATIVE</NAME>
#define GTK_TYPE_FILE_CHOOSER_NATIVE             (gtk_file_chooser_native_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_file_chooser_native_new</NAME>
<RETURNS>GtkFileChooserNative  *</RETURNS>
const gchar          *title, GtkWindow            *parent, GtkFileChooserAction  action, const gchar          *accept_label, const gchar          *cancel_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_get_accept_label</NAME>
<RETURNS>const char  *</RETURNS>
GtkFileChooserNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_set_accept_label</NAME>
<RETURNS>void         </RETURNS>
GtkFileChooserNative *self, const char           *accept_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_get_cancel_label</NAME>
<RETURNS>const char  *</RETURNS>
GtkFileChooserNative *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_chooser_native_set_cancel_label</NAME>
<RETURNS>void         </RETURNS>
GtkFileChooserNative *self, const char           *cancel_label
</FUNCTION>
<STRUCT>
<NAME>GtkFileChooserNative</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_FILE_CHOOSER_DELEGATE_QUARK</NAME>
#define GTK_FILE_CHOOSER_DELEGATE_QUARK	  (_gtk_file_chooser_delegate_get_quark ())
</MACRO>
<ENUM>
<NAME>GtkFileChooserProp</NAME>
typedef enum {
  GTK_FILE_CHOOSER_PROP_FIRST                  = 0x1000,
  GTK_FILE_CHOOSER_PROP_ACTION                 = GTK_FILE_CHOOSER_PROP_FIRST,
  GTK_FILE_CHOOSER_PROP_FILTER,
  GTK_FILE_CHOOSER_PROP_LOCAL_ONLY,
  GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET,
  GTK_FILE_CHOOSER_PROP_PREVIEW_WIDGET_ACTIVE,
  GTK_FILE_CHOOSER_PROP_USE_PREVIEW_LABEL,
  GTK_FILE_CHOOSER_PROP_EXTRA_WIDGET,
  GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE,
  GTK_FILE_CHOOSER_PROP_SHOW_HIDDEN,
  GTK_FILE_CHOOSER_PROP_DO_OVERWRITE_CONFIRMATION,
  GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS,
  GTK_FILE_CHOOSER_PROP_LAST                   = GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS
} GtkFileChooserProp;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_WIDGET</NAME>
#define GTK_TYPE_FILE_CHOOSER_WIDGET             (gtk_file_chooser_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_WIDGET</NAME>
#define GTK_FILE_CHOOSER_WIDGET(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_CHOOSER_WIDGET, GtkFileChooserWidget))
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_FILE_CHOOSER_WIDGET_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FILE_CHOOSER_WIDGET, GtkFileChooserWidgetClass))
</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>
<MACRO>
<NAME>GTK_IS_FILE_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_IS_FILE_CHOOSER_WIDGET_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FILE_CHOOSER_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_FILE_CHOOSER_WIDGET_GET_CLASS</NAME>
#define GTK_FILE_CHOOSER_WIDGET_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FILE_CHOOSER_WIDGET, GtkFileChooserWidgetClass))
</MACRO>
<STRUCT>
<NAME>GtkFileChooserWidget</NAME>
struct _GtkFileChooserWidget
{
  GtkWidget parent_instance;

  GtkFileChooserWidgetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkFileChooserWidgetClass</NAME>
struct _GtkFileChooserWidgetClass
{
  GtkWidgetClass 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_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>GtkFileChooserWidgetPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_FILTER</NAME>
#define GTK_TYPE_FILE_FILTER              (gtk_file_filter_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_FILTER</NAME>
#define GTK_FILE_FILTER(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_FILTER, GtkFileFilter))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_FILTER</NAME>
#define GTK_IS_FILE_FILTER(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_FILTER))
</MACRO>
<ENUM>
<NAME>GtkFileFilterFlags</NAME>
typedef enum {
  GTK_FILE_FILTER_FILENAME     = 1 << 0,
  GTK_FILE_FILTER_URI          = 1 << 1,
  GTK_FILE_FILTER_DISPLAY_NAME = 1 << 2,
  GTK_FILE_FILTER_MIME_TYPE    = 1 << 3
} GtkFileFilterFlags;
</ENUM>
<USER_FUNCTION>
<NAME>GtkFileFilterFunc</NAME>
<RETURNS>gboolean </RETURNS>
const GtkFileFilterInfo *filter_info,
				       gpointer                 data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkFileFilterInfo</NAME>
struct _GtkFileFilterInfo
{
  GtkFileFilterFlags contains;

  const gchar *filename;
  const gchar *uri;
  const gchar *display_name;
  const gchar *mime_type;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_file_filter_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_new</NAME>
<RETURNS>GtkFileFilter  *       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_set_name</NAME>
<RETURNS>void                   </RETURNS>
GtkFileFilter *filter, const gchar   *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_get_name</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkFileFilter *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_mime_type</NAME>
<RETURNS>void  </RETURNS>
GtkFileFilter      *filter, const gchar        *mime_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_pattern</NAME>
<RETURNS>void  </RETURNS>
GtkFileFilter      *filter, const gchar        *pattern
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_pixbuf_formats</NAME>
<RETURNS>void  </RETURNS>
GtkFileFilter      *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_add_custom</NAME>
<RETURNS>void  </RETURNS>
GtkFileFilter      *filter, GtkFileFilterFlags  needed, GtkFileFilterFunc   func, gpointer            data, GDestroyNotify      notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_get_needed</NAME>
<RETURNS>GtkFileFilterFlags  </RETURNS>
GtkFileFilter           *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_filter</NAME>
<RETURNS>gboolean            </RETURNS>
GtkFileFilter           *filter, const GtkFileFilterInfo *filter_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_to_gvariant</NAME>
<RETURNS>GVariant       *</RETURNS>
GtkFileFilter *filter
</FUNCTION>
<FUNCTION>
<NAME>gtk_file_filter_new_from_gvariant</NAME>
<RETURNS>GtkFileFilter  *</RETURNS>
GVariant      *variant
</FUNCTION>
<STRUCT>
<NAME>GtkFileFilter</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM</NAME>
#define GTK_TYPE_FILE_SYSTEM         (_gtk_file_system_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM</NAME>
#define GTK_FILE_SYSTEM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_FILE_SYSTEM, GtkFileSystem))
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_CLASS</NAME>
#define GTK_FILE_SYSTEM_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST    ((c), GTK_TYPE_FILE_SYSTEM, GtkFileSystemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM</NAME>
#define GTK_IS_FILE_SYSTEM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_FILE_SYSTEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_CLASS</NAME>
#define GTK_IS_FILE_SYSTEM_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE    ((c), GTK_TYPE_FILE_SYSTEM))
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_GET_CLASS</NAME>
#define GTK_FILE_SYSTEM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS  ((o), GTK_TYPE_FILE_SYSTEM, GtkFileSystemClass))
</MACRO>
<TYPEDEF>
<NAME>GtkFileSystem</NAME>
typedef struct GtkFileSystem          GtkFileSystem;
</TYPEDEF>
<TYPEDEF>
<NAME>GtkFileSystemPrivate</NAME>
typedef struct GtkFileSystemPrivate      GtkFileSystemPrivate;
</TYPEDEF>
<TYPEDEF>
<NAME>GtkFileSystemClass</NAME>
typedef struct GtkFileSystemClass     GtkFileSystemClass;
</TYPEDEF>
<TYPEDEF>
<NAME>GtkFileSystemVolume</NAME>
typedef struct GtkFileSystemVolume GtkFileSystemVolume; /* opaque struct */
</TYPEDEF>
<USER_FUNCTION>
<NAME>GtkFileSystemGetInfoCallback</NAME>
<RETURNS>void </RETURNS>
GCancellable        *cancellable,
						    GFileInfo           *file_info,
						    const GError        *error,
						    gpointer             data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkFileSystemVolumeMountCallback</NAME>
<RETURNS>void </RETURNS>
GCancellable        *cancellable,
						    GtkFileSystemVolume *volume,
						    const GError        *error,
						    gpointer             data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FILE_SYSTEM_MODEL</NAME>
#define GTK_TYPE_FILE_SYSTEM_MODEL             (_gtk_file_system_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FILE_SYSTEM_MODEL</NAME>
#define GTK_FILE_SYSTEM_MODEL(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FILE_SYSTEM_MODEL, GtkFileSystemModel))
</MACRO>
<MACRO>
<NAME>GTK_IS_FILE_SYSTEM_MODEL</NAME>
#define GTK_IS_FILE_SYSTEM_MODEL(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FILE_SYSTEM_MODEL))
</MACRO>
<USER_FUNCTION>
<NAME>GtkFileSystemModelGetValue</NAME>
<RETURNS>gboolean </RETURNS>
GtkFileSystemModel *model,
                                                  GFile              *file,
                                                  GFileInfo          *info,
                                                  int                 column,
                                                  GValue             *value,
                                                  gpointer            user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkFileSystemModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FILTER_LIST_MODEL</NAME>
#define GTK_TYPE_FILTER_LIST_MODEL (gtk_filter_list_model_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkFilterListModelFilterFunc</NAME>
<RETURNS>gboolean </RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_new</NAME>
<RETURNS>GtkFilterListModel  *    </RETURNS>
GListModel             *model, GtkFilterListModelFilterFunc filter_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_new_for_type</NAME>
<RETURNS>GtkFilterListModel  *    </RETURNS>
GType                   item_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_set_filter_func</NAME>
<RETURNS>void                     </RETURNS>
GtkFilterListModel     *self, GtkFilterListModelFilterFunc filter_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_set_model</NAME>
<RETURNS>void                     </RETURNS>
GtkFilterListModel     *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_get_model</NAME>
<RETURNS>GListModel  *            </RETURNS>
GtkFilterListModel     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_has_filter</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkFilterListModel     *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_filter_list_model_refilter</NAME>
<RETURNS>void                     </RETURNS>
GtkFilterListModel     *self
</FUNCTION>
<STRUCT>
<NAME>GtkFilterListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FIXED</NAME>
#define GTK_TYPE_FIXED                  (gtk_fixed_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FIXED</NAME>
#define GTK_FIXED(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FIXED, GtkFixed))
</MACRO>
<MACRO>
<NAME>GTK_FIXED_CLASS</NAME>
#define GTK_FIXED_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FIXED, GtkFixedClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_FIXED</NAME>
#define GTK_IS_FIXED(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FIXED))
</MACRO>
<MACRO>
<NAME>GTK_IS_FIXED_CLASS</NAME>
#define GTK_IS_FIXED_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FIXED))
</MACRO>
<MACRO>
<NAME>GTK_FIXED_GET_CLASS</NAME>
#define GTK_FIXED_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FIXED, GtkFixedClass))
</MACRO>
<STRUCT>
<NAME>GtkFixed</NAME>
struct _GtkFixed
{
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFixedClass</NAME>
struct _GtkFixedClass
{
  GtkContainerClass 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_fixed_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_new</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_put</NAME>
<RETURNS>void             </RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, gint          x, gint          y
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_move</NAME>
<RETURNS>void             </RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, gint          x, gint          y
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_get_child_position</NAME>
<RETURNS>void             </RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, gint         *x, gint         *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_set_child_transform</NAME>
<RETURNS>void             </RETURNS>
GtkFixed     *fixed, GtkWidget    *widget, GskTransform *transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_get_child_transform</NAME>
<RETURNS>GskTransform  *  </RETURNS>
GtkFixed     *fixed, GtkWidget    *widget
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_FIXED_LAYOUT</NAME>
#define GTK_TYPE_FIXED_LAYOUT (gtk_fixed_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FIXED_LAYOUT_CHILD</NAME>
#define GTK_TYPE_FIXED_LAYOUT_CHILD (gtk_fixed_layout_child_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_fixed_layout_new</NAME>
<RETURNS>GtkLayoutManager  *      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_layout_child_set_position</NAME>
<RETURNS>void             </RETURNS>
GtkFixedLayoutChild *child, GskTransform        *position
</FUNCTION>
<FUNCTION>
<NAME>gtk_fixed_layout_child_get_position</NAME>
<RETURNS>GskTransform  *  </RETURNS>
GtkFixedLayoutChild *child
</FUNCTION>
<STRUCT>
<NAME>GtkFixedLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkFixedLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FLATTEN_LIST_MODEL</NAME>
#define GTK_TYPE_FLATTEN_LIST_MODEL (gtk_flatten_list_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_flatten_list_model_new</NAME>
<RETURNS>GtkFlattenListModel  *    </RETURNS>
GType                   item_type, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_flatten_list_model_set_model</NAME>
<RETURNS>void                     </RETURNS>
GtkFlattenListModel    *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_flatten_list_model_get_model</NAME>
<RETURNS>GListModel  *            </RETURNS>
GtkFlattenListModel    *self
</FUNCTION>
<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_FLOW_BOX_CLASS</NAME>
#define GTK_FLOW_BOX_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FLOW_BOX, GtkFlowBoxClass))
</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_IS_FLOW_BOX_CLASS</NAME>
#define GTK_IS_FLOW_BOX_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FLOW_BOX))
</MACRO>
<MACRO>
<NAME>GTK_FLOW_BOX_GET_CLASS</NAME>
#define GTK_FLOW_BOX_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FLOW_BOX, GtkFlowBoxClass))
</MACRO>
<STRUCT>
<NAME>GtkFlowBox</NAME>
struct _GtkFlowBox
{
  GtkContainer container;
};
</STRUCT>
<STRUCT>
<NAME>GtkFlowBoxClass</NAME>
struct _GtkFlowBoxClass
{
  GtkContainerClass parent_class;

  void (*child_activated)            (GtkFlowBox        *box,
                                      GtkFlowBoxChild   *child);
  void (*selected_children_changed)  (GtkFlowBox        *box);
  void (*activate_cursor_child)      (GtkFlowBox        *box);
  void (*toggle_cursor_child)        (GtkFlowBox        *box);
  gboolean (*move_cursor)            (GtkFlowBox        *box,
                                      GtkMovementStep    step,
                                      gint               count);
  void (*select_all)                 (GtkFlowBox        *box);
  void (*unselect_all)               (GtkFlowBox        *box);

  /* 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>
<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
{
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFlowBoxChildClass</NAME>
struct _GtkFlowBoxChildClass
{
  GtkBinClass parent_class;

  void (* activate) (GtkFlowBoxChild *child);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
};
</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_get_index</NAME>
<RETURNS>gint                   </RETURNS>
GtkFlowBoxChild *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_is_selected</NAME>
<RETURNS>gboolean               </RETURNS>
GtkFlowBoxChild *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_child_changed</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBoxChild *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_new</NAME>
<RETURNS>GtkWidget             *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_bind_model</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox                 *box, GListModel                 *model, GtkFlowBoxCreateWidgetFunc  create_widget_func, gpointer                    user_data, GDestroyNotify              user_data_free_func
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_homogeneous</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox           *box, gboolean              homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_homogeneous</NAME>
<RETURNS>gboolean               </RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_row_spacing</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox           *box, guint                 spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_row_spacing</NAME>
<RETURNS>guint                  </RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_column_spacing</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox           *box, guint                 spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_column_spacing</NAME>
<RETURNS>guint                  </RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_min_children_per_line</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox           *box, guint                 n_children
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_min_children_per_line</NAME>
<RETURNS>guint                  </RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_max_children_per_line</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox           *box, guint                 n_children
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_max_children_per_line</NAME>
<RETURNS>guint                  </RETURNS>
GtkFlowBox           *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_activate_on_single_click</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, gboolean           single
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_activate_on_single_click</NAME>
<RETURNS>gboolean               </RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_insert</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkWidget         *widget, gint               position
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_child_at_index</NAME>
<RETURNS>GtkFlowBoxChild       *</RETURNS>
GtkFlowBox        *box, gint               idx
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_child_at_pos</NAME>
<RETURNS>GtkFlowBoxChild       *</RETURNS>
GtkFlowBox        *box, gint               x, gint               y
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkFlowBoxForeachFunc</NAME>
<RETURNS>void </RETURNS>
GtkFlowBox      *box,
                                        GtkFlowBoxChild *child,
                                        gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_selected_foreach</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkFlowBoxForeachFunc func, gpointer           data
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_selected_children</NAME>
<RETURNS>GList                 *</RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_select_child</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkFlowBoxChild   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_unselect_child</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkFlowBoxChild   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_select_all</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_unselect_all</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_selection_mode</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkSelectionMode   mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_get_selection_mode</NAME>
<RETURNS>GtkSelectionMode       </RETURNS>
GtkFlowBox        *box
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_hadjustment</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkAdjustment     *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_vadjustment</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkAdjustment     *adjustment
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkFlowBoxFilterFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkFlowBoxChild *child,
                                          gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_filter_func</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkFlowBoxFilterFunc filter_func, gpointer             user_data, GDestroyNotify       destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_invalidate_filter</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkFlowBoxSortFunc</NAME>
<RETURNS>gint </RETURNS>
GtkFlowBoxChild *child1,
                                    GtkFlowBoxChild *child2,
                                    gpointer         user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_set_sort_func</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox        *box, GtkFlowBoxSortFunc  sort_func, gpointer            user_data, GDestroyNotify      destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_flow_box_invalidate_sort</NAME>
<RETURNS>void                   </RETURNS>
GtkFlowBox         *box
</FUNCTION>
<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_FONT_BUTTON_CLASS</NAME>
#define GTK_FONT_BUTTON_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FONT_BUTTON, GtkFontButtonClass))
</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>
<MACRO>
<NAME>GTK_IS_FONT_BUTTON_CLASS</NAME>
#define GTK_IS_FONT_BUTTON_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FONT_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_FONT_BUTTON_GET_CLASS</NAME>
#define GTK_FONT_BUTTON_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FONT_BUTTON, GtkFontButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkFontButton</NAME>
struct _GtkFontButton
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFontButtonClass</NAME>
struct _GtkFontButtonClass
{
  GtkWidgetClass parent_class;

  /* font_set signal is emitted when font is chosen */
  void (* font_set) (GtkFontButton *gfp);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_font_button_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_new</NAME>
<RETURNS>GtkWidget             *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_new_with_font</NAME>
<RETURNS>GtkWidget             *</RETURNS>
const gchar   *fontname
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_get_title</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkFontButton *font_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_set_title</NAME>
<RETURNS>void                   </RETURNS>
GtkFontButton *font_button, const gchar   *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_button_get_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>
<USER_FUNCTION>
<NAME>GtkFontFilterFunc</NAME>
<RETURNS>gboolean </RETURNS>
const PangoFontFamily *family,
                                       const PangoFontFace   *face,
                                       gpointer               data
</USER_FUNCTION>
<ENUM>
<NAME>GtkFontChooserLevel</NAME>
typedef enum {
  GTK_FONT_CHOOSER_LEVEL_FAMILY     = 0,
  GTK_FONT_CHOOSER_LEVEL_STYLE      = 1 << 0,
  GTK_FONT_CHOOSER_LEVEL_SIZE       = 1 << 1,
  GTK_FONT_CHOOSER_LEVEL_VARIATIONS = 1 << 2,
  GTK_FONT_CHOOSER_LEVEL_FEATURES   = 1 << 3
} GtkFontChooserLevel;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_FONT_CHOOSER</NAME>
#define GTK_TYPE_FONT_CHOOSER			(gtk_font_chooser_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER</NAME>
#define GTK_FONT_CHOOSER(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_CHOOSER, GtkFontChooser))
</MACRO>
<MACRO>
<NAME>GTK_IS_FONT_CHOOSER</NAME>
#define GTK_IS_FONT_CHOOSER(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_FONT_CHOOSER))
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_GET_IFACE</NAME>
#define GTK_FONT_CHOOSER_GET_IFACE(inst)	(G_TYPE_INSTANCE_GET_INTERFACE ((inst), GTK_TYPE_FONT_CHOOSER, GtkFontChooserIface))
</MACRO>
<STRUCT>
<NAME>GtkFontChooserIface</NAME>
struct _GtkFontChooserIface
{
  GTypeInterface base_iface;

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

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

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

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

   /* Padding */
  gpointer padding[10];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_font_chooser_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_family</NAME>
<RETURNS>PangoFontFamily  *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_face</NAME>
<RETURNS>PangoFontFace    *</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_size</NAME>
<RETURNS>gint              </RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_desc</NAME>
<RETURNS>PangoFontDescription  *</RETURNS>
GtkFontChooser             *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_font_desc</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser             *fontchooser, const PangoFontDescription *font_desc
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font</NAME>
<RETURNS>gchar *           </RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_font</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser   *fontchooser, const gchar      *fontname
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_preview_text</NAME>
<RETURNS>gchar *           </RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_preview_text</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser   *fontchooser, const gchar      *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_show_preview_entry</NAME>
<RETURNS>gboolean          </RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_show_preview_entry</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser   *fontchooser, gboolean          show_preview_entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_filter_func</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser   *fontchooser, GtkFontFilterFunc filter, gpointer          user_data, GDestroyNotify    destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_font_map</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser   *fontchooser, PangoFontMap     *fontmap
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_map</NAME>
<RETURNS>PangoFontMap  *   </RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_level</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser   *fontchooser, GtkFontChooserLevel level
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_level</NAME>
<RETURNS>GtkFontChooserLevel</RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_font_features</NAME>
<RETURNS>char  *           </RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_get_language</NAME>
<RETURNS>char  *           </RETURNS>
GtkFontChooser   *fontchooser
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_set_language</NAME>
<RETURNS>void              </RETURNS>
GtkFontChooser   *fontchooser, const char       *language
</FUNCTION>
<STRUCT>
<NAME>GtkFontChooser</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_FONT_CHOOSER_DIALOG</NAME>
#define GTK_TYPE_FONT_CHOOSER_DIALOG              (gtk_font_chooser_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_DIALOG</NAME>
#define GTK_FONT_CHOOSER_DIALOG(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_FONT_CHOOSER_DIALOG, GtkFontChooserDialog))
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_FONT_CHOOSER_DIALOG_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FONT_CHOOSER_DIALOG, GtkFontChooserDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_FONT_CHOOSER_DIALOG_CLASS</NAME>
#define GTK_IS_FONT_CHOOSER_DIALOG_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FONT_CHOOSER_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_DIALOG_GET_CLASS</NAME>
#define GTK_FONT_CHOOSER_DIALOG_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FONT_CHOOSER_DIALOG, GtkFontChooserDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkFontChooserDialog</NAME>
struct _GtkFontChooserDialog
{
  GtkDialog parent_instance;

  /*< private >*/
  GtkFontChooserDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkFontChooserDialogClass</NAME>
struct _GtkFontChooserDialogClass
{
  GtkDialogClass parent_class;

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_font_chooser_dialog_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_font_chooser_dialog_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar          *title, GtkWindow            *parent
</FUNCTION>
<STRUCT>
<NAME>GtkFontChooserDialogPrivate</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_FONT_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_FONT_CHOOSER_WIDGET_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_FONT_CHOOSER_WIDGET, GtkFontChooserWidgetClass))
</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>
<MACRO>
<NAME>GTK_IS_FONT_CHOOSER_WIDGET_CLASS</NAME>
#define GTK_IS_FONT_CHOOSER_WIDGET_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FONT_CHOOSER_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_FONT_CHOOSER_WIDGET_GET_CLASS</NAME>
#define GTK_FONT_CHOOSER_WIDGET_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_FONT_CHOOSER_WIDGET, GtkFontChooserWidgetClass))
</MACRO>
<STRUCT>
<NAME>GtkFontChooserWidget</NAME>
struct _GtkFontChooserWidget
{
  GtkWidget parent_instance;

  /*< private >*/
  GtkFontChooserWidgetPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkFontChooserWidgetClass</NAME>
struct _GtkFontChooserWidgetClass
{
  GtkWidgetClass parent_class;

  /*< 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);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<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>GtkFontChooserWidgetPrivate</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
{
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkFrameClass</NAME>
struct _GtkFrameClass
{
  GtkBinClass parent_class;

  /*< public >*/

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

  /*< 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_frame_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar   *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_label</NAME>
<RETURNS>void           </RETURNS>
GtkFrame    *frame, const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkFrame    *frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_label_widget</NAME>
<RETURNS>void        </RETURNS>
GtkFrame      *frame, GtkWidget     *label_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkFrame      *frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_label_align</NAME>
<RETURNS>void        </RETURNS>
GtkFrame      *frame, gfloat         xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_label_align</NAME>
<RETURNS>gfloat      </RETURNS>
GtkFrame      *frame
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_set_shadow_type</NAME>
<RETURNS>void        </RETURNS>
GtkFrame      *frame, GtkShadowType  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_frame_get_shadow_type</NAME>
<RETURNS>GtkShadowType  </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>const GdkEvent  *</RETURNS>
GtkGesture       *gesture, GdkEventSequence *sequence
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_point</NAME>
<RETURNS>gboolean     </RETURNS>
GtkGesture       *gesture, GdkEventSequence *sequence, gdouble          *x, gdouble          *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_bounding_box</NAME>
<RETURNS>gboolean     </RETURNS>
GtkGesture       *gesture, GdkRectangle     *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_bounding_box_center</NAME>
<RETURNS>gboolean  </RETURNS>
GtkGesture       *gesture, gdouble          *x, gdouble          *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_is_active</NAME>
<RETURNS>gboolean     </RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_is_recognized</NAME>
<RETURNS>gboolean     </RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_group</NAME>
<RETURNS>void         </RETURNS>
GtkGesture       *group_gesture, GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_ungroup</NAME>
<RETURNS>void         </RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_get_group</NAME>
<RETURNS>GList  *     </RETURNS>
GtkGesture       *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_is_grouped_with</NAME>
<RETURNS>gboolean     </RETURNS>
GtkGesture       *gesture, GtkGesture       *other
</FUNCTION>
<STRUCT>
<NAME>GtkGestureClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_DRAG</NAME>
#define GTK_TYPE_GESTURE_DRAG         (gtk_gesture_drag_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_DRAG</NAME>
#define GTK_GESTURE_DRAG(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_DRAG, GtkGestureDrag))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_DRAG_CLASS</NAME>
#define GTK_GESTURE_DRAG_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_DRAG, GtkGestureDragClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_DRAG</NAME>
#define GTK_IS_GESTURE_DRAG(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_DRAG))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_DRAG_CLASS</NAME>
#define GTK_IS_GESTURE_DRAG_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_DRAG))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_DRAG_GET_CLASS</NAME>
#define GTK_GESTURE_DRAG_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_DRAG, GtkGestureDragClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_drag_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_drag_new</NAME>
<RETURNS>GtkGesture  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_drag_get_start_point</NAME>
<RETURNS>gboolean      </RETURNS>
GtkGestureDrag *gesture, gdouble        *x, gdouble        *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_drag_get_offset</NAME>
<RETURNS>gboolean      </RETURNS>
GtkGestureDrag *gesture, gdouble        *x, gdouble        *y
</FUNCTION>
<STRUCT>
<NAME>GtkGestureDrag</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureDragClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_LONG_PRESS</NAME>
#define GTK_TYPE_GESTURE_LONG_PRESS         (gtk_gesture_long_press_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_LONG_PRESS</NAME>
#define GTK_GESTURE_LONG_PRESS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_LONG_PRESS, GtkGestureLongPress))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_LONG_PRESS_CLASS</NAME>
#define GTK_GESTURE_LONG_PRESS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_LONG_PRESS, GtkGestureLongPressClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_LONG_PRESS</NAME>
#define GTK_IS_GESTURE_LONG_PRESS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_LONG_PRESS))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_LONG_PRESS_CLASS</NAME>
#define GTK_IS_GESTURE_LONG_PRESS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_LONG_PRESS))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_LONG_PRESS_GET_CLASS</NAME>
#define GTK_GESTURE_LONG_PRESS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_LONG_PRESS, GtkGestureLongPressClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_long_press_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_long_press_new</NAME>
<RETURNS>GtkGesture  * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkGestureLongPress</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureLongPressClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_MULTI_PRESS</NAME>
#define GTK_TYPE_GESTURE_MULTI_PRESS         (gtk_gesture_multi_press_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_MULTI_PRESS</NAME>
#define GTK_GESTURE_MULTI_PRESS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_MULTI_PRESS, GtkGestureMultiPress))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_MULTI_PRESS_CLASS</NAME>
#define GTK_GESTURE_MULTI_PRESS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_MULTI_PRESS, GtkGestureMultiPressClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_MULTI_PRESS</NAME>
#define GTK_IS_GESTURE_MULTI_PRESS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_MULTI_PRESS))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_MULTI_PRESS_CLASS</NAME>
#define GTK_IS_GESTURE_MULTI_PRESS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_MULTI_PRESS))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_MULTI_PRESS_GET_CLASS</NAME>
#define GTK_GESTURE_MULTI_PRESS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_MULTI_PRESS, GtkGestureMultiPressClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_multi_press_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_multi_press_new</NAME>
<RETURNS>GtkGesture  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_multi_press_set_area</NAME>
<RETURNS>void          </RETURNS>
GtkGestureMultiPress *gesture, const GdkRectangle   *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_multi_press_get_area</NAME>
<RETURNS>gboolean      </RETURNS>
GtkGestureMultiPress *gesture, GdkRectangle         *rect
</FUNCTION>
<STRUCT>
<NAME>GtkGestureMultiPress</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureMultiPressClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_PAN</NAME>
#define GTK_TYPE_GESTURE_PAN         (gtk_gesture_pan_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_PAN</NAME>
#define GTK_GESTURE_PAN(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_PAN, GtkGesturePan))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_PAN_CLASS</NAME>
#define GTK_GESTURE_PAN_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_PAN, GtkGesturePanClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_PAN</NAME>
#define GTK_IS_GESTURE_PAN(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_PAN))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_PAN_CLASS</NAME>
#define GTK_IS_GESTURE_PAN_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_PAN))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_PAN_GET_CLASS</NAME>
#define GTK_GESTURE_PAN_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_PAN, GtkGesturePanClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_pan_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_pan_new</NAME>
<RETURNS>GtkGesture  *      </RETURNS>
GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_pan_get_orientation</NAME>
<RETURNS>GtkOrientation     </RETURNS>
GtkGesturePan  *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_pan_set_orientation</NAME>
<RETURNS>void               </RETURNS>
GtkGesturePan  *gesture, GtkOrientation  orientation
</FUNCTION>
<STRUCT>
<NAME>GtkGesturePan</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGesturePanClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_ROTATE</NAME>
#define GTK_TYPE_GESTURE_ROTATE         (gtk_gesture_rotate_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ROTATE</NAME>
#define GTK_GESTURE_ROTATE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_ROTATE, GtkGestureRotate))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ROTATE_CLASS</NAME>
#define GTK_GESTURE_ROTATE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_ROTATE, GtkGestureRotateClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ROTATE</NAME>
#define GTK_IS_GESTURE_ROTATE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_ROTATE))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ROTATE_CLASS</NAME>
#define GTK_IS_GESTURE_ROTATE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_ROTATE))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ROTATE_GET_CLASS</NAME>
#define GTK_GESTURE_ROTATE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_ROTATE, GtkGestureRotateClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_rotate_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_rotate_new</NAME>
<RETURNS>GtkGesture  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_rotate_get_angle_delta</NAME>
<RETURNS>gdouble       </RETURNS>
GtkGestureRotate *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureRotate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureRotateClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_SINGLE</NAME>
#define GTK_TYPE_GESTURE_SINGLE         (gtk_gesture_single_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SINGLE</NAME>
#define GTK_GESTURE_SINGLE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_SINGLE, GtkGestureSingle))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SINGLE_CLASS</NAME>
#define GTK_GESTURE_SINGLE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_SINGLE, GtkGestureSingleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SINGLE</NAME>
#define GTK_IS_GESTURE_SINGLE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_SINGLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SINGLE_CLASS</NAME>
#define GTK_IS_GESTURE_SINGLE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_SINGLE))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SINGLE_GET_CLASS</NAME>
#define GTK_GESTURE_SINGLE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_SINGLE, GtkGestureSingleClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_single_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_touch_only</NAME>
<RETURNS>gboolean     </RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_set_touch_only</NAME>
<RETURNS>void         </RETURNS>
GtkGestureSingle *gesture, gboolean          touch_only
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_exclusive</NAME>
<RETURNS>gboolean     </RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_set_exclusive</NAME>
<RETURNS>void         </RETURNS>
GtkGestureSingle *gesture, gboolean          exclusive
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_button</NAME>
<RETURNS>guint        </RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_set_button</NAME>
<RETURNS>void         </RETURNS>
GtkGestureSingle *gesture, guint             button
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_current_button</NAME>
<RETURNS>guint  </RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_single_get_current_sequence</NAME>
<RETURNS>GdkEventSequence  *</RETURNS>
GtkGestureSingle *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureSingle</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureSingleClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_STYLUS</NAME>
#define GTK_TYPE_GESTURE_STYLUS         (gtk_gesture_stylus_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_STYLUS</NAME>
#define GTK_GESTURE_STYLUS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_STYLUS, GtkGestureStylus))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_STYLUS_CLASS</NAME>
#define GTK_GESTURE_STYLUS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_STYLUS, GtkGestureStylusClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_STYLUS</NAME>
#define GTK_IS_GESTURE_STYLUS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_STYLUS))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_STYLUS_CLASS</NAME>
#define GTK_IS_GESTURE_STYLUS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_STYLUS))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_STYLUS_GET_CLASS</NAME>
#define GTK_GESTURE_STYLUS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_STYLUS, GtkGestureStylusClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_new</NAME>
<RETURNS>GtkGesture  *      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_axis</NAME>
<RETURNS>gboolean           </RETURNS>
GtkGestureStylus *gesture, GdkAxisUse        axis, gdouble          *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_axes</NAME>
<RETURNS>gboolean           </RETURNS>
GtkGestureStylus  *gesture, GdkAxisUse         axes[], gdouble          **values
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_backlog</NAME>
<RETURNS>gboolean           </RETURNS>
GtkGestureStylus  *gesture, GdkTimeCoord     **backlog, guint             *n_elems
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_stylus_get_device_tool</NAME>
<RETURNS>GdkDeviceTool  *   </RETURNS>
GtkGestureStylus *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureStylus</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureStylusClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_SWIPE</NAME>
#define GTK_TYPE_GESTURE_SWIPE         (gtk_gesture_swipe_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SWIPE</NAME>
#define GTK_GESTURE_SWIPE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_SWIPE, GtkGestureSwipe))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SWIPE_CLASS</NAME>
#define GTK_GESTURE_SWIPE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_SWIPE, GtkGestureSwipeClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SWIPE</NAME>
#define GTK_IS_GESTURE_SWIPE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_SWIPE))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_SWIPE_CLASS</NAME>
#define GTK_IS_GESTURE_SWIPE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_SWIPE))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_SWIPE_GET_CLASS</NAME>
#define GTK_GESTURE_SWIPE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_SWIPE, GtkGestureSwipeClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_swipe_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_swipe_new</NAME>
<RETURNS>GtkGesture  *    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_swipe_get_velocity</NAME>
<RETURNS>gboolean         </RETURNS>
GtkGestureSwipe *gesture, gdouble         *velocity_x, gdouble         *velocity_y
</FUNCTION>
<STRUCT>
<NAME>GtkGestureSwipe</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureSwipeClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GESTURE_ZOOM</NAME>
#define GTK_TYPE_GESTURE_ZOOM         (gtk_gesture_zoom_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ZOOM</NAME>
#define GTK_GESTURE_ZOOM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_GESTURE_ZOOM, GtkGestureZoom))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ZOOM_CLASS</NAME>
#define GTK_GESTURE_ZOOM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_GESTURE_ZOOM, GtkGestureZoomClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ZOOM</NAME>
#define GTK_IS_GESTURE_ZOOM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_GESTURE_ZOOM))
</MACRO>
<MACRO>
<NAME>GTK_IS_GESTURE_ZOOM_CLASS</NAME>
#define GTK_IS_GESTURE_ZOOM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_GESTURE_ZOOM))
</MACRO>
<MACRO>
<NAME>GTK_GESTURE_ZOOM_GET_CLASS</NAME>
#define GTK_GESTURE_ZOOM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_GESTURE_ZOOM, GtkGestureZoomClass))
</MACRO>
<FUNCTION>
<NAME>gtk_gesture_zoom_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_zoom_new</NAME>
<RETURNS>GtkGesture  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_gesture_zoom_get_scale_delta</NAME>
<RETURNS>gdouble       </RETURNS>
GtkGestureZoom *gesture
</FUNCTION>
<STRUCT>
<NAME>GtkGestureZoom</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGestureZoomClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_GL_AREA</NAME>
#define GTK_TYPE_GL_AREA                (gtk_gl_area_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_GL_AREA</NAME>
#define GTK_GL_AREA(obj)                (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_GL_AREA, GtkGLArea))
</MACRO>
<MACRO>
<NAME>GTK_IS_GL_AREA</NAME>
#define GTK_IS_GL_AREA(obj)             (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_GL_AREA))
</MACRO>
<MACRO>
<NAME>GTK_GL_AREA_CLASS</NAME>
#define GTK_GL_AREA_CLASS(klass)        (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_GL_AREA, GtkGLAreaClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_GL_AREA_CLASS</NAME>
#define GTK_IS_GL_AREA_CLASS(klass)     (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_GL_AREA))
</MACRO>
<MACRO>
<NAME>GTK_GL_AREA_GET_CLASS</NAME>
#define GTK_GL_AREA_GET_CLASS(obj)      (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_GL_AREA, GtkGLAreaClass))
</MACRO>
<STRUCT>
<NAME>GtkGLArea</NAME>
struct _GtkGLArea
{
  /*< private >*/
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkGLAreaClass</NAME>
struct _GtkGLAreaClass
{
  /*< private >*/
  GtkWidgetClass parent_class;

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

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

  /*< private >*/

  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_grid_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_attach</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, GtkWidget       *child, gint             left, gint             top, gint             width, gint             height
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_attach_next_to</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, GtkWidget       *child, GtkWidget       *sibling, GtkPositionType  side, gint             width, gint             height
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_child_at</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkGrid         *grid, gint             left, gint             top
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_insert_row</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_insert_column</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_remove_row</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_remove_column</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, gint             position
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_insert_next_to</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, GtkWidget       *sibling, GtkPositionType  side
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_row_homogeneous</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, gboolean         homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_row_homogeneous</NAME>
<RETURNS>gboolean    </RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_row_spacing</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, guint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_row_spacing</NAME>
<RETURNS>guint       </RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_column_homogeneous</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, gboolean         homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_column_homogeneous</NAME>
<RETURNS>gboolean    </RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_column_spacing</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, guint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_column_spacing</NAME>
<RETURNS>guint       </RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_row_baseline_position</NAME>
<RETURNS>void        </RETURNS>
GtkGrid      *grid, gint          row, GtkBaselinePosition pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_row_baseline_position</NAME>
<RETURNS>GtkBaselinePosition  </RETURNS>
GtkGrid      *grid, gint          row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_set_baseline_row</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, gint             row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_get_baseline_row</NAME>
<RETURNS>gint        </RETURNS>
GtkGrid         *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_query_child</NAME>
<RETURNS>void        </RETURNS>
GtkGrid         *grid, GtkWidget       *child, gint            *left, gint            *top, gint            *width, gint            *height
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_GRID_LAYOUT</NAME>
#define GTK_TYPE_GRID_LAYOUT (gtk_grid_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_GRID_LAYOUT_CHILD</NAME>
#define GTK_TYPE_GRID_LAYOUT_CHILD (gtk_grid_layout_child_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_grid_layout_new</NAME>
<RETURNS>GtkLayoutManager  *      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_row_homogeneous</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayout       *grid, gboolean             homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_row_homogeneous</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_row_spacing</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayout       *grid, guint                spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_row_spacing</NAME>
<RETURNS>guint                    </RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_column_homogeneous</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayout       *grid, gboolean             homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_column_homogeneous</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_column_spacing</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayout       *grid, guint                spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_column_spacing</NAME>
<RETURNS>guint                    </RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_row_baseline_position</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayout       *grid, int                  row, GtkBaselinePosition  pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_row_baseline_position</NAME>
<RETURNS>GtkBaselinePosition      </RETURNS>
GtkGridLayout       *grid, int                  row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_set_baseline_row</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayout       *grid, int                  row
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_get_baseline_row</NAME>
<RETURNS>int                      </RETURNS>
GtkGridLayout       *grid
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_top_attach</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayoutChild  *child, int                  attach
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_top_attach</NAME>
<RETURNS>int                      </RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_left_attach</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayoutChild  *child, int                  attach
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_left_attach</NAME>
<RETURNS>int                      </RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_column_span</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayoutChild  *child, int                  span
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_column_span</NAME>
<RETURNS>int                      </RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_set_row_span</NAME>
<RETURNS>void                     </RETURNS>
GtkGridLayoutChild  *child, int                  span
</FUNCTION>
<FUNCTION>
<NAME>gtk_grid_layout_child_get_row_span</NAME>
<RETURNS>int                      </RETURNS>
GtkGridLayoutChild  *child
</FUNCTION>
<STRUCT>
<NAME>GtkGridLayout</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGridLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_HEADER_BAR</NAME>
#define GTK_TYPE_HEADER_BAR            (gtk_header_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_HEADER_BAR</NAME>
#define GTK_HEADER_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_HEADER_BAR, GtkHeaderBar))
</MACRO>
<MACRO>
<NAME>GTK_HEADER_BAR_CLASS</NAME>
#define GTK_HEADER_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_HEADER_BAR, GtkHeaderBarClass))
</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>
<MACRO>
<NAME>GTK_IS_HEADER_BAR_CLASS</NAME>
#define GTK_IS_HEADER_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_HEADER_BAR))
</MACRO>
<MACRO>
<NAME>GTK_HEADER_BAR_GET_CLASS</NAME>
#define GTK_HEADER_BAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_HEADER_BAR, GtkHeaderBarClass))
</MACRO>
<STRUCT>
<NAME>GtkHeaderBar</NAME>
struct _GtkHeaderBar
{
  GtkContainer container;
};
</STRUCT>
<STRUCT>
<NAME>GtkHeaderBarClass</NAME>
struct _GtkHeaderBarClass
{
  GtkContainerClass 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_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</NAME>
<RETURNS>void          </RETURNS>
GtkHeaderBar *bar, const gchar  *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_title</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkHeaderBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_set_subtitle</NAME>
<RETURNS>void          </RETURNS>
GtkHeaderBar *bar, const gchar  *subtitle
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_subtitle</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkHeaderBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_set_custom_title</NAME>
<RETURNS>void          </RETURNS>
GtkHeaderBar *bar, GtkWidget    *title_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_custom_title</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_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_has_subtitle</NAME>
<RETURNS>void          </RETURNS>
GtkHeaderBar *bar, gboolean      setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_has_subtitle</NAME>
<RETURNS>gboolean      </RETURNS>
GtkHeaderBar *bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_set_decoration_layout</NAME>
<RETURNS>void          </RETURNS>
GtkHeaderBar *bar, const gchar  *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_header_bar_get_decoration_layout</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkHeaderBar *bar
</FUNCTION>
<STRUCT>
<NAME>GtkHeaderBarPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_ICON_INFO</NAME>
#define GTK_TYPE_ICON_INFO              (gtk_icon_info_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_ICON_INFO</NAME>
#define GTK_ICON_INFO(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_ICON_INFO, GtkIconInfo))
</MACRO>
<MACRO>
<NAME>GTK_ICON_INFO_CLASS</NAME>
#define GTK_ICON_INFO_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_INFO, GtkIconInfoClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_ICON_INFO</NAME>
#define GTK_IS_ICON_INFO(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_ICON_INFO))
</MACRO>
<MACRO>
<NAME>GTK_IS_ICON_INFO_CLASS</NAME>
#define GTK_IS_ICON_INFO_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ICON_INFO))
</MACRO>
<MACRO>
<NAME>GTK_ICON_INFO_GET_CLASS</NAME>
#define GTK_ICON_INFO_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ICON_INFO, GtkIconInfoClass))
</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_ICON_THEME_CLASS</NAME>
#define GTK_ICON_THEME_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_THEME, GtkIconThemeClass))
</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>
<MACRO>
<NAME>GTK_IS_ICON_THEME_CLASS</NAME>
#define GTK_IS_ICON_THEME_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ICON_THEME))
</MACRO>
<MACRO>
<NAME>GTK_ICON_THEME_GET_CLASS</NAME>
#define GTK_ICON_THEME_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ICON_THEME, GtkIconThemeClass))
</MACRO>
<STRUCT>
<NAME>GtkIconTheme</NAME>
struct _GtkIconTheme
{
  /*< private >*/
  GObject parent_instance;

  GtkIconThemePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkIconThemeClass</NAME>
struct _GtkIconThemeClass
{
  GObjectClass parent_class;

  /*< public >*/

  void (* changed)  (GtkIconTheme *icon_theme);

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<ENUM>
<NAME>GtkIconLookupFlags</NAME>
typedef enum
{
  GTK_ICON_LOOKUP_NO_SVG           = 1 << 0,
  GTK_ICON_LOOKUP_FORCE_SVG        = 1 << 1,
  GTK_ICON_LOOKUP_USE_BUILTIN      = 1 << 2,
  GTK_ICON_LOOKUP_GENERIC_FALLBACK = 1 << 3,
  GTK_ICON_LOOKUP_FORCE_SIZE       = 1 << 4,
  GTK_ICON_LOOKUP_FORCE_REGULAR    = 1 << 5,
  GTK_ICON_LOOKUP_FORCE_SYMBOLIC   = 1 << 6,
  GTK_ICON_LOOKUP_DIR_LTR          = 1 << 7,
  GTK_ICON_LOOKUP_DIR_RTL          = 1 << 8
} 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_default</NAME>
<RETURNS>GtkIconTheme  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_for_display</NAME>
<RETURNS>GtkIconTheme  *</RETURNS>
GdkDisplay                  *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_set_display</NAME>
<RETURNS>void           </RETURNS>
GtkIconTheme                *icon_theme, GdkDisplay                  *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_set_search_path</NAME>
<RETURNS>void           </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *path[], gint                         n_elements
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_search_path</NAME>
<RETURNS>void           </RETURNS>
GtkIconTheme                *icon_theme, gchar                      **path[], gint                        *n_elements
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_append_search_path</NAME>
<RETURNS>void           </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_prepend_search_path</NAME>
<RETURNS>void           </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_add_resource_path</NAME>
<RETURNS>void           </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_set_custom_theme</NAME>
<RETURNS>void           </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *theme_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_has_icon</NAME>
<RETURNS>gboolean       </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_icon_sizes</NAME>
<RETURNS>gint          *</RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_icon</NAME>
<RETURNS>GtkIconInfo  * </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_name, gint                         size, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_icon_for_scale</NAME>
<RETURNS>GtkIconInfo  * </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_name, gint                         size, gint                         scale, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_choose_icon</NAME>
<RETURNS>GtkIconInfo  * </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_names[], gint                         size, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_choose_icon_for_scale</NAME>
<RETURNS>GtkIconInfo  * </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_names[], gint                         size, gint                         scale, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_load_icon</NAME>
<RETURNS>GdkPixbuf  *   </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_name, gint                         size, GtkIconLookupFlags           flags, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_load_icon_for_scale</NAME>
<RETURNS>GdkPixbuf  *   </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *icon_name, gint                         size, gint                         scale, GtkIconLookupFlags           flags, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_by_gicon</NAME>
<RETURNS>GtkIconInfo  * </RETURNS>
GtkIconTheme                *icon_theme, GIcon                       *icon, gint                         size, GtkIconLookupFlags           flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_lookup_by_gicon_for_scale</NAME>
<RETURNS>GtkIconInfo  * </RETURNS>
GtkIconTheme             *icon_theme, GIcon                    *icon, gint                      size, gint                      scale, GtkIconLookupFlags        flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_list_icons</NAME>
<RETURNS>GList  *       </RETURNS>
GtkIconTheme                *icon_theme, const gchar                 *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_list_contexts</NAME>
<RETURNS>GList  *       </RETURNS>
GtkIconTheme                *icon_theme
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_get_example_icon_name</NAME>
<RETURNS>char  *        </RETURNS>
GtkIconTheme                *icon_theme
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_theme_rescan_if_needed</NAME>
<RETURNS>gboolean       </RETURNS>
GtkIconTheme                *icon_theme
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_new_for_pixbuf</NAME>
<RETURNS>GtkIconInfo  *         </RETURNS>
GtkIconTheme  *icon_theme, GdkPixbuf     *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_get_base_size</NAME>
<RETURNS>gint                   </RETURNS>
GtkIconInfo   *icon_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_get_base_scale</NAME>
<RETURNS>gint                   </RETURNS>
GtkIconInfo   *icon_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_get_filename</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkIconInfo   *icon_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_is_symbolic</NAME>
<RETURNS>gboolean               </RETURNS>
GtkIconInfo   *icon_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_icon</NAME>
<RETURNS>GdkPixbuf  *           </RETURNS>
GtkIconInfo   *icon_info, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_texture</NAME>
<RETURNS>GdkTexture  *          </RETURNS>
GtkIconInfo   *icon_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_icon_async</NAME>
<RETURNS>void                   </RETURNS>
GtkIconInfo          *icon_info, GCancellable         *cancellable, GAsyncReadyCallback   callback, gpointer              user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_icon_finish</NAME>
<RETURNS>GdkPixbuf  *           </RETURNS>
GtkIconInfo          *icon_info, GAsyncResult         *res, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_symbolic</NAME>
<RETURNS>GdkPixbuf  *           </RETURNS>
GtkIconInfo   *icon_info, const GdkRGBA *fg, const GdkRGBA *success_color, const GdkRGBA *warning_color, const GdkRGBA *error_color, gboolean      *was_symbolic, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_symbolic_async</NAME>
<RETURNS>void                   </RETURNS>
GtkIconInfo   *icon_info, const GdkRGBA *fg, const GdkRGBA *success_color, const GdkRGBA *warning_color, const GdkRGBA *error_color, GCancellable         *cancellable, GAsyncReadyCallback   callback, gpointer              user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_symbolic_finish</NAME>
<RETURNS>GdkPixbuf  *           </RETURNS>
GtkIconInfo   *icon_info, GAsyncResult         *res, gboolean      *was_symbolic, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_symbolic_for_context</NAME>
<RETURNS>GdkPixbuf  *           </RETURNS>
GtkIconInfo      *icon_info, GtkStyleContext  *context, gboolean         *was_symbolic, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_symbolic_for_context_async</NAME>
<RETURNS>void                   </RETURNS>
GtkIconInfo      *icon_info, GtkStyleContext  *context, GCancellable     *cancellable, GAsyncReadyCallback callback, gpointer          user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_info_load_symbolic_for_context_finish</NAME>
<RETURNS>GdkPixbuf  *           </RETURNS>
GtkIconInfo      *icon_info, GAsyncResult     *res, gboolean         *was_symbolic, GError          **error
</FUNCTION>
<STRUCT>
<NAME>GtkIconInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkIconInfoClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkIconThemePrivate</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_ICON_VIEW_CLASS</NAME>
#define GTK_ICON_VIEW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_ICON_VIEW, GtkIconViewClass))
</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>
<MACRO>
<NAME>GTK_IS_ICON_VIEW_CLASS</NAME>
#define GTK_IS_ICON_VIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ICON_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_ICON_VIEW_GET_CLASS</NAME>
#define GTK_ICON_VIEW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_ICON_VIEW, GtkIconViewClass))
</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>
<STRUCT>
<NAME>GtkIconView</NAME>
struct _GtkIconView
{
  GtkContainer parent;

  /*< private >*/
  GtkIconViewPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkIconViewClass</NAME>
struct _GtkIconViewClass
{
  GtkContainerClass parent_class;

  void    (* item_activated)         (GtkIconView      *icon_view,
				      GtkTreePath      *path);
  void    (* selection_changed)      (GtkIconView      *icon_view);

  /* Key binding signals */
  void    (* select_all)             (GtkIconView      *icon_view);
  void    (* unselect_all)           (GtkIconView      *icon_view);
  void    (* select_cursor_item)     (GtkIconView      *icon_view);
  void    (* toggle_cursor_item)     (GtkIconView      *icon_view);
  gboolean (* move_cursor)           (GtkIconView      *icon_view,
				      GtkMovementStep   step,
				      gint              count);
  gboolean (* activate_cursor_item)  (GtkIconView      *icon_view);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_icon_view_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_new</NAME>
<RETURNS>GtkWidget  *    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_new_with_area</NAME>
<RETURNS>GtkWidget  *    </RETURNS>
GtkCellArea    *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_new_with_model</NAME>
<RETURNS>GtkWidget  *    </RETURNS>
GtkTreeModel   *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_model</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, GtkTreeModel   *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_model</NAME>
<RETURNS>GtkTreeModel  * </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_text_column</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_text_column</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_markup_column</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_markup_column</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_pixbuf_column</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_pixbuf_column</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_orientation</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_orientation</NAME>
<RETURNS>GtkOrientation  </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_columns</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            columns
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_columns</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_width</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            item_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_width</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_spacing</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_spacing</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_row_spacing</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            row_spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_row_spacing</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_column_spacing</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            column_spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_column_spacing</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_margin</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_margin</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_item_padding</NAME>
<RETURNS>void            </RETURNS>
GtkIconView    *icon_view, gint            item_padding
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_padding</NAME>
<RETURNS>gint            </RETURNS>
GtkIconView    *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_path_at_pos</NAME>
<RETURNS>GtkTreePath  *  </RETURNS>
GtkIconView     *icon_view, gint             x, gint             y
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_at_pos</NAME>
<RETURNS>gboolean        </RETURNS>
GtkIconView     *icon_view, gint              x, gint              y, GtkTreePath     **path, GtkCellRenderer **cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_visible_range</NAME>
<RETURNS>gboolean        </RETURNS>
GtkIconView      *icon_view, GtkTreePath     **start_path, GtkTreePath     **end_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_activate_on_single_click</NAME>
<RETURNS>void            </RETURNS>
GtkIconView  *icon_view, gboolean      single
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_activate_on_single_click</NAME>
<RETURNS>gboolean        </RETURNS>
GtkIconView  *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_selected_foreach</NAME>
<RETURNS>void            </RETURNS>
GtkIconView            *icon_view, GtkIconViewForeachFunc  func, gpointer                data
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_selection_mode</NAME>
<RETURNS>void            </RETURNS>
GtkIconView            *icon_view, GtkSelectionMode        mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_selection_mode</NAME>
<RETURNS>GtkSelectionMode  </RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_select_path</NAME>
<RETURNS>void              </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unselect_path</NAME>
<RETURNS>void              </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_path_is_selected</NAME>
<RETURNS>gboolean          </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_row</NAME>
<RETURNS>gint              </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_item_column</NAME>
<RETURNS>gint              </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_selected_items</NAME>
<RETURNS>GList            *</RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_select_all</NAME>
<RETURNS>void              </RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unselect_all</NAME>
<RETURNS>void              </RETURNS>
GtkIconView            *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_item_activated</NAME>
<RETURNS>void              </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_cursor</NAME>
<RETURNS>void              </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path, GtkCellRenderer        *cell, gboolean                start_editing
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_cursor</NAME>
<RETURNS>gboolean          </RETURNS>
GtkIconView            *icon_view, GtkTreePath           **path, GtkCellRenderer       **cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_scroll_to_path</NAME>
<RETURNS>void              </RETURNS>
GtkIconView            *icon_view, GtkTreePath            *path, gboolean                use_align, gfloat                  row_align, gfloat                  col_align
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_enable_model_drag_source</NAME>
<RETURNS>void                    </RETURNS>
GtkIconView              *icon_view, GdkModifierType           start_button_mask, GdkContentFormats        *formats, GdkDragAction             actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_enable_model_drag_dest</NAME>
<RETURNS>void                    </RETURNS>
GtkIconView              *icon_view, GdkContentFormats        *formats, GdkDragAction             actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unset_model_drag_source</NAME>
<RETURNS>void                    </RETURNS>
GtkIconView              *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_unset_model_drag_dest</NAME>
<RETURNS>void                    </RETURNS>
GtkIconView              *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_reorderable</NAME>
<RETURNS>void                    </RETURNS>
GtkIconView              *icon_view, gboolean                  reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_reorderable</NAME>
<RETURNS>gboolean                </RETURNS>
GtkIconView              *icon_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_drag_dest_item</NAME>
<RETURNS>void                    </RETURNS>
GtkIconView              *icon_view, GtkTreePath              *path, GtkIconViewDropPosition   pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_drag_dest_item</NAME>
<RETURNS>void                    </RETURNS>
GtkIconView              *icon_view, GtkTreePath             **path, GtkIconViewDropPosition  *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_dest_item_at_pos</NAME>
<RETURNS>gboolean                </RETURNS>
GtkIconView              *icon_view, gint                      drag_x, gint                      drag_y, GtkTreePath             **path, GtkIconViewDropPosition  *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_create_drag_icon</NAME>
<RETURNS>GdkPaintable           *</RETURNS>
GtkIconView              *icon_view, GtkTreePath              *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_cell_rect</NAME>
<RETURNS>gboolean  </RETURNS>
GtkIconView     *icon_view, GtkTreePath     *path, GtkCellRenderer *cell, GdkRectangle    *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_tooltip_item</NAME>
<RETURNS>void     </RETURNS>
GtkIconView     *icon_view, GtkTooltip      *tooltip, GtkTreePath     *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_tooltip_cell</NAME>
<RETURNS>void     </RETURNS>
GtkIconView     *icon_view, GtkTooltip      *tooltip, GtkTreePath     *path, GtkCellRenderer *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_tooltip_context</NAME>
<RETURNS>gboolean  </RETURNS>
GtkIconView       *icon_view, gint              *x, gint              *y, gboolean           keyboard_tip, GtkTreeModel     **model, GtkTreePath      **path, GtkTreeIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_set_tooltip_column</NAME>
<RETURNS>void      </RETURNS>
GtkIconView       *icon_view, gint               column
</FUNCTION>
<FUNCTION>
<NAME>gtk_icon_view_get_tooltip_column</NAME>
<RETURNS>gint      </RETURNS>
GtkIconView       *icon_view
</FUNCTION>
<STRUCT>
<NAME>GtkIconViewPrivate</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_IMAGE_CLASS</NAME>
#define GTK_IMAGE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IMAGE, GtkImageClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IMAGE</NAME>
#define GTK_IS_IMAGE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IMAGE))
</MACRO>
<MACRO>
<NAME>GTK_IS_IMAGE_CLASS</NAME>
#define GTK_IS_IMAGE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IMAGE))
</MACRO>
<MACRO>
<NAME>GTK_IMAGE_GET_CLASS</NAME>
#define GTK_IMAGE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IMAGE, GtkImageClass))
</MACRO>
<ENUM>
<NAME>GtkImageType</NAME>
typedef enum
{
  GTK_IMAGE_EMPTY,
  GTK_IMAGE_ICON_NAME,
  GTK_IMAGE_GICON,
  GTK_IMAGE_PAINTABLE
} GtkImageType;
</ENUM>
<STRUCT>
<NAME>GtkImage</NAME>
struct _GtkImage
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkImageClass</NAME>
struct _GtkImageClass
{
  GtkWidgetClass 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_image_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_file</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_resource</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar     *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_pixbuf</NAME>
<RETURNS>GtkWidget * </RETURNS>
GdkPixbuf       *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_paintable</NAME>
<RETURNS>GtkWidget * </RETURNS>
GdkPaintable    *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_icon_name</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_new_from_gicon</NAME>
<RETURNS>GtkWidget * </RETURNS>
GIcon           *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_clear</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_file</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, const gchar     *filename
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_resource</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, const gchar     *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_pixbuf</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, GdkPixbuf       *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_paintable</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, GdkPaintable    *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_icon_name</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, const gchar     *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_from_gicon</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, GIcon           *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_pixel_size</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, gint             pixel_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_set_icon_size</NAME>
<RETURNS>void  </RETURNS>
GtkImage        *image, GtkIconSize      icon_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_storage_type</NAME>
<RETURNS>GtkImageType  </RETURNS>
GtkImage   *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_paintable</NAME>
<RETURNS>GdkPaintable  *</RETURNS>
GtkImage       *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_icon_name</NAME>
<RETURNS>const char  *</RETURNS>
GtkImage     *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_gicon</NAME>
<RETURNS>GIcon  *    </RETURNS>
GtkImage              *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_pixel_size</NAME>
<RETURNS>gint        </RETURNS>
GtkImage             *image
</FUNCTION>
<FUNCTION>
<NAME>gtk_image_get_icon_size</NAME>
<RETURNS>GtkIconSize  </RETURNS>
GtkImage             *image
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_IM_CONTEXT</NAME>
#define GTK_TYPE_IM_CONTEXT              (gtk_im_context_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT</NAME>
#define GTK_IM_CONTEXT(obj)              (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_IM_CONTEXT, GtkIMContext))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_CLASS</NAME>
#define GTK_IM_CONTEXT_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_IM_CONTEXT, GtkIMContextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT</NAME>
#define GTK_IS_IM_CONTEXT(obj)           (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_IM_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IS_IM_CONTEXT_CLASS</NAME>
#define GTK_IS_IM_CONTEXT_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_IM_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IM_CONTEXT_GET_CLASS</NAME>
#define GTK_IM_CONTEXT_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_IM_CONTEXT, GtkIMContextClass))
</MACRO>
<STRUCT>
<NAME>GtkIMContext</NAME>
struct _GtkIMContext
{
  GObject parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkIMContextClass</NAME>
struct _GtkIMContextClass
{
  /*< private >*/
  GObjectClass parent_class;

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

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

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

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

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_im_multicontext_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_multicontext_new</NAME>
<RETURNS>GtkIMContext  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_multicontext_get_context_id</NAME>
<RETURNS>const char   * </RETURNS>
GtkIMMulticontext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_im_multicontext_set_context_id</NAME>
<RETURNS>void           </RETURNS>
GtkIMMulticontext *context, const char        *context_id
</FUNCTION>
<STRUCT>
<NAME>GtkIMMulticontextPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INFO_BAR</NAME>
#define GTK_TYPE_INFO_BAR              (gtk_info_bar_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INFO_BAR</NAME>
#define GTK_INFO_BAR(obj)              (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INFO_BAR, GtkInfoBar))
</MACRO>
<MACRO>
<NAME>GTK_INFO_BAR_CLASS</NAME>
#define GTK_INFO_BAR_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INFO_BAR, GtkInfoBarClass))
</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>
<MACRO>
<NAME>GTK_IS_INFO_BAR_CLASS</NAME>
#define GTK_IS_INFO_BAR_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_INFO_BAR))
</MACRO>
<MACRO>
<NAME>GTK_INFO_BAR_GET_CLASS</NAME>
#define GTK_INFO_BAR_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INFO_BAR, GtkInfoBarClass))
</MACRO>
<STRUCT>
<NAME>GtkInfoBar</NAME>
struct _GtkInfoBar
{
  GtkBox parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkInfoBarClass</NAME>
struct _GtkInfoBarClass
{
  GtkBoxClass parent_class;

  /* Signals */
  void (* response) (GtkInfoBar *info_bar, gint response_id);

  /* Keybinding signals */
  void (* close)    (GtkInfoBar *info_bar);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_info_bar_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_new</NAME>
<RETURNS>GtkWidget      *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_new_with_buttons</NAME>
<RETURNS>GtkWidget      *</RETURNS>
const gchar    *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_action_area</NAME>
<RETURNS>GtkWidget      *</RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_content_area</NAME>
<RETURNS>GtkWidget      *</RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_action_widget</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, GtkWidget      *child, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_button</NAME>
<RETURNS>GtkWidget      *</RETURNS>
GtkInfoBar     *info_bar, const gchar    *button_text, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_add_buttons</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, const gchar    *first_button_text, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_response_sensitive</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, gint            response_id, gboolean        setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_default_response</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_response</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, gint            response_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_message_type</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, GtkMessageType  message_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_message_type</NAME>
<RETURNS>GtkMessageType  </RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_show_close_button</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, gboolean        setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_show_close_button</NAME>
<RETURNS>gboolean        </RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_set_revealed</NAME>
<RETURNS>void            </RETURNS>
GtkInfoBar     *info_bar, gboolean        revealed
</FUNCTION>
<FUNCTION>
<NAME>gtk_info_bar_get_revealed</NAME>
<RETURNS>gboolean        </RETURNS>
GtkInfoBar     *info_bar
</FUNCTION>
<MACRO>
<NAME>P_</NAME>
#define P_(String) g_dgettext(GETTEXT_PACKAGE "-properties",String)
</MACRO>
<MACRO>
<NAME>I_</NAME>
#define I_(string) g_intern_static_string (string)
</MACRO>
<STRUCT>
<NAME>GtkKeyHash</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_LABEL_CLASS</NAME>
#define GTK_LABEL_CLASS(klass)	  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LABEL, GtkLabelClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LABEL</NAME>
#define GTK_IS_LABEL(obj)	  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_LABEL))
</MACRO>
<MACRO>
<NAME>GTK_IS_LABEL_CLASS</NAME>
#define GTK_IS_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LABEL))
</MACRO>
<MACRO>
<NAME>GTK_LABEL_GET_CLASS</NAME>
#define GTK_LABEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LABEL, GtkLabelClass))
</MACRO>
<STRUCT>
<NAME>GtkLabel</NAME>
struct _GtkLabel
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkLabelClass</NAME>
struct _GtkLabelClass
{
  GtkWidgetClass parent_class;

  void (* move_cursor)     (GtkLabel       *label,
			    GtkMovementStep step,
			    gint            count,
			    gboolean        extend_selection);
  void (* copy_clipboard)  (GtkLabel       *label);

  /* Hook to customize right-click popup for selectable labels */
  void (* populate_popup)   (GtkLabel       *label,
                             GtkMenu        *menu);

  gboolean (*activate_link) (GtkLabel       *label,
                             const gchar    *uri);

  /* 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_label_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_new</NAME>
<RETURNS>GtkWidget *            </RETURNS>
const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_new_with_mnemonic</NAME>
<RETURNS>GtkWidget *            </RETURNS>
const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_text</NAME>
<RETURNS>void                   </RETURNS>
GtkLabel      *label, const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_text</NAME>
<RETURNS>const gchar *          </RETURNS>
GtkLabel      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_attributes</NAME>
<RETURNS>void                   </RETURNS>
GtkLabel      *label, PangoAttrList *attrs
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_attributes</NAME>
<RETURNS>PangoAttrList         *</RETURNS>
GtkLabel      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_label</NAME>
<RETURNS>void                   </RETURNS>
GtkLabel      *label, const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_label</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkLabel      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_markup</NAME>
<RETURNS>void                   </RETURNS>
GtkLabel      *label, const gchar   *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_use_markup</NAME>
<RETURNS>void                   </RETURNS>
GtkLabel      *label, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_use_markup</NAME>
<RETURNS>gboolean               </RETURNS>
GtkLabel      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_use_underline</NAME>
<RETURNS>void                   </RETURNS>
GtkLabel      *label, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_use_underline</NAME>
<RETURNS>gboolean               </RETURNS>
GtkLabel      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_markup_with_mnemonic</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, const gchar      *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_mnemonic_keyval</NAME>
<RETURNS>guint     </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_mnemonic_widget</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_mnemonic_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_text_with_mnemonic</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, const gchar      *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_justify</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, GtkJustification  jtype
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_justify</NAME>
<RETURNS>GtkJustification  </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_ellipsize</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, PangoEllipsizeMode mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_ellipsize</NAME>
<RETURNS>PangoEllipsizeMode  </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_width_chars</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, gint              n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_width_chars</NAME>
<RETURNS>gint      </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_max_width_chars</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, gint              n_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_max_width_chars</NAME>
<RETURNS>gint      </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_lines</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, gint              lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_lines</NAME>
<RETURNS>gint      </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_pattern</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, const gchar      *pattern
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_line_wrap</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, gboolean          wrap
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_line_wrap</NAME>
<RETURNS>gboolean  </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_line_wrap_mode</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, PangoWrapMode     wrap_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_line_wrap_mode</NAME>
<RETURNS>PangoWrapMode  </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_selectable</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, gboolean          setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_selectable</NAME>
<RETURNS>gboolean  </RETURNS>
GtkLabel         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_select_region</NAME>
<RETURNS>void      </RETURNS>
GtkLabel         *label, gint              start_offset, gint              end_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_selection_bounds</NAME>
<RETURNS>gboolean  </RETURNS>
GtkLabel         *label, gint             *start, gint             *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_layout</NAME>
<RETURNS>PangoLayout  *</RETURNS>
GtkLabel *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_layout_offsets</NAME>
<RETURNS>void          </RETURNS>
GtkLabel *label, gint     *x, gint     *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_single_line_mode</NAME>
<RETURNS>void          </RETURNS>
GtkLabel *label, gboolean single_line_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_single_line_mode</NAME>
<RETURNS>gboolean      </RETURNS>
GtkLabel *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_current_uri</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkLabel *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_track_visited_links</NAME>
<RETURNS>void          </RETURNS>
GtkLabel *label, gboolean  track_links
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_track_visited_links</NAME>
<RETURNS>gboolean      </RETURNS>
GtkLabel *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_xalign</NAME>
<RETURNS>void          </RETURNS>
GtkLabel *label, gfloat    xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_xalign</NAME>
<RETURNS>gfloat        </RETURNS>
GtkLabel *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_set_yalign</NAME>
<RETURNS>void          </RETURNS>
GtkLabel *label, gfloat    yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_label_get_yalign</NAME>
<RETURNS>gfloat        </RETURNS>
GtkLabel *label
</FUNCTION>
<STRUCT>
<NAME>GtkLabelPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkLabelSelectionInfo</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LAYOUT_CHILD</NAME>
#define GTK_TYPE_LAYOUT_CHILD (gtk_layout_child_get_type())
</MACRO>
<STRUCT>
<NAME>GtkLayoutChildClass</NAME>
struct _GtkLayoutChildClass
{
  /*< private >*/
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_layout_child_get_layout_manager</NAME>
<RETURNS>GtkLayoutManager  *      </RETURNS>
GtkLayoutChild *layout_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_child_get_child_widget</NAME>
<RETURNS>GtkWidget  *             </RETURNS>
GtkLayoutChild *layout_child
</FUNCTION>
<STRUCT>
<NAME>GtkLayoutChild</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LAYOUT_MANAGER</NAME>
#define GTK_TYPE_LAYOUT_MANAGER (gtk_layout_manager_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkLayoutManagerClass</NAME>
struct _GtkLayoutManagerClass
{
  /*< private >*/
  GObjectClass parent_class;

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

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

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

  GType              layout_child_type;

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

  /*< private >*/
  gpointer _padding[16];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_layout_manager_measure</NAME>
<RETURNS>void                     </RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget, GtkOrientation    orientation, int               for_size, int              *minimum, int              *natural, int              *minimum_baseline, int              *natural_baseline
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_allocate</NAME>
<RETURNS>void                     </RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget, int               width, int               height, int               baseline
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_get_request_mode</NAME>
<RETURNS>GtkSizeRequestMode       </RETURNS>
GtkLayoutManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_get_widget</NAME>
<RETURNS>GtkWidget  *             </RETURNS>
GtkLayoutManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_layout_changed</NAME>
<RETURNS>void                     </RETURNS>
GtkLayoutManager *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_get_layout_child</NAME>
<RETURNS>GtkLayoutChild  *        </RETURNS>
GtkLayoutManager *manager, GtkWidget        *child
</FUNCTION>
<STRUCT>
<NAME>GtkLayoutManager</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_layout_manager_set_widget</NAME>
<RETURNS>void  </RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_layout_manager_remove_layout_child</NAME>
<RETURNS>void  </RETURNS>
GtkLayoutManager *manager, GtkWidget        *widget
</FUNCTION>
<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_LEVEL_BAR_CLASS</NAME>
#define GTK_LEVEL_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LEVEL_BAR, GtkLevelBarClass))
</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_IS_LEVEL_BAR_CLASS</NAME>
#define GTK_IS_LEVEL_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LEVEL_BAR))
</MACRO>
<MACRO>
<NAME>GTK_LEVEL_BAR_GET_CLASS</NAME>
#define GTK_LEVEL_BAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LEVEL_BAR, GtkLevelBarClass))
</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>
<STRUCT>
<NAME>GtkLevelBar</NAME>
struct _GtkLevelBar {
  /*< private >*/
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkLevelBarClass</NAME>
struct _GtkLevelBarClass {
  /*< private >*/
  GtkWidgetClass parent_class;

  void (* offset_changed) (GtkLevelBar *self,
                           const gchar *name);

  /* padding for future class expansion */
  gpointer padding[16];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_level_bar_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_new_for_interval</NAME>
<RETURNS>GtkWidget  *</RETURNS>
gdouble      min_value, gdouble      max_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_mode</NAME>
<RETURNS>void        </RETURNS>
GtkLevelBar *self, GtkLevelBarMode mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_mode</NAME>
<RETURNS>GtkLevelBarMode  </RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_value</NAME>
<RETURNS>void        </RETURNS>
GtkLevelBar *self, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_value</NAME>
<RETURNS>gdouble     </RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_min_value</NAME>
<RETURNS>void        </RETURNS>
GtkLevelBar *self, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_min_value</NAME>
<RETURNS>gdouble     </RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_max_value</NAME>
<RETURNS>void        </RETURNS>
GtkLevelBar *self, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_max_value</NAME>
<RETURNS>gdouble     </RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_set_inverted</NAME>
<RETURNS>void        </RETURNS>
GtkLevelBar *self, gboolean     inverted
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_inverted</NAME>
<RETURNS>gboolean    </RETURNS>
GtkLevelBar *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_add_offset_value</NAME>
<RETURNS>void        </RETURNS>
GtkLevelBar *self, const gchar *name, gdouble      value
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_remove_offset_value</NAME>
<RETURNS>void        </RETURNS>
GtkLevelBar *self, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_level_bar_get_offset_value</NAME>
<RETURNS>gboolean    </RETURNS>
GtkLevelBar *self, const gchar *name, gdouble     *value
</FUNCTION>
<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>
<MACRO>
<NAME>GTK_LINK_BUTTON_CLASS</NAME>
#define GTK_LINK_BUTTON_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LINK_BUTTON, GtkLinkButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_LINK_BUTTON_CLASS</NAME>
#define GTK_IS_LINK_BUTTON_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LINK_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_LINK_BUTTON_GET_CLASS</NAME>
#define GTK_LINK_BUTTON_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LINK_BUTTON, GtkLinkButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkLinkButton</NAME>
struct _GtkLinkButton
{
  /*< private >*/
  GtkButton parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkLinkButtonClass</NAME>
struct _GtkLinkButtonClass
{
  /*< private >*/
  GtkButtonClass parent_class;

  /*< public >*/
  gboolean (* activate_link) (GtkLinkButton *button);

  /*< private >*/
  /* Padding for future expansion */
  void (*_gtk_padding1) (void);
  void (*_gtk_padding2) (void);
  void (*_gtk_padding3) (void);
  void (*_gtk_padding4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_link_button_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_new</NAME>
<RETURNS>GtkWidget  *           </RETURNS>
const gchar   *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_new_with_label</NAME>
<RETURNS>GtkWidget  *           </RETURNS>
const gchar   *uri, const gchar   *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_get_uri</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkLinkButton *link_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_set_uri</NAME>
<RETURNS>void                   </RETURNS>
GtkLinkButton *link_button, const gchar   *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_get_visited</NAME>
<RETURNS>gboolean               </RETURNS>
GtkLinkButton *link_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_link_button_set_visited</NAME>
<RETURNS>void                   </RETURNS>
GtkLinkButton *link_button, gboolean       visited
</FUNCTION>
<STRUCT>
<NAME>GtkLinkButtonPrivate</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_LIST_BOX_CLASS</NAME>
#define GTK_LIST_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_LIST_BOX, GtkListBoxClass))
</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_IS_LIST_BOX_CLASS</NAME>
#define GTK_IS_LIST_BOX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_LIST_BOX))
</MACRO>
<MACRO>
<NAME>GTK_LIST_BOX_GET_CLASS</NAME>
#define GTK_LIST_BOX_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_LIST_BOX, GtkListBoxClass))
</MACRO>
<STRUCT>
<NAME>GtkListBox</NAME>
struct _GtkListBox
{
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkListBoxClass</NAME>
struct _GtkListBoxClass
{
  GtkContainerClass parent_class;

  /*< public >*/

  void (*row_selected)        (GtkListBox      *box,
                               GtkListBoxRow   *row);
  void (*row_activated)       (GtkListBox      *box,
                               GtkListBoxRow   *row);
  void (*activate_cursor_row) (GtkListBox      *box);
  void (*toggle_cursor_row)   (GtkListBox      *box);
  void (*move_cursor)         (GtkListBox      *box,
                               GtkMovementStep  step,
                               gint             count);
  void (*selected_rows_changed) (GtkListBox    *box);
  void (*select_all)            (GtkListBox    *box);
  void (*unselect_all)          (GtkListBox    *box);

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
};
</STRUCT>
<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
{
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkListBoxRowClass</NAME>
struct _GtkListBoxRowClass
{
  GtkBinClass parent_class;

  /*< public >*/

  void (* activate) (GtkListBoxRow *row);

  /*< private >*/

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_list_store_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_new</NAME>
<RETURNS>GtkListStore  *</RETURNS>
gint          n_columns, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_newv</NAME>
<RETURNS>GtkListStore  *</RETURNS>
gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_column_types</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_value</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          column, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_valuesv</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_set_valist</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, va_list       var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_remove</NAME>
<RETURNS>gboolean       </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_before</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_after</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_with_values</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          position, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_insert_with_valuesv</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter, gint          position, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_prepend</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_append</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_clear</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *list_store
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_iter_is_valid</NAME>
<RETURNS>gboolean       </RETURNS>
GtkListStore *list_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_reorder</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *store, gint         *new_order
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_swap</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *store, GtkTreeIter  *a, GtkTreeIter  *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_move_after</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<FUNCTION>
<NAME>gtk_list_store_move_before</NAME>
<RETURNS>void           </RETURNS>
GtkListStore *store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<STRUCT>
<NAME>GtkListStorePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_LOCK_BUTTON</NAME>
#define GTK_TYPE_LOCK_BUTTON         (gtk_lock_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_LOCK_BUTTON</NAME>
#define GTK_LOCK_BUTTON(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_LOCK_BUTTON, GtkLockButton))
</MACRO>
<MACRO>
<NAME>GTK_LOCK_BUTTON_CLASS</NAME>
#define GTK_LOCK_BUTTON_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_LOCK_BUTTON,  GtkLockButtonClass))
</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>
<MACRO>
<NAME>GTK_IS_LOCK_BUTTON_CLASS</NAME>
#define GTK_IS_LOCK_BUTTON_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_LOCK_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_LOCK_BUTTON_GET_CLASS</NAME>
#define GTK_LOCK_BUTTON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_LOCK_BUTTON, GtkLockButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkLockButton</NAME>
struct _GtkLockButton
{
  GtkButton parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkLockButtonClass</NAME>
struct _GtkLockButtonClass
{
  GtkButtonClass parent_class;

  /*< private >*/

  void (*reserved0) (void);
  void (*reserved1) (void);
  void (*reserved2) (void);
  void (*reserved3) (void);
  void (*reserved4) (void);
  void (*reserved5) (void);
  void (*reserved6) (void);
  void (*reserved7) (void);
};
</STRUCT>
<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>
<MACRO>
<NAME>GTK_PRIORITY_RESIZE</NAME>
#define GTK_PRIORITY_RESIZE (G_PRIORITY_HIGH_IDLE + 10)
</MACRO>
<FUNCTION>
<NAME>gtk_get_major_version</NAME>
<RETURNS>guint  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_minor_version</NAME>
<RETURNS>guint  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_micro_version</NAME>
<RETURNS>guint  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_binary_age</NAME>
<RETURNS>guint  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_interface_age</NAME>
<RETURNS>guint  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_check_version</NAME>
<RETURNS>const gchar * </RETURNS>
guint   required_major, guint   required_minor, guint   required_micro
</FUNCTION>
<FUNCTION>
<NAME>gtk_init</NAME>
<RETURNS>void      </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_init_check</NAME>
<RETURNS>gboolean  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_is_initialized</NAME>
<RETURNS>gboolean  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_main_thread</NAME>
<RETURNS>GThread  * </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>
<FUNCTION>
<NAME>gtk_events_pending</NAME>
<RETURNS>gboolean        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_main_do_event</NAME>
<RETURNS>void        </RETURNS>
GdkEvent           *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_main</NAME>
<RETURNS>void        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_main_level</NAME>
<RETURNS>guint       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_main_quit</NAME>
<RETURNS>void        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_main_iteration</NAME>
<RETURNS>gboolean    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_main_iteration_do</NAME>
<RETURNS>gboolean    </RETURNS>
gboolean            blocking
</FUNCTION>
<FUNCTION>
<NAME>gtk_grab_add</NAME>
<RETURNS>void        </RETURNS>
GtkWidget          *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_grab_get_current</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_grab_remove</NAME>
<RETURNS>void        </RETURNS>
GtkWidget          *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_device_grab_add</NAME>
<RETURNS>void        </RETURNS>
GtkWidget          *widget, GdkDevice          *device, gboolean            block_others
</FUNCTION>
<FUNCTION>
<NAME>gtk_device_grab_remove</NAME>
<RETURNS>void        </RETURNS>
GtkWidget          *widget, GdkDevice          *device
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_current_event</NAME>
<RETURNS>GdkEvent  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_current_event_time</NAME>
<RETURNS>guint32     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_current_event_state</NAME>
<RETURNS>gboolean    </RETURNS>
GdkModifierType *state
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_current_event_device</NAME>
<RETURNS>GdkDevice  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_event_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
const GdkEvent  *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_event_target</NAME>
<RETURNS>GtkWidget  *</RETURNS>
const GdkEvent  *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_get_event_target_with_type</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GdkEvent *event, GType     type
</FUNCTION>
<FUNCTION>
<NAME>gtk_propagate_event</NAME>
<RETURNS>void        </RETURNS>
GtkWidget       *widget, GdkEvent        *event
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_MAP_LIST_MODEL</NAME>
#define GTK_TYPE_MAP_LIST_MODEL (gtk_map_list_model_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkMapListModelMapFunc</NAME>
<RETURNS>gpointer </RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_new</NAME>
<RETURNS>GtkMapListModel  *       </RETURNS>
GType                   item_type, GListModel             *model, GtkMapListModelMapFunc  map_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_set_map_func</NAME>
<RETURNS>void                     </RETURNS>
GtkMapListModel        *self, GtkMapListModelMapFunc  map_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_set_model</NAME>
<RETURNS>void                     </RETURNS>
GtkMapListModel        *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_get_model</NAME>
<RETURNS>GListModel  *            </RETURNS>
GtkMapListModel        *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_map_list_model_has_map</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMapListModel        *self
</FUNCTION>
<STRUCT>
<NAME>GtkMapListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MEDIA_CONTROLS</NAME>
#define GTK_TYPE_MEDIA_CONTROLS         (gtk_media_controls_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_media_controls_new</NAME>
<RETURNS>GtkWidget       *</RETURNS>
GtkMediaStream         *stream
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_controls_get_media_stream</NAME>
<RETURNS>GtkMediaStream  *</RETURNS>
GtkMediaControls       *controls
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_controls_set_media_stream</NAME>
<RETURNS>void             </RETURNS>
GtkMediaControls       *controls, GtkMediaStream         *stream
</FUNCTION>
<STRUCT>
<NAME>GtkMediaControls</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_MEDIA_FILE_EXTENSION_POINT_NAME</NAME>
#define GTK_MEDIA_FILE_EXTENSION_POINT_NAME "gtk-media-file"
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MEDIA_FILE</NAME>
#define GTK_TYPE_MEDIA_FILE             (gtk_media_file_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkMediaFileClass</NAME>
struct _GtkMediaFileClass
{
  GtkMediaStreamClass parent_class;

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

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
  void (*_gtk_reserved5) (void);
  void (*_gtk_reserved6) (void);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_media_stream_is_prepared</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_error</NAME>
<RETURNS>const GError  *          </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_has_audio</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_has_video</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_play</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_pause</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_playing</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_playing</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, gboolean        playing
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_ended</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_timestamp</NAME>
<RETURNS>gint64                   </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_duration</NAME>
<RETURNS>gint64                   </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_is_seekable</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_is_seeking</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_seek</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, gint64          timestamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_loop</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_loop</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, gboolean        loop
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_muted</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_muted</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, gboolean        muted
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_get_volume</NAME>
<RETURNS>double                   </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_set_volume</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, double          volume
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_realize</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, GdkSurface      *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_unrealize</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, GdkSurface      *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_prepared</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, gboolean        has_audio, gboolean        has_video, gboolean        seekable, gint64          duration
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_unprepared</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_update</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, gint64          timestamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_ended</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_seek_success</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_seek_failed</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_gerror</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, GError         *error
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_error</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, GQuark          domain, gint            code, const gchar    *format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_media_stream_error_valist</NAME>
<RETURNS>void                     </RETURNS>
GtkMediaStream *self, GQuark          domain, gint            code, const gchar    *format, va_list         args
</FUNCTION>
<STRUCT>
<NAME>GtkMediaStream</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU</NAME>
#define GTK_TYPE_MENU			(gtk_menu_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU</NAME>
#define GTK_MENU(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU, GtkMenu))
</MACRO>
<MACRO>
<NAME>GTK_MENU_CLASS</NAME>
#define GTK_MENU_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU, GtkMenuClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU</NAME>
#define GTK_IS_MENU(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_CLASS</NAME>
#define GTK_IS_MENU_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU))
</MACRO>
<MACRO>
<NAME>GTK_MENU_GET_CLASS</NAME>
#define GTK_MENU_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU, GtkMenuClass))
</MACRO>
<ENUM>
<NAME>GtkArrowPlacement</NAME>
typedef enum
{
  GTK_ARROWS_BOTH,
  GTK_ARROWS_START,
  GTK_ARROWS_END
} GtkArrowPlacement;
</ENUM>
<USER_FUNCTION>
<NAME>GtkMenuDetachFunc</NAME>
<RETURNS>void </RETURNS>
GtkWidget *attach_widget,
				     GtkMenu   *menu
</USER_FUNCTION>
<STRUCT>
<NAME>GtkMenu</NAME>
struct _GtkMenu
{
  GtkMenuShell menu_shell;

  /*< private >*/
  GtkMenuPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuClass</NAME>
struct _GtkMenuClass
{
  GtkMenuShellClass 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_menu_get_type</NAME>
<RETURNS>GType 	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_new_from_model</NAME>
<RETURNS>GtkWidget * </RETURNS>
GMenuModel *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_popup_at_rect</NAME>
<RETURNS>void        </RETURNS>
GtkMenu             *menu, GdkSurface          *rect_surface, const GdkRectangle  *rect, GdkGravity           rect_anchor, GdkGravity           menu_anchor, const GdkEvent      *trigger_event
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_popup_at_widget</NAME>
<RETURNS>void        </RETURNS>
GtkMenu             *menu, GtkWidget           *widget, GdkGravity           widget_anchor, GdkGravity           menu_anchor, const GdkEvent      *trigger_event
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_popup_at_pointer</NAME>
<RETURNS>void        </RETURNS>
GtkMenu             *menu, const GdkEvent      *trigger_event
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_reposition</NAME>
<RETURNS>void 	   </RETURNS>
GtkMenu	       *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_popdown</NAME>
<RETURNS>void 	   </RETURNS>
GtkMenu	       *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_get_active</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkMenu	       *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_set_active</NAME>
<RETURNS>void 	   </RETURNS>
GtkMenu	       *menu, guint		index
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_set_accel_group</NAME>
<RETURNS>void 	       </RETURNS>
GtkMenu	       *menu, GtkAccelGroup       *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_get_accel_group</NAME>
<RETURNS>GtkAccelGroup * </RETURNS>
GtkMenu	       *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_set_accel_path</NAME>
<RETURNS>void            </RETURNS>
GtkMenu             *menu, const gchar         *accel_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_get_accel_path</NAME>
<RETURNS>const gchar *   </RETURNS>
GtkMenu             *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_attach_to_widget</NAME>
<RETURNS>void 	   </RETURNS>
GtkMenu	       *menu, GtkWidget	       *attach_widget, GtkMenuDetachFunc	detacher
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_detach</NAME>
<RETURNS>void 	   </RETURNS>
GtkMenu	       *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_get_attach_widget</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkMenu	       *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_reorder_child</NAME>
<RETURNS>void        </RETURNS>
GtkMenu             *menu, GtkWidget           *child, gint                position
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_set_monitor</NAME>
<RETURNS>void        </RETURNS>
GtkMenu             *menu, gint                 monitor_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_get_monitor</NAME>
<RETURNS>gint        </RETURNS>
GtkMenu             *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_place_on_monitor</NAME>
<RETURNS>void        </RETURNS>
GtkMenu             *menu, GdkMonitor          *monitor
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_get_for_attach_widget</NAME>
<RETURNS>GList *     </RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_set_reserve_toggle_size</NAME>
<RETURNS>void      </RETURNS>
GtkMenu  *menu, gboolean   reserve_toggle_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_get_reserve_toggle_size</NAME>
<RETURNS>gboolean  </RETURNS>
GtkMenu  *menu
</FUNCTION>
<STRUCT>
<NAME>GtkMenuPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_BAR</NAME>
#define	GTK_TYPE_MENU_BAR               (gtk_menu_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_BAR</NAME>
#define GTK_MENU_BAR(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_BAR, GtkMenuBar))
</MACRO>
<MACRO>
<NAME>GTK_MENU_BAR_CLASS</NAME>
#define GTK_MENU_BAR_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_BAR, GtkMenuBarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_BAR</NAME>
#define GTK_IS_MENU_BAR(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_BAR))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_BAR_CLASS</NAME>
#define GTK_IS_MENU_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_BAR))
</MACRO>
<MACRO>
<NAME>GTK_MENU_BAR_GET_CLASS</NAME>
#define GTK_MENU_BAR_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_BAR, GtkMenuBarClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuBar</NAME>
struct _GtkMenuBar
{
  GtkMenuShell menu_shell;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuBarClass</NAME>
struct _GtkMenuBarClass
{
  GtkMenuShellClass 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_menu_bar_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_bar_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_bar_new_from_model</NAME>
<RETURNS>GtkWidget * </RETURNS>
GMenuModel *model
</FUNCTION>
<STRUCT>
<NAME>GtkMenuBarPrivate</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_MENU_BUTTON_CLASS</NAME>
#define GTK_MENU_BUTTON_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_BUTTON, GtkMenuButtonClass))
</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>
<MACRO>
<NAME>GTK_IS_MENU_BUTTON_CLASS</NAME>
#define GTK_IS_MENU_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON_GET_CLASS</NAME>
#define GTK_MENU_BUTTON_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_BUTTON, GtkMenuButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuButton</NAME>
struct _GtkMenuButton
{
  GtkToggleButton parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuButtonClass</NAME>
struct _GtkMenuButtonClass
{
  GtkToggleButtonClass 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_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_popup</NAME>
<RETURNS>void          </RETURNS>
GtkMenuButton *menu_button, GtkWidget     *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_popup</NAME>
<RETURNS>GtkMenu      *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_popover</NAME>
<RETURNS>void          </RETURNS>
GtkMenuButton *menu_button, GtkWidget     *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_popover</NAME>
<RETURNS>GtkPopover   *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_direction</NAME>
<RETURNS>void          </RETURNS>
GtkMenuButton *menu_button, GtkArrowType   direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_direction</NAME>
<RETURNS>GtkArrowType  </RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_menu_model</NAME>
<RETURNS>void          </RETURNS>
GtkMenuButton *menu_button, GMenuModel    *menu_model
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_menu_model</NAME>
<RETURNS>GMenuModel   *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_align_widget</NAME>
<RETURNS>void          </RETURNS>
GtkMenuButton *menu_button, GtkWidget     *align_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_align_widget</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_set_use_popover</NAME>
<RETURNS>void          </RETURNS>
GtkMenuButton *menu_button, gboolean       use_popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_button_get_use_popover</NAME>
<RETURNS>gboolean      </RETURNS>
GtkMenuButton *menu_button
</FUNCTION>
<STRUCT>
<NAME>GtkMenuButtonPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_ITEM</NAME>
#define GTK_TYPE_MENU_ITEM            (gtk_menu_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_ITEM</NAME>
#define GTK_MENU_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ITEM, GtkMenuItem))
</MACRO>
<MACRO>
<NAME>GTK_MENU_ITEM_CLASS</NAME>
#define GTK_MENU_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ITEM, GtkMenuItemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_ITEM</NAME>
#define GTK_IS_MENU_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_ITEM_CLASS</NAME>
#define GTK_IS_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_MENU_ITEM_GET_CLASS</NAME>
#define GTK_MENU_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_ITEM, GtkMenuItemClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuItem</NAME>
struct _GtkMenuItem
{
  GtkBin bin;

  /*< private >*/
  GtkMenuItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuItemClass</NAME>
struct _GtkMenuItemClass
{
  GtkBinClass parent_class;

  /*< public >*/

  /* If the following flag is true, then we should always
   * hide the menu when the MenuItem is activated. Otherwise,
   * it is up to the caller. For instance, when navigating
   * a menu with the keyboard, <Space> doesn't hide, but
   * <Return> does.
   */
  guint hide_on_activate : 1;

  void (* activate)             (GtkMenuItem *menu_item);
  void (* activate_item)        (GtkMenuItem *menu_item);
  void (* toggle_size_request)  (GtkMenuItem *menu_item,
                                 gint        *requisition);
  void (* toggle_size_allocate) (GtkMenuItem *menu_item,
                                 gint         allocation);
  void (* set_label)            (GtkMenuItem *menu_item,
                                 const gchar *label);
  const gchar * (* get_label)   (GtkMenuItem *menu_item);

  void (* select)               (GtkMenuItem *menu_item);
  void (* deselect)             (GtkMenuItem *menu_item);

  /*< 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_menu_item_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_new_with_label</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_new_with_mnemonic</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_set_submenu</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem         *menu_item, GtkWidget           *submenu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_get_submenu</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkMenuItem         *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_select</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem         *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_deselect</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem         *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_activate</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem         *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_toggle_size_request</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem         *menu_item, gint                *requisition
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_toggle_size_allocate</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem         *menu_item, gint                 allocation
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_set_accel_path</NAME>
<RETURNS>void           </RETURNS>
GtkMenuItem         *menu_item, const gchar         *accel_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_get_accel_path</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkMenuItem    *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_set_label</NAME>
<RETURNS>void           </RETURNS>
GtkMenuItem         *menu_item, const gchar         *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_get_label</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkMenuItem         *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_set_use_underline</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem         *menu_item, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_get_use_underline</NAME>
<RETURNS>gboolean    </RETURNS>
GtkMenuItem         *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_set_reserve_indicator</NAME>
<RETURNS>void        </RETURNS>
GtkMenuItem        *menu_item, gboolean            reserve
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_item_get_reserve_indicator</NAME>
<RETURNS>gboolean    </RETURNS>
GtkMenuItem        *menu_item
</FUNCTION>
<STRUCT>
<NAME>GtkMenuItemPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_SECTION_BOX</NAME>
#define GTK_TYPE_MENU_SECTION_BOX                           (gtk_menu_section_box_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_SECTION_BOX</NAME>
#define GTK_MENU_SECTION_BOX(inst)                          (G_TYPE_CHECK_INSTANCE_CAST ((inst),                     \
                                                             GTK_TYPE_MENU_SECTION_BOX, GtkMenuSectionBox))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SECTION_BOX_CLASS</NAME>
#define GTK_MENU_SECTION_BOX_CLASS(class)                   (G_TYPE_CHECK_CLASS_CAST ((class),                       \
                                                             GTK_TYPE_MENU_SECTION_BOX, GtkMenuSectionBoxClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SECTION_BOX</NAME>
#define GTK_IS_MENU_SECTION_BOX(inst)                       (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                     \
                                                             GTK_TYPE_MENU_SECTION_BOX))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SECTION_BOX_CLASS</NAME>
#define GTK_IS_MENU_SECTION_BOX_CLASS(class)                (G_TYPE_CHECK_CLASS_TYPE ((class),                       \
                                                             GTK_TYPE_MENU_SECTION_BOX))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SECTION_BOX_GET_CLASS</NAME>
#define GTK_MENU_SECTION_BOX_GET_CLASS(inst)                (G_TYPE_INSTANCE_GET_CLASS ((inst),                      \
                                                             GTK_TYPE_MENU_SECTION_BOX, GtkMenuSectionBoxClass))
</MACRO>
<FUNCTION>
<NAME>gtk_menu_section_box_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_section_box_new_toplevel</NAME>
<RETURNS>void                     </RETURNS>
GtkStack    *stack, GMenuModel  *model, const gchar *action_namespace, GtkPopover  *popover
</FUNCTION>
<STRUCT>
<NAME>GtkMenuSectionBox</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_SHELL</NAME>
#define GTK_TYPE_MENU_SHELL             (gtk_menu_shell_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_SHELL</NAME>
#define GTK_MENU_SHELL(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_SHELL, GtkMenuShell))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SHELL_CLASS</NAME>
#define GTK_MENU_SHELL_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_SHELL, GtkMenuShellClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SHELL</NAME>
#define GTK_IS_MENU_SHELL(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_SHELL))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SHELL_CLASS</NAME>
#define GTK_IS_MENU_SHELL_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_SHELL))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SHELL_GET_CLASS</NAME>
#define GTK_MENU_SHELL_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_SHELL, GtkMenuShellClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuShell</NAME>
struct _GtkMenuShell
{
  GtkContainer container;

  /*< private >*/
  GtkMenuShellPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuShellClass</NAME>
struct _GtkMenuShellClass
{
  GtkContainerClass parent_class;

  guint submenu_placement : 1;

  void     (*deactivate)       (GtkMenuShell *menu_shell);
  void     (*selection_done)   (GtkMenuShell *menu_shell);

  void     (*move_current)     (GtkMenuShell *menu_shell,
                                GtkMenuDirectionType direction);
  void     (*activate_current) (GtkMenuShell *menu_shell,
                                gboolean      force_hide);
  void     (*cancel)           (GtkMenuShell *menu_shell);
  void     (*select_item)      (GtkMenuShell *menu_shell,
                                GtkWidget    *menu_item);
  void     (*insert)           (GtkMenuShell *menu_shell,
                                GtkWidget    *child,
                                gint          position);
  gint     (*get_popup_delay)  (GtkMenuShell *menu_shell);
  gboolean (*move_selected)    (GtkMenuShell *menu_shell,
                                gint          distance);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_menu_shell_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_append</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_prepend</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell, GtkWidget    *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_insert</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell, GtkWidget    *child, gint          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_deactivate</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_select_item</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell, GtkWidget    *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_deselect</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_activate_item</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell, GtkWidget    *menu_item, gboolean      force_deactivate
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_select_first</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell, gboolean      search_sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_cancel</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_get_take_focus</NAME>
<RETURNS>gboolean  </RETURNS>
GtkMenuShell *menu_shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_set_take_focus</NAME>
<RETURNS>void      </RETURNS>
GtkMenuShell *menu_shell, gboolean      take_focus
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_get_selected_item</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkMenuShell *menu_shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_get_parent_shell</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkMenuShell *menu_shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_shell_bind_model</NAME>
<RETURNS>void        </RETURNS>
GtkMenuShell *menu_shell, GMenuModel   *model, const gchar  *action_namespace, gboolean      with_separators
</FUNCTION>
<STRUCT>
<NAME>GtkMenuShellPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_TOOL_BUTTON</NAME>
#define GTK_TYPE_MENU_TOOL_BUTTON         (gtk_menu_tool_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_TOOL_BUTTON</NAME>
#define GTK_MENU_TOOL_BUTTON(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_MENU_TOOL_BUTTON, GtkMenuToolButton))
</MACRO>
<MACRO>
<NAME>GTK_MENU_TOOL_BUTTON_CLASS</NAME>
#define GTK_MENU_TOOL_BUTTON_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GTK_TYPE_MENU_TOOL_BUTTON, GtkMenuToolButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_TOOL_BUTTON</NAME>
#define GTK_IS_MENU_TOOL_BUTTON(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_MENU_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_TOOL_BUTTON_CLASS</NAME>
#define GTK_IS_MENU_TOOL_BUTTON_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_MENU_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_MENU_TOOL_BUTTON_GET_CLASS</NAME>
#define GTK_MENU_TOOL_BUTTON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_MENU_TOOL_BUTTON, GtkMenuToolButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuToolButton</NAME>
struct _GtkMenuToolButton
{
  GtkToolButton parent;

  /*< private >*/
  GtkMenuToolButtonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuToolButtonClass</NAME>
struct _GtkMenuToolButtonClass
{
  GtkToolButtonClass parent_class;

  /*< public >*/

  void (*show_menu) (GtkMenuToolButton *button);

  /*< 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_menu_tool_button_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tool_button_new</NAME>
<RETURNS>GtkToolItem   *</RETURNS>
GtkWidget   *icon_widget, const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tool_button_set_menu</NAME>
<RETURNS>void           </RETURNS>
GtkMenuToolButton *button, GtkWidget         *menu
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tool_button_get_menu</NAME>
<RETURNS>GtkWidget     *</RETURNS>
GtkMenuToolButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tool_button_set_arrow_tooltip_text</NAME>
<RETURNS>void           </RETURNS>
GtkMenuToolButton *button, const gchar       *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tool_button_set_arrow_tooltip_markup</NAME>
<RETURNS>void           </RETURNS>
GtkMenuToolButton *button, const gchar       *markup
</FUNCTION>
<STRUCT>
<NAME>GtkMenuToolButtonPrivate</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkMenuTrackerInsertFunc</NAME>
<RETURNS>void </RETURNS>
GtkMenuTrackerItem       *item,
                                                                         gint                      position,
                                                                         gpointer                  user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkMenuTrackerRemoveFunc</NAME>
<RETURNS>void </RETURNS>
gint                      position,
                                                                         gpointer                  user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_new</NAME>
<RETURNS>GtkMenuTracker  *        </RETURNS>
GtkActionObservable      *observer, GMenuModel               *model, gboolean                  with_separators, gboolean                  merge_sections, gboolean                  mac_os_mode, const gchar              *action_namespace, GtkMenuTrackerInsertFunc  insert_func, GtkMenuTrackerRemoveFunc  remove_func, gpointer                  user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_new_for_item_link</NAME>
<RETURNS>GtkMenuTracker  *        </RETURNS>
GtkMenuTrackerItem       *item, const gchar              *link_name, gboolean                  merge_sections, gboolean                  mac_os_mode, GtkMenuTrackerInsertFunc  insert_func, GtkMenuTrackerRemoveFunc  remove_func, gpointer                  user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_free</NAME>
<RETURNS>void                     </RETURNS>
GtkMenuTracker           *tracker
</FUNCTION>
<STRUCT>
<NAME>GtkMenuTracker</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_TRACKER_ITEM</NAME>
#define GTK_TYPE_MENU_TRACKER_ITEM                          (gtk_menu_tracker_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_TRACKER_ITEM</NAME>
#define GTK_MENU_TRACKER_ITEM(inst)                         (G_TYPE_CHECK_INSTANCE_CAST ((inst), \
                                                             GTK_TYPE_MENU_TRACKER_ITEM, GtkMenuTrackerItem))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_TRACKER_ITEM</NAME>
#define GTK_IS_MENU_TRACKER_ITEM(inst)                      (G_TYPE_CHECK_INSTANCE_TYPE ((inst), \
                                                             GTK_TYPE_MENU_TRACKER_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MENU_TRACKER_ITEM_ROLE</NAME>
#define GTK_TYPE_MENU_TRACKER_ITEM_ROLE                     (gtk_menu_tracker_item_role_get_type ())
</MACRO>
<ENUM>
<NAME>GtkMenuTrackerItemRole</NAME>
typedef enum  {
  GTK_MENU_TRACKER_ITEM_ROLE_NORMAL,
  GTK_MENU_TRACKER_ITEM_ROLE_CHECK,
  GTK_MENU_TRACKER_ITEM_ROLE_RADIO,
} GtkMenuTrackerItemRole;
</ENUM>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_role_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_special</NAME>
<RETURNS>const gchar  *           </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_display_hint</NAME>
<RETURNS>const gchar  *           </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_text_direction</NAME>
<RETURNS>const gchar  *           </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_is_separator</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_has_link</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self, const gchar        *link_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_label</NAME>
<RETURNS>const gchar  *           </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_icon</NAME>
<RETURNS>GIcon  *                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_verb_icon</NAME>
<RETURNS>GIcon  *                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_sensitive</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_role</NAME>
<RETURNS>GtkMenuTrackerItemRole   </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_toggled</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_accel</NAME>
<RETURNS>const gchar  *           </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_may_disappear</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_is_visible</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_should_request_show</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_activated</NAME>
<RETURNS>void                     </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_request_submenu_shown</NAME>
<RETURNS>void                     </RETURNS>
GtkMenuTrackerItem *self, gboolean            shown
</FUNCTION>
<FUNCTION>
<NAME>gtk_menu_tracker_item_get_submenu_shown</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkMenuTrackerItem *self
</FUNCTION>
<STRUCT>
<NAME>GtkMenuTrackerItem</NAME>
</STRUCT>
<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_MESSAGE_DIALOG_CLASS</NAME>
#define GTK_MESSAGE_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_MESSAGE_DIALOG_CLASS</NAME>
#define GTK_IS_MESSAGE_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MESSAGE_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_MESSAGE_DIALOG_GET_CLASS</NAME>
#define GTK_MESSAGE_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MESSAGE_DIALOG, GtkMessageDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkMessageDialog</NAME>
struct _GtkMessageDialog
{
  GtkDialog parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkMessageDialogClass</NAME>
struct _GtkMessageDialogClass
{
  GtkDialogClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<ENUM>
<NAME>GtkButtonsType</NAME>
typedef enum
{
  GTK_BUTTONS_NONE,
  GTK_BUTTONS_OK,
  GTK_BUTTONS_CLOSE,
  GTK_BUTTONS_CANCEL,
  GTK_BUTTONS_YES_NO,
  GTK_BUTTONS_OK_CANCEL
} GtkButtonsType;
</ENUM>
<FUNCTION>
<NAME>gtk_message_dialog_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkWindow      *parent, GtkDialogFlags  flags, GtkMessageType  type, GtkButtonsType  buttons, const gchar    *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_new_with_markup</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkWindow      *parent, GtkDialogFlags  flags, GtkMessageType  type, GtkButtonsType  buttons, const gchar    *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_set_markup</NAME>
<RETURNS>void        </RETURNS>
GtkMessageDialog *message_dialog, const gchar      *str
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_format_secondary_text</NAME>
<RETURNS>void        </RETURNS>
GtkMessageDialog *message_dialog, const gchar      *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_format_secondary_markup</NAME>
<RETURNS>void        </RETURNS>
GtkMessageDialog *message_dialog, const gchar      *message_format, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_message_dialog_get_message_area</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkMessageDialog *message_dialog
</FUNCTION>
<TYPEDEF>
<NAME>GtkMnemonicHash</NAME>
typedef struct _GtkMnemnonicHash GtkMnemonicHash;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GtkMnemonicHashForeach</NAME>
<RETURNS>void </RETURNS>
guint      keyval,
					GSList    *targets,
					gpointer   data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_MODEL_BUTTON</NAME>
#define GTK_TYPE_MODEL_BUTTON         (gtk_model_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MODEL_BUTTON</NAME>
#define GTK_MODEL_BUTTON(inst)        (G_TYPE_CHECK_INSTANCE_CAST ((inst),                      \
                                      GTK_TYPE_MODEL_BUTTON, GtkModelButton))
</MACRO>
<MACRO>
<NAME>GTK_IS_MODEL_BUTTON</NAME>
#define GTK_IS_MODEL_BUTTON(inst)     (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                      \
                                      GTK_TYPE_MODEL_BUTTON))
</MACRO>
<ENUM>
<NAME>GtkButtonRole</NAME>
typedef enum {
  GTK_BUTTON_ROLE_NORMAL,
  GTK_BUTTON_ROLE_CHECK,
  GTK_BUTTON_ROLE_RADIO
} GtkButtonRole;
</ENUM>
<FUNCTION>
<NAME>gtk_model_button_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_model_button_new</NAME>
<RETURNS>GtkWidget  * </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkModelButton</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MODEL_MENU_ITEM</NAME>
#define GTK_TYPE_MODEL_MENU_ITEM                            (gtk_model_menu_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MODEL_MENU_ITEM</NAME>
#define GTK_MODEL_MENU_ITEM(inst)                           (G_TYPE_CHECK_INSTANCE_CAST ((inst),                      \
                                                             GTK_TYPE_MODEL_MENU_ITEM, GtkModelMenuItem))
</MACRO>
<MACRO>
<NAME>GTK_IS_MODEL_MENU_ITEM</NAME>
#define GTK_IS_MODEL_MENU_ITEM(inst)                        (G_TYPE_CHECK_INSTANCE_TYPE ((inst),                      \
                                                             GTK_TYPE_MODEL_MENU_ITEM))
</MACRO>
<FUNCTION>
<NAME>gtk_model_menu_item_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_model_menu_item_new</NAME>
<RETURNS>GtkWidget  *             </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkModelMenuItem</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MOUNT_OPERATION</NAME>
#define GTK_TYPE_MOUNT_OPERATION         (gtk_mount_operation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MOUNT_OPERATION</NAME>
#define GTK_MOUNT_OPERATION(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_MOUNT_OPERATION, GtkMountOperation))
</MACRO>
<MACRO>
<NAME>GTK_MOUNT_OPERATION_CLASS</NAME>
#define GTK_MOUNT_OPERATION_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), GTK_TYPE_MOUNT_OPERATION, GtkMountOperationClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MOUNT_OPERATION</NAME>
#define GTK_IS_MOUNT_OPERATION(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_MOUNT_OPERATION))
</MACRO>
<MACRO>
<NAME>GTK_IS_MOUNT_OPERATION_CLASS</NAME>
#define GTK_IS_MOUNT_OPERATION_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_MOUNT_OPERATION))
</MACRO>
<MACRO>
<NAME>GTK_MOUNT_OPERATION_GET_CLASS</NAME>
#define GTK_MOUNT_OPERATION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_MOUNT_OPERATION, GtkMountOperationClass))
</MACRO>
<STRUCT>
<NAME>GtkMountOperation</NAME>
struct _GtkMountOperation
{
  GMountOperation parent_instance;

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

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_mount_operation_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_new</NAME>
<RETURNS>GMountOperation  *</RETURNS>
GtkWindow         *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_is_showing</NAME>
<RETURNS>gboolean          </RETURNS>
GtkMountOperation *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_set_parent</NAME>
<RETURNS>void              </RETURNS>
GtkMountOperation *op, GtkWindow         *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_get_parent</NAME>
<RETURNS>GtkWindow  *      </RETURNS>
GtkMountOperation *op
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_set_display</NAME>
<RETURNS>void              </RETURNS>
GtkMountOperation *op, GdkDisplay        *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_mount_operation_get_display</NAME>
<RETURNS>GdkDisplay  *     </RETURNS>
GtkMountOperation *op
</FUNCTION>
<STRUCT>
<NAME>GtkMountOperationPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NATIVE_DIALOG</NAME>
#define GTK_TYPE_NATIVE_DIALOG             (gtk_native_dialog_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkNativeDialogClass</NAME>
struct _GtkNativeDialogClass
{
  GObjectClass parent_class;

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_native_dialog_show</NAME>
<RETURNS>void                   </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_hide</NAME>
<RETURNS>void                   </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_destroy</NAME>
<RETURNS>void                   </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_visible</NAME>
<RETURNS>gboolean               </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_set_modal</NAME>
<RETURNS>void                   </RETURNS>
GtkNativeDialog *self, gboolean modal
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_modal</NAME>
<RETURNS>gboolean               </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_set_title</NAME>
<RETURNS>void                   </RETURNS>
GtkNativeDialog *self, const char *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_title</NAME>
<RETURNS>const char  *          </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_set_transient_for</NAME>
<RETURNS>void                   </RETURNS>
GtkNativeDialog *self, GtkWindow *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_get_transient_for</NAME>
<RETURNS>GtkWindow  *           </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_native_dialog_run</NAME>
<RETURNS>gint                   </RETURNS>
GtkNativeDialog *self
</FUNCTION>
<STRUCT>
<NAME>GtkNativeDialog</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_NOTEBOOK_CLASS</NAME>
#define GTK_NOTEBOOK_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK, GtkNotebookClass))
</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_IS_NOTEBOOK_CLASS</NAME>
#define GTK_IS_NOTEBOOK_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_NOTEBOOK))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_GET_CLASS</NAME>
#define GTK_NOTEBOOK_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK, GtkNotebookClass))
</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_NOTEBOOK_PAGE_CLASS</NAME>
#define GTK_NOTEBOOK_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_PAGE, GtkNotebookPageClass))
</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>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_PAGE_CLASS</NAME>
#define GTK_IS_NOTEBOOK_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_NOTEBOOK_PAGE))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_PAGE_GET_CLASS</NAME>
#define GTK_NOTEBOOK_PAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK_PAGE, GtkNotebookPageClass))
</MACRO>
<ENUM>
<NAME>GtkNotebookTab</NAME>
typedef enum
{
  GTK_NOTEBOOK_TAB_FIRST,
  GTK_NOTEBOOK_TAB_LAST
} GtkNotebookTab;
</ENUM>
<STRUCT>
<NAME>GtkNotebook</NAME>
struct _GtkNotebook
{
  /*< private >*/
  GtkContainer container;

  GtkNotebookPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkNotebookClass</NAME>
struct _GtkNotebookClass
{
  GtkContainerClass parent_class;

  void (* switch_page)       (GtkNotebook     *notebook,
                              GtkWidget       *page,
			      guint            page_num);

  /* Action signals for keybindings */
  gboolean (* select_page)     (GtkNotebook       *notebook,
                                gboolean           move_focus);
  gboolean (* focus_tab)       (GtkNotebook       *notebook,
                                GtkNotebookTab     type);
  gboolean (* change_current_page) (GtkNotebook   *notebook,
                                gint               offset);
  void (* move_focus_out)      (GtkNotebook       *notebook,
				GtkDirectionType   direction);
  gboolean (* reorder_tab)     (GtkNotebook       *notebook,
				GtkDirectionType   direction,
				gboolean           move_to_last);

  /* More vfuncs */
  gint (* insert_page)         (GtkNotebook       *notebook,
			        GtkWidget         *child,
				GtkWidget         *tab_label,
				GtkWidget         *menu_label,
				gint               position);

  GtkNotebook * (* create_window) (GtkNotebook       *notebook,
                                   GtkWidget         *page,
                                   gint               x,
                                   gint               y);

  void (* page_reordered)      (GtkNotebook     *notebook,
                                GtkWidget       *child,
                                guint            page_num);

  void (* page_removed)        (GtkNotebook     *notebook,
                                GtkWidget       *child,
                                guint            page_num);

  void (* page_added)          (GtkNotebook     *notebook,
                                GtkWidget       *child,
                                guint            page_num);

  /* 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_notebook_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_new</NAME>
<RETURNS>GtkWidget  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_append_page</NAME>
<RETURNS>gint  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_append_page_menu</NAME>
<RETURNS>gint  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prepend_page</NAME>
<RETURNS>gint  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prepend_page_menu</NAME>
<RETURNS>gint  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_insert_page</NAME>
<RETURNS>gint  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, gint         position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_insert_page_menu</NAME>
<RETURNS>gint  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label, GtkWidget   *menu_label, gint         position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_remove_page</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook, gint         page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_group_name</NAME>
<RETURNS>void          </RETURNS>
GtkNotebook *notebook, const gchar *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_group_name</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_current_page</NAME>
<RETURNS>gint        </RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_nth_page</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkNotebook *notebook, gint         page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_n_pages</NAME>
<RETURNS>gint        </RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_num</NAME>
<RETURNS>gint        </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_current_page</NAME>
<RETURNS>void        </RETURNS>
GtkNotebook *notebook, gint         page_num
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_next_page</NAME>
<RETURNS>void        </RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_prev_page</NAME>
<RETURNS>void        </RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_show_border</NAME>
<RETURNS>void      </RETURNS>
GtkNotebook     *notebook, gboolean         show_border
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_show_border</NAME>
<RETURNS>gboolean  </RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_show_tabs</NAME>
<RETURNS>void      </RETURNS>
GtkNotebook     *notebook, gboolean         show_tabs
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_show_tabs</NAME>
<RETURNS>gboolean  </RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_pos</NAME>
<RETURNS>void      </RETURNS>
GtkNotebook     *notebook, GtkPositionType  pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_pos</NAME>
<RETURNS>GtkPositionType  </RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_scrollable</NAME>
<RETURNS>void      </RETURNS>
GtkNotebook     *notebook, gboolean         scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_scrollable</NAME>
<RETURNS>gboolean  </RETURNS>
GtkNotebook     *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_popup_enable</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_popup_disable</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_label</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_label</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_label_text</NAME>
<RETURNS>void           </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, const gchar *tab_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_label_text</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_menu_label</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_menu_label</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, GtkWidget   *menu_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_menu_label_text</NAME>
<RETURNS>void           </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, const gchar *menu_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_menu_label_text</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_reorder_child</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, gint         position
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_reorderable</NAME>
<RETURNS>gboolean  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_reorderable</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, gboolean     reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_tab_detachable</NAME>
<RETURNS>gboolean  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_tab_detachable</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child, gboolean     detachable
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_detach_tab</NAME>
<RETURNS>void  </RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_action_widget</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkNotebook *notebook, GtkPackType  pack_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_set_action_widget</NAME>
<RETURNS>void        </RETURNS>
GtkNotebook *notebook, GtkWidget   *widget, GtkPackType  pack_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_page</NAME>
<RETURNS>GtkNotebookPage  *</RETURNS>
GtkNotebook *notebook, GtkWidget   *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_page_get_child</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkNotebookPage *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_notebook_get_pages</NAME>
<RETURNS>GListModel  *</RETURNS>
GtkNotebook *notebook
</FUNCTION>
<STRUCT>
<NAME>GtkNotebookPage</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkNotebookPageClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkNotebookPrivate</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_OVERLAY_CLASS</NAME>
#define GTK_OVERLAY_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_OVERLAY, GtkOverlayClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_OVERLAY</NAME>
#define GTK_IS_OVERLAY(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_OVERLAY))
</MACRO>
<MACRO>
<NAME>GTK_IS_OVERLAY_CLASS</NAME>
#define GTK_IS_OVERLAY_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_OVERLAY))
</MACRO>
<MACRO>
<NAME>GTK_OVERLAY_GET_CLASS</NAME>
#define GTK_OVERLAY_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_OVERLAY, GtkOverlayClass))
</MACRO>
<STRUCT>
<NAME>GtkOverlay</NAME>
struct _GtkOverlay
{
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkOverlayClass</NAME>
struct _GtkOverlayClass
{
  GtkBinClass parent_class;

  /*< public >*/

  gboolean (*get_child_position) (GtkOverlay    *overlay,
                                  GtkWidget     *widget,
                                  GtkAllocation *allocation);

  /*< 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);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<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_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>
<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;
  gint index;
  gint mode;
  gchar *label;
  gchar *action_name;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_pad_controller_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_pad_controller_new</NAME>
<RETURNS>GtkPadController  *</RETURNS>
GActionGroup     *group, GdkDevice        *pad
</FUNCTION>
<FUNCTION>
<NAME>gtk_pad_controller_set_action_entries</NAME>
<RETURNS>void   </RETURNS>
GtkPadController        *controller, const GtkPadActionEntry *entries, gint                     n_entries
</FUNCTION>
<FUNCTION>
<NAME>gtk_pad_controller_set_action</NAME>
<RETURNS>void   </RETURNS>
GtkPadController *controller, GtkPadActionType  type, gint              index, gint              mode, const gchar      *label, const gchar      *action_name
</FUNCTION>
<STRUCT>
<NAME>GtkPadController</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPadControllerClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PAGE_SETUP</NAME>
#define GTK_TYPE_PAGE_SETUP    (gtk_page_setup_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PAGE_SETUP</NAME>
#define GTK_PAGE_SETUP(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PAGE_SETUP, GtkPageSetup))
</MACRO>
<MACRO>
<NAME>GTK_IS_PAGE_SETUP</NAME>
#define GTK_IS_PAGE_SETUP(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PAGE_SETUP))
</MACRO>
<FUNCTION>
<NAME>gtk_page_setup_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new</NAME>
<RETURNS>GtkPageSetup  *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_copy</NAME>
<RETURNS>GtkPageSetup  *     </RETURNS>
GtkPageSetup       *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_orientation</NAME>
<RETURNS>GtkPageOrientation  </RETURNS>
GtkPageSetup       *setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_orientation</NAME>
<RETURNS>void                </RETURNS>
GtkPageSetup       *setup, GtkPageOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_paper_size</NAME>
<RETURNS>GtkPaperSize  *     </RETURNS>
GtkPageSetup       *setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_paper_size</NAME>
<RETURNS>void                </RETURNS>
GtkPageSetup       *setup, GtkPaperSize       *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_top_margin</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_top_margin</NAME>
<RETURNS>void                </RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_bottom_margin</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_bottom_margin</NAME>
<RETURNS>void                </RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_left_margin</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_left_margin</NAME>
<RETURNS>void                </RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_right_margin</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_right_margin</NAME>
<RETURNS>void                </RETURNS>
GtkPageSetup       *setup, gdouble             margin, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_set_paper_size_and_default_margins</NAME>
<RETURNS>void  </RETURNS>
GtkPageSetup    *setup, GtkPaperSize    *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_paper_width</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_paper_height</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_page_width</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_get_page_height</NAME>
<RETURNS>gdouble             </RETURNS>
GtkPageSetup       *setup, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new_from_file</NAME>
<RETURNS>GtkPageSetup 	  *</RETURNS>
const gchar         *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_load_file</NAME>
<RETURNS>gboolean 	   </RETURNS>
GtkPageSetup        *setup, const char          *file_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_to_file</NAME>
<RETURNS>gboolean 	   </RETURNS>
GtkPageSetup        *setup, const char          *file_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new_from_key_file</NAME>
<RETURNS>GtkPageSetup 	  *</RETURNS>
GKeyFile            *key_file, const gchar         *group_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_load_key_file</NAME>
<RETURNS>gboolean            </RETURNS>
GtkPageSetup        *setup, GKeyFile            *key_file, const gchar         *group_name, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_to_key_file</NAME>
<RETURNS>void 		   </RETURNS>
GtkPageSetup        *setup, GKeyFile            *key_file, const gchar         *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_to_gvariant</NAME>
<RETURNS>GVariant           *</RETURNS>
GtkPageSetup        *setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_new_from_gvariant</NAME>
<RETURNS>GtkPageSetup       *</RETURNS>
GVariant            *variant
</FUNCTION>
<STRUCT>
<NAME>GtkPageSetup</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PAGE_SETUP_UNIX_DIALOG</NAME>
#define GTK_TYPE_PAGE_SETUP_UNIX_DIALOG                  (gtk_page_setup_unix_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PAGE_SETUP_UNIX_DIALOG</NAME>
#define GTK_PAGE_SETUP_UNIX_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PAGE_SETUP_UNIX_DIALOG, GtkPageSetupUnixDialog))
</MACRO>
<MACRO>
<NAME>GTK_PAGE_SETUP_UNIX_DIALOG_CLASS</NAME>
#define GTK_PAGE_SETUP_UNIX_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PAGE_SETUP_UNIX_DIALOG, GtkPageSetupUnixDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_PAGE_SETUP_UNIX_DIALOG_CLASS</NAME>
#define GTK_IS_PAGE_SETUP_UNIX_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PAGE_SETUP_UNIX_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_PAGE_SETUP_UNIX_DIALOG_GET_CLASS</NAME>
#define GTK_PAGE_SETUP_UNIX_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PAGE_SETUP_UNIX_DIALOG, GtkPageSetupUnixDialogClass))
</MACRO>
<STRUCT>
<NAME>GtkPageSetupUnixDialog</NAME>
struct _GtkPageSetupUnixDialog
{
  GtkDialog parent_instance;

  GtkPageSetupUnixDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPageSetupUnixDialogClass</NAME>
struct _GtkPageSetupUnixDialogClass
{
  GtkDialogClass parent_class;

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_get_type</NAME>
<RETURNS>GType  		  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_new</NAME>
<RETURNS>GtkWidget  *       </RETURNS>
const gchar            *title, GtkWindow              *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_set_page_setup</NAME>
<RETURNS>void               </RETURNS>
GtkPageSetupUnixDialog *dialog, GtkPageSetup           *page_setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_get_page_setup</NAME>
<RETURNS>GtkPageSetup  *    </RETURNS>
GtkPageSetupUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_set_print_settings</NAME>
<RETURNS>void               </RETURNS>
GtkPageSetupUnixDialog *dialog, GtkPrintSettings       *print_settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_page_setup_unix_dialog_get_print_settings</NAME>
<RETURNS>GtkPrintSettings  *</RETURNS>
GtkPageSetupUnixDialog *dialog
</FUNCTION>
<STRUCT>
<NAME>GtkPageSetupUnixDialogPrivate</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_PANED_CLASS</NAME>
#define GTK_PANED_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PANED, GtkPanedClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PANED</NAME>
#define GTK_IS_PANED(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PANED))
</MACRO>
<MACRO>
<NAME>GTK_IS_PANED_CLASS</NAME>
#define GTK_IS_PANED_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PANED))
</MACRO>
<MACRO>
<NAME>GTK_PANED_GET_CLASS</NAME>
#define GTK_PANED_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PANED, GtkPanedClass))
</MACRO>
<STRUCT>
<NAME>GtkPaned</NAME>
struct _GtkPaned
{
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkPanedClass</NAME>
struct _GtkPanedClass
{
  GtkContainerClass parent_class;

  gboolean (* cycle_child_focus)   (GtkPaned      *paned,
				    gboolean       reverse);
  gboolean (* toggle_handle_focus) (GtkPaned      *paned);
  gboolean (* move_handle)         (GtkPaned      *paned,
				    GtkScrollType  scroll);
  gboolean (* cycle_handle_focus)  (GtkPaned      *paned,
				    gboolean       reverse);
  gboolean (* accept_position)     (GtkPaned	  *paned);
  gboolean (* cancel_position)     (GtkPaned	  *paned);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<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_add1</NAME>
<RETURNS>void         </RETURNS>
GtkPaned       *paned, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_add2</NAME>
<RETURNS>void         </RETURNS>
GtkPaned       *paned, GtkWidget      *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_pack1</NAME>
<RETURNS>void         </RETURNS>
GtkPaned       *paned, GtkWidget      *child, gboolean        resize, gboolean        shrink
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_pack2</NAME>
<RETURNS>void         </RETURNS>
GtkPaned       *paned, GtkWidget      *child, gboolean        resize, gboolean        shrink
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_position</NAME>
<RETURNS>gint         </RETURNS>
GtkPaned       *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_set_position</NAME>
<RETURNS>void         </RETURNS>
GtkPaned       *paned, gint            position
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_child1</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GtkPaned       *paned
</FUNCTION>
<FUNCTION>
<NAME>gtk_paned_get_child2</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GtkPaned       *paned
</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>
<MACRO>
<NAME>GTK_TYPE_PAPER_SIZE</NAME>
#define GTK_TYPE_PAPER_SIZE    (gtk_paper_size_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_A3</NAME>
#define GTK_PAPER_NAME_A3 "iso_a3"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_A4</NAME>
#define GTK_PAPER_NAME_A4 "iso_a4"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_A5</NAME>
#define GTK_PAPER_NAME_A5 "iso_a5"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_B5</NAME>
#define GTK_PAPER_NAME_B5 "iso_b5"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_LETTER</NAME>
#define GTK_PAPER_NAME_LETTER "na_letter"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_EXECUTIVE</NAME>
#define GTK_PAPER_NAME_EXECUTIVE "na_executive"
</MACRO>
<MACRO>
<NAME>GTK_PAPER_NAME_LEGAL</NAME>
#define GTK_PAPER_NAME_LEGAL "na_legal"
</MACRO>
<FUNCTION>
<NAME>gtk_paper_size_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new</NAME>
<RETURNS>GtkPaperSize  *</RETURNS>
const gchar  *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_ppd</NAME>
<RETURNS>GtkPaperSize  *</RETURNS>
const gchar  *ppd_name, const gchar  *ppd_display_name, gdouble       width, gdouble       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_ipp</NAME>
<RETURNS>GtkPaperSize  *</RETURNS>
const gchar  *ipp_name, gdouble       width, gdouble       height
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_custom</NAME>
<RETURNS>GtkPaperSize  *</RETURNS>
const gchar  *name, const gchar  *display_name, gdouble       width, gdouble       height, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_copy</NAME>
<RETURNS>GtkPaperSize  *</RETURNS>
GtkPaperSize *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_free</NAME>
<RETURNS>void           </RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_is_equal</NAME>
<RETURNS>gboolean       </RETURNS>
GtkPaperSize *size1, GtkPaperSize *size2
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_paper_sizes</NAME>
<RETURNS>GList         *</RETURNS>
gboolean include_custom
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_name</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_display_name</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_ppd_name</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_width</NAME>
<RETURNS>gdouble   </RETURNS>
GtkPaperSize *size, GtkUnit unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_height</NAME>
<RETURNS>gdouble   </RETURNS>
GtkPaperSize *size, GtkUnit unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_is_custom</NAME>
<RETURNS>gboolean  </RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_is_ipp</NAME>
<RETURNS>gboolean  </RETURNS>
GtkPaperSize *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_set_size</NAME>
<RETURNS>void     </RETURNS>
GtkPaperSize *size, gdouble       width, gdouble       height, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_top_margin</NAME>
<RETURNS>gdouble  </RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_bottom_margin</NAME>
<RETURNS>gdouble  </RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_left_margin</NAME>
<RETURNS>gdouble  </RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default_right_margin</NAME>
<RETURNS>gdouble  </RETURNS>
GtkPaperSize *size, GtkUnit       unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_get_default</NAME>
<RETURNS>const gchar  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_key_file</NAME>
<RETURNS>GtkPaperSize  *</RETURNS>
GKeyFile    *key_file, const gchar *group_name, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_to_key_file</NAME>
<RETURNS>void      </RETURNS>
GtkPaperSize *size, GKeyFile     *key_file, const gchar  *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_new_from_gvariant</NAME>
<RETURNS>GtkPaperSize  *</RETURNS>
GVariant     *variant
</FUNCTION>
<FUNCTION>
<NAME>gtk_paper_size_to_gvariant</NAME>
<RETURNS>GVariant      *</RETURNS>
GtkPaperSize *paper_size
</FUNCTION>
<STRUCT>
<NAME>GtkPaperSize</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PASSWORD_ENTRY</NAME>
#define GTK_TYPE_PASSWORD_ENTRY                 (gtk_password_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PASSWORD_ENTRY</NAME>
#define GTK_PASSWORD_ENTRY(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PASSWORD_ENTRY, GtkPasswordEntry))
</MACRO>
<MACRO>
<NAME>GTK_PASSWORD_ENTRY_CLASS</NAME>
#define GTK_PASSWORD_ENTRY_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PASSWORD_ENTRY, GtkPasswordEntryClass))
</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>
<MACRO>
<NAME>GTK_IS_PASSWORD_ENTRY_CLASS</NAME>
#define GTK_IS_PASSWORD_ENTRY_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PASSWORD_ENTRY))
</MACRO>
<MACRO>
<NAME>GTK_PASSWORD_ENTRY_GET_CLASS</NAME>
#define GTK_PASSWORD_ENTRY_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PASSWORD_ENTRY, GtkPasswordEntryClass))
</MACRO>
<STRUCT>
<NAME>GtkPasswordEntry</NAME>
struct _GtkPasswordEntry
{
  GtkWidget parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkPasswordEntryClass</NAME>
struct _GtkPasswordEntryClass
{
  GtkWidgetClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_password_entry_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_new</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_set_show_peek_icon</NAME>
<RETURNS>void             </RETURNS>
GtkPasswordEntry *entry, gboolean          show_peek_icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_password_entry_get_show_peek_icon</NAME>
<RETURNS>gboolean         </RETURNS>
GtkPasswordEntry *entry
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PATH_BAR</NAME>
#define GTK_TYPE_PATH_BAR                 (gtk_path_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PATH_BAR</NAME>
#define GTK_PATH_BAR(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PATH_BAR, GtkPathBar))
</MACRO>
<MACRO>
<NAME>GTK_PATH_BAR_CLASS</NAME>
#define GTK_PATH_BAR_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PATH_BAR, GtkPathBarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PATH_BAR</NAME>
#define GTK_IS_PATH_BAR(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PATH_BAR))
</MACRO>
<MACRO>
<NAME>GTK_IS_PATH_BAR_CLASS</NAME>
#define GTK_IS_PATH_BAR_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PATH_BAR))
</MACRO>
<MACRO>
<NAME>GTK_PATH_BAR_GET_CLASS</NAME>
#define GTK_PATH_BAR_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PATH_BAR, GtkPathBarClass))
</MACRO>
<STRUCT>
<NAME>GtkPathBar</NAME>
struct _GtkPathBar
{
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkPathBarClass</NAME>
struct _GtkPathBarClass
{
  GtkContainerClass parent_class;

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

  void (* closed) (GtkPopover *popover);

  /*< private >*/

  /* Padding for future expansion */
  gpointer reserved[10];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_popover_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_new</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
GtkWidget             *relative_to
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_new_from_model</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
GtkWidget             *relative_to, GMenuModel            *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_relative_to</NAME>
<RETURNS>void             </RETURNS>
GtkPopover            *popover, GtkWidget             *relative_to
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_relative_to</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_modal</NAME>
<RETURNS>void             </RETURNS>
GtkPopover            *popover, gboolean               modal
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_modal</NAME>
<RETURNS>gboolean         </RETURNS>
GtkPopover            *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_bind_model</NAME>
<RETURNS>void             </RETURNS>
GtkPopover            *popover, GMenuModel            *model, const gchar           *action_namespace
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_default_widget</NAME>
<RETURNS>void             </RETURNS>
GtkPopover *popover, GtkWidget  *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_default_widget</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
GtkPopover *popover
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_set_constrain_to</NAME>
<RETURNS>void                  </RETURNS>
GtkPopover           *popover, GtkPopoverConstraint  constraint
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_get_constrain_to</NAME>
<RETURNS>GtkPopoverConstraint  </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>
<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_POPOVER_MENU_CLASS</NAME>
#define GTK_POPOVER_MENU_CLASS(c)       (G_TYPE_CHECK_CLASS_CAST ((c), GTK_TYPE_POPOVER_MENU, GtkPopoverMenuClass))
</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>
<MACRO>
<NAME>GTK_IS_POPOVER_MENU_CLASS</NAME>
#define GTK_IS_POPOVER_MENU_CLASS(o)    (G_TYPE_CHECK_CLASS_TYPE ((o), GTK_TYPE_POPOVER_MENU))
</MACRO>
<MACRO>
<NAME>GTK_POPOVER_MENU_GET_CLASS</NAME>
#define GTK_POPOVER_MENU_GET_CLASS(o)   (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_POPOVER_MENU, GtkPopoverMenuClass))
</MACRO>
<STRUCT>
<NAME>GtkPopoverMenuClass</NAME>
struct _GtkPopoverMenuClass
{
  GtkPopoverClass parent_class;

  /*< private >*/

  /* Padding for future expansion */
  gpointer reserved[10];
};
</STRUCT>
<FUNCTION>
<NAME>gtk_popover_menu_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_new</NAME>
<RETURNS>GtkWidget  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_add_submenu</NAME>
<RETURNS>void         </RETURNS>
GtkPopoverMenu *popover, GtkWidget      *submenu, const char     *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_popover_menu_open_submenu</NAME>
<RETURNS>void         </RETURNS>
GtkPopoverMenu *popover, const char     *name
</FUNCTION>
<STRUCT>
<NAME>GtkPopoverMenu</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_PRINT_BACKEND_ERROR</NAME>
#define GTK_PRINT_BACKEND_ERROR (gtk_print_backend_error_quark ())
</MACRO>
<ENUM>
<NAME>GtkPrintBackendError</NAME>
typedef enum
{
  /* TODO: add specific errors */
  GTK_PRINT_BACKEND_ERROR_GENERIC
} GtkPrintBackendError;
</ENUM>
<FUNCTION>
<NAME>gtk_print_backend_error_quark</NAME>
<RETURNS>GQuark      </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINT_BACKEND</NAME>
#define GTK_TYPE_PRINT_BACKEND                  (gtk_print_backend_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_BACKEND</NAME>
#define GTK_PRINT_BACKEND(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_BACKEND, GtkPrintBackend))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_BACKEND_CLASS</NAME>
#define GTK_PRINT_BACKEND_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_BACKEND, GtkPrintBackendClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_BACKEND</NAME>
#define GTK_IS_PRINT_BACKEND(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_BACKEND))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_BACKEND_CLASS</NAME>
#define GTK_IS_PRINT_BACKEND_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_BACKEND))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_BACKEND_GET_CLASS</NAME>
#define GTK_PRINT_BACKEND_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_BACKEND, GtkPrintBackendClass))
</MACRO>
<ENUM>
<NAME>GtkPrintBackendStatus</NAME>
typedef enum 
{
  GTK_PRINT_BACKEND_STATUS_UNKNOWN,
  GTK_PRINT_BACKEND_STATUS_OK,
  GTK_PRINT_BACKEND_STATUS_UNAVAILABLE
} GtkPrintBackendStatus;
</ENUM>
<STRUCT>
<NAME>GtkPrintBackend</NAME>
struct _GtkPrintBackend
{
  GObject parent_instance;

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

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

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

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

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

  gboolean              (*printer_get_hard_margins_for_paper_size) (GtkPrinter    *printer,
								    GtkPaperSize  *paper_size,
								    gdouble       *top,
								    gdouble       *bottom,
								    gdouble       *left,
								    gdouble       *right);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
};
</STRUCT>
<MACRO>
<NAME>GTK_PRINT_BACKEND_EXTENSION_POINT_NAME</NAME>
#define GTK_PRINT_BACKEND_EXTENSION_POINT_NAME "gtk-print-backend"
</MACRO>
<FUNCTION>
<NAME>gtk_print_backend_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_get_printer_list</NAME>
<RETURNS>GList       *</RETURNS>
GtkPrintBackend         *print_backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_printer_list_is_done</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrintBackend         *print_backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_find_printer</NAME>
<RETURNS>GtkPrinter  *</RETURNS>
GtkPrintBackend         *print_backend, const gchar             *printer_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_print_stream</NAME>
<RETURNS>void         </RETURNS>
GtkPrintBackend         *print_backend, GtkPrintJob             *job, GIOChannel              *data_io, GtkPrintJobCompleteFunc  callback, gpointer                 user_data, GDestroyNotify           dnotify
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_load_modules</NAME>
<RETURNS>GList  *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_destroy</NAME>
<RETURNS>void         </RETURNS>
GtkPrintBackend         *print_backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_set_password</NAME>
<RETURNS>void         </RETURNS>
GtkPrintBackend         *backend, gchar                  **auth_info_required, gchar                  **auth_info, gboolean                 can_store_auth_info
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_add_printer</NAME>
<RETURNS>void         </RETURNS>
GtkPrintBackend         *print_backend, GtkPrinter              *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_remove_printer</NAME>
<RETURNS>void         </RETURNS>
GtkPrintBackend         *print_backend, GtkPrinter              *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backend_set_list_done</NAME>
<RETURNS>void         </RETURNS>
GtkPrintBackend         *backend
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_new</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_accepts_pdf</NAME>
<RETURNS>void         </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_accepts_ps</NAME>
<RETURNS>void         </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_new</NAME>
<RETURNS>void         </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_active</NAME>
<RETURNS>void         </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_paused</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_accepting_jobs</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_has_details</NAME>
<RETURNS>void         </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_is_default</NAME>
<RETURNS>void         </RETURNS>
GtkPrinter      *printer, gboolean         val
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_icon_name</NAME>
<RETURNS>void         </RETURNS>
GtkPrinter      *printer, const gchar     *icon
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_job_count</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrinter      *printer, gint             count
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_location</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrinter      *printer, const gchar     *location
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_description</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrinter      *printer, const gchar     *description
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_set_state_message</NAME>
<RETURNS>gboolean     </RETURNS>
GtkPrinter      *printer, const gchar     *message
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_backends_init</NAME>
<RETURNS>void         </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkPrintBackendPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_CONTEXT</NAME>
#define GTK_TYPE_PRINT_CONTEXT    (gtk_print_context_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_CONTEXT</NAME>
#define GTK_PRINT_CONTEXT(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_CONTEXT, GtkPrintContext))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_CONTEXT</NAME>
#define GTK_IS_PRINT_CONTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_CONTEXT))
</MACRO>
<FUNCTION>
<NAME>gtk_print_context_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_cairo_context</NAME>
<RETURNS>cairo_t       *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_page_setup</NAME>
<RETURNS>GtkPageSetup  *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_width</NAME>
<RETURNS>gdouble        </RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_height</NAME>
<RETURNS>gdouble        </RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_dpi_x</NAME>
<RETURNS>gdouble        </RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_dpi_y</NAME>
<RETURNS>gdouble        </RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_hard_margins</NAME>
<RETURNS>gboolean       </RETURNS>
GtkPrintContext *context, gdouble         *top, gdouble         *bottom, gdouble         *left, gdouble         *right
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_get_pango_fontmap</NAME>
<RETURNS>PangoFontMap  *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_create_pango_context</NAME>
<RETURNS>PangoContext  *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_create_pango_layout</NAME>
<RETURNS>PangoLayout   *</RETURNS>
GtkPrintContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_context_set_cairo_context</NAME>
<RETURNS>void          </RETURNS>
GtkPrintContext *context, cairo_t         *cr, double           dpi_x, double           dpi_y
</FUNCTION>
<STRUCT>
<NAME>GtkPrintContext</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_CAPABILITIES</NAME>
#define GTK_TYPE_PRINT_CAPABILITIES (gtk_print_capabilities_get_type ())
</MACRO>
<ENUM>
<NAME>GtkPrintCapabilities</NAME>
typedef enum
{
  GTK_PRINT_CAPABILITY_PAGE_SET         = 1 << 0,
  GTK_PRINT_CAPABILITY_COPIES           = 1 << 1,
  GTK_PRINT_CAPABILITY_COLLATE          = 1 << 2,
  GTK_PRINT_CAPABILITY_REVERSE          = 1 << 3,
  GTK_PRINT_CAPABILITY_SCALE            = 1 << 4,
  GTK_PRINT_CAPABILITY_GENERATE_PDF     = 1 << 5,
  GTK_PRINT_CAPABILITY_GENERATE_PS      = 1 << 6,
  GTK_PRINT_CAPABILITY_PREVIEW          = 1 << 7,
  GTK_PRINT_CAPABILITY_NUMBER_UP        = 1 << 8,
  GTK_PRINT_CAPABILITY_NUMBER_UP_LAYOUT = 1 << 9
} GtkPrintCapabilities;
</ENUM>
<FUNCTION>
<NAME>gtk_print_capabilities_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINTER</NAME>
#define GTK_TYPE_PRINTER                  (gtk_printer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINTER</NAME>
#define GTK_PRINTER(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINTER, GtkPrinter))
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_CLASS</NAME>
#define GTK_PRINTER_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINTER, GtkPrinterClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER</NAME>
#define GTK_IS_PRINTER(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINTER))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER_CLASS</NAME>
#define GTK_IS_PRINTER_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINTER))
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_GET_CLASS</NAME>
#define GTK_PRINTER_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINTER, GtkPrinterClass))
</MACRO>
<STRUCT>
<NAME>GtkPrinter</NAME>
struct _GtkPrinter
{
  GObject parent_instance;

  /*< private >*/
  GtkPrinterPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrinterClass</NAME>
struct _GtkPrinterClass
{
  GObjectClass parent_class;

  void (*details_acquired) (GtkPrinter *printer,
                            gboolean    success);

  /* 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_printer_get_type</NAME>
<RETURNS>GType                     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_new</NAME>
<RETURNS>GtkPrinter               *</RETURNS>
const gchar     *name, GtkPrintBackend *backend, gboolean         virtual_
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_backend</NAME>
<RETURNS>GtkPrintBackend          *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_name</NAME>
<RETURNS>const gchar  *            </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_state_message</NAME>
<RETURNS>const gchar  *            </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_description</NAME>
<RETURNS>const gchar  *            </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_location</NAME>
<RETURNS>const gchar  *            </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_icon_name</NAME>
<RETURNS>const gchar  *            </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_job_count</NAME>
<RETURNS>gint                      </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_active</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_paused</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_accepting_jobs</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_virtual</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_is_default</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_accepts_pdf</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_accepts_ps</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_list_papers</NAME>
<RETURNS>GList                    *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_default_page_size</NAME>
<RETURNS>GtkPageSetup             *</RETURNS>
GtkPrinter      *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_compare</NAME>
<RETURNS>gint                      </RETURNS>
GtkPrinter *a, GtkPrinter *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_has_details</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter       *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_request_details</NAME>
<RETURNS>void                      </RETURNS>
GtkPrinter       *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_capabilities</NAME>
<RETURNS>GtkPrintCapabilities      </RETURNS>
GtkPrinter       *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_hard_margins</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter       *printer, gdouble          *top, gdouble          *bottom, gdouble          *left, gdouble          *right
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_get_hard_margins_for_paper_size</NAME>
<RETURNS>gboolean                  </RETURNS>
GtkPrinter       *printer, GtkPaperSize     *paper_size, gdouble          *top, gdouble          *bottom, gdouble          *left, gdouble          *right
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkPrinterFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkPrinter *printer,
				    gpointer    data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_enumerate_printers</NAME>
<RETURNS>void                      </RETURNS>
GtkPrinterFunc   func, gpointer         data, GDestroyNotify   destroy, gboolean         wait
</FUNCTION>
<STRUCT>
<NAME>GtkPrintBackend</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPrinterPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINTER_OPTION</NAME>
#define GTK_TYPE_PRINTER_OPTION             (gtk_printer_option_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION</NAME>
#define GTK_PRINTER_OPTION(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINTER_OPTION, GtkPrinterOption))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINTER_OPTION</NAME>
#define GTK_IS_PRINTER_OPTION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINTER_OPTION))
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_GROUP_IMAGE_QUALITY</NAME>
#define GTK_PRINTER_OPTION_GROUP_IMAGE_QUALITY "ImageQuality"
</MACRO>
<MACRO>
<NAME>GTK_PRINTER_OPTION_GROUP_FINISHING</NAME>
#define GTK_PRINTER_OPTION_GROUP_FINISHING "Finishing"
</MACRO>
<ENUM>
<NAME>GtkPrinterOptionType</NAME>
typedef enum {
  GTK_PRINTER_OPTION_TYPE_BOOLEAN,
  GTK_PRINTER_OPTION_TYPE_PICKONE,
  GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD,
  GTK_PRINTER_OPTION_TYPE_PICKONE_PASSCODE,
  GTK_PRINTER_OPTION_TYPE_PICKONE_REAL,
  GTK_PRINTER_OPTION_TYPE_PICKONE_INT,
  GTK_PRINTER_OPTION_TYPE_PICKONE_STRING,
  GTK_PRINTER_OPTION_TYPE_ALTERNATIVE,
  GTK_PRINTER_OPTION_TYPE_STRING,
  GTK_PRINTER_OPTION_TYPE_FILESAVE,
  GTK_PRINTER_OPTION_TYPE_INFO
} GtkPrinterOptionType;
</ENUM>
<STRUCT>
<NAME>GtkPrinterOption</NAME>
struct _GtkPrinterOption
{
  GObject parent_instance;

  char *name;
  char *display_text;
  GtkPrinterOptionType type;

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

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

  void (*changed) (GtkPrinterOption *option);

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

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

  void (*changed) (GtkPrinterOptionSet *option);


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

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

  void (*changed) (GtkPrinterOptionWidget *widget);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_printer_option_widget_get_type</NAME>
<RETURNS>GType 	     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GtkPrinterOption       *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_set_source</NAME>
<RETURNS>void          </RETURNS>
GtkPrinterOptionWidget *setting, GtkPrinterOption       *source
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_has_external_label</NAME>
<RETURNS>gboolean      </RETURNS>
GtkPrinterOptionWidget *setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_get_external_label</NAME>
<RETURNS>GtkWidget    *</RETURNS>
GtkPrinterOptionWidget *setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_printer_option_widget_get_value</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkPrinterOptionWidget *setting
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PRINT_JOB</NAME>
#define GTK_TYPE_PRINT_JOB                  (gtk_print_job_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_JOB</NAME>
#define GTK_PRINT_JOB(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_JOB, GtkPrintJob))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_JOB_CLASS</NAME>
#define GTK_PRINT_JOB_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_JOB, GtkPrintJobClass))
</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>
<MACRO>
<NAME>GTK_IS_PRINT_JOB_CLASS</NAME>
#define GTK_IS_PRINT_JOB_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_JOB))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_JOB_GET_CLASS</NAME>
#define GTK_PRINT_JOB_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_JOB, GtkPrintJobClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkPrintJobCompleteFunc</NAME>
<RETURNS>void </RETURNS>
GtkPrintJob  *print_job,
                                         gpointer      user_data,
                                         const GError *error
</USER_FUNCTION>
<STRUCT>
<NAME>GtkPrintJob</NAME>
struct _GtkPrintJob
{
  GObject parent_instance;

  GtkPrintJobPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrintJobClass</NAME>
struct _GtkPrintJobClass
{
  GObjectClass parent_class;

  void (*status_changed) (GtkPrintJob *job);

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

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

  /*< public >*/

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

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

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

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

  /*< private >*/

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

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
  void (*_gtk_reserved5) (void);
  void (*_gtk_reserved6) (void);
  void (*_gtk_reserved7) (void);
  void (*_gtk_reserved8) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_print_operation_preview_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_preview_render_page</NAME>
<RETURNS>void      </RETURNS>
GtkPrintOperationPreview *preview, gint                      page_nr
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_preview_end_preview</NAME>
<RETURNS>void      </RETURNS>
GtkPrintOperationPreview *preview
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_operation_preview_is_selected</NAME>
<RETURNS>gboolean  </RETURNS>
GtkPrintOperationPreview *preview, gint                      page_nr
</FUNCTION>
<STRUCT>
<NAME>GtkPrintOperationPreview</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_SETTINGS</NAME>
#define GTK_TYPE_PRINT_SETTINGS    (gtk_print_settings_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS</NAME>
#define GTK_PRINT_SETTINGS(obj)    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_SETTINGS, GtkPrintSettings))
</MACRO>
<MACRO>
<NAME>GTK_IS_PRINT_SETTINGS</NAME>
#define GTK_IS_PRINT_SETTINGS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PRINT_SETTINGS))
</MACRO>
<USER_FUNCTION>
<NAME>GtkPrintSettingsFunc</NAME>
<RETURNS>void </RETURNS>
const gchar *key,
					const gchar *value,
					gpointer     user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkPageRange</NAME>
struct _GtkPageRange
{
  gint start;
  gint end;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_print_settings_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new</NAME>
<RETURNS>GtkPrintSettings  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_copy</NAME>
<RETURNS>GtkPrintSettings  *</RETURNS>
GtkPrintSettings     *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new_from_file</NAME>
<RETURNS>GtkPrintSettings  *</RETURNS>
const gchar          *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_load_file</NAME>
<RETURNS>gboolean           </RETURNS>
GtkPrintSettings     *settings, const gchar          *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_file</NAME>
<RETURNS>gboolean           </RETURNS>
GtkPrintSettings     *settings, const gchar          *file_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new_from_key_file</NAME>
<RETURNS>GtkPrintSettings  *</RETURNS>
GKeyFile             *key_file, const gchar          *group_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_load_key_file</NAME>
<RETURNS>gboolean           </RETURNS>
GtkPrintSettings     *settings, GKeyFile             *key_file, const gchar          *group_name, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_key_file</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, GKeyFile             *key_file, const gchar          *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_has_key</NAME>
<RETURNS>gboolean           </RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get</NAME>
<RETURNS>const gchar  *     </RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, const gchar          *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_unset</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_foreach</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, GtkPrintSettingsFunc  func, gpointer              user_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_bool</NAME>
<RETURNS>gboolean           </RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_bool</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gboolean              value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_double</NAME>
<RETURNS>gdouble            </RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_double_with_default</NAME>
<RETURNS>gdouble            </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gdouble               def
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_double</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gdouble               value
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_length</NAME>
<RETURNS>gdouble            </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, GtkUnit               unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_length</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gdouble               value, GtkUnit               unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_int</NAME>
<RETURNS>gint               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_int_with_default</NAME>
<RETURNS>gint               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gint                  def
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_int</NAME>
<RETURNS>void               </RETURNS>
GtkPrintSettings     *settings, const gchar          *key, gint                  value
</FUNCTION>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PRINTER</NAME>
#define GTK_PRINT_SETTINGS_PRINTER          "printer"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_ORIENTATION</NAME>
#define GTK_PRINT_SETTINGS_ORIENTATION      "orientation"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAPER_FORMAT</NAME>
#define GTK_PRINT_SETTINGS_PAPER_FORMAT     "paper-format"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAPER_WIDTH</NAME>
#define GTK_PRINT_SETTINGS_PAPER_WIDTH      "paper-width"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAPER_HEIGHT</NAME>
#define GTK_PRINT_SETTINGS_PAPER_HEIGHT     "paper-height"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_N_COPIES</NAME>
#define GTK_PRINT_SETTINGS_N_COPIES         "n-copies"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_DEFAULT_SOURCE</NAME>
#define GTK_PRINT_SETTINGS_DEFAULT_SOURCE   "default-source"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_QUALITY</NAME>
#define GTK_PRINT_SETTINGS_QUALITY          "quality"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_RESOLUTION</NAME>
#define GTK_PRINT_SETTINGS_RESOLUTION       "resolution"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_USE_COLOR</NAME>
#define GTK_PRINT_SETTINGS_USE_COLOR        "use-color"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_DUPLEX</NAME>
#define GTK_PRINT_SETTINGS_DUPLEX           "duplex"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_COLLATE</NAME>
#define GTK_PRINT_SETTINGS_COLLATE          "collate"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_REVERSE</NAME>
#define GTK_PRINT_SETTINGS_REVERSE          "reverse"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_MEDIA_TYPE</NAME>
#define GTK_PRINT_SETTINGS_MEDIA_TYPE       "media-type"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_DITHER</NAME>
#define GTK_PRINT_SETTINGS_DITHER           "dither"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_SCALE</NAME>
#define GTK_PRINT_SETTINGS_SCALE            "scale"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PRINT_PAGES</NAME>
#define GTK_PRINT_SETTINGS_PRINT_PAGES      "print-pages"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAGE_RANGES</NAME>
#define GTK_PRINT_SETTINGS_PAGE_RANGES      "page-ranges"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PAGE_SET</NAME>
#define GTK_PRINT_SETTINGS_PAGE_SET         "page-set"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_FINISHINGS</NAME>
#define GTK_PRINT_SETTINGS_FINISHINGS       "finishings"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_NUMBER_UP</NAME>
#define GTK_PRINT_SETTINGS_NUMBER_UP        "number-up"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT</NAME>
#define GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT "number-up-layout"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_BIN</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_BIN       "output-bin"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_RESOLUTION_X</NAME>
#define GTK_PRINT_SETTINGS_RESOLUTION_X     "resolution-x"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_RESOLUTION_Y</NAME>
#define GTK_PRINT_SETTINGS_RESOLUTION_Y     "resolution-y"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_PRINTER_LPI</NAME>
#define GTK_PRINT_SETTINGS_PRINTER_LPI      "printer-lpi"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_DIR</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_DIR       "output-dir"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_BASENAME</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_BASENAME  "output-basename"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_FILE_FORMAT  "output-file-format"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_OUTPUT_URI</NAME>
#define GTK_PRINT_SETTINGS_OUTPUT_URI          "output-uri"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION</NAME>
#define GTK_PRINT_SETTINGS_WIN32_DRIVER_VERSION "win32-driver-version"
</MACRO>
<MACRO>
<NAME>GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA</NAME>
#define GTK_PRINT_SETTINGS_WIN32_DRIVER_EXTRA   "win32-driver-extra"
</MACRO>
<FUNCTION>
<NAME>gtk_print_settings_get_printer</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_printer</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, const gchar        *printer
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_orientation</NAME>
<RETURNS>GtkPageOrientation     </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_orientation</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkPageOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_paper_size</NAME>
<RETURNS>GtkPaperSize  *        </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_size</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkPaperSize       *paper_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_paper_width</NAME>
<RETURNS>gdouble                </RETURNS>
GtkPrintSettings   *settings, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_width</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gdouble             width, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_paper_height</NAME>
<RETURNS>gdouble                </RETURNS>
GtkPrintSettings   *settings, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_paper_height</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gdouble             height, GtkUnit             unit
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_use_color</NAME>
<RETURNS>gboolean               </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_use_color</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gboolean            use_color
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_collate</NAME>
<RETURNS>gboolean               </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_collate</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gboolean            collate
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_reverse</NAME>
<RETURNS>gboolean               </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_reverse</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gboolean            reverse
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_duplex</NAME>
<RETURNS>GtkPrintDuplex         </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_duplex</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkPrintDuplex      duplex
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_quality</NAME>
<RETURNS>GtkPrintQuality        </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_quality</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkPrintQuality     quality
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_n_copies</NAME>
<RETURNS>gint                   </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_n_copies</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gint                num_copies
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_number_up</NAME>
<RETURNS>gint                   </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_number_up</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gint                number_up
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_number_up_layout</NAME>
<RETURNS>GtkNumberUpLayout      </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_number_up_layout</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkNumberUpLayout   number_up_layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution</NAME>
<RETURNS>gint                   </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_resolution</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gint                resolution
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution_x</NAME>
<RETURNS>gint                   </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_resolution_y</NAME>
<RETURNS>gint                   </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_resolution_xy</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gint                resolution_x, gint                resolution_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_printer_lpi</NAME>
<RETURNS>gdouble                </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_printer_lpi</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gdouble             lpi
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_scale</NAME>
<RETURNS>gdouble                </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_scale</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, gdouble             scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_print_pages</NAME>
<RETURNS>GtkPrintPages          </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_print_pages</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkPrintPages       pages
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_page_ranges</NAME>
<RETURNS>GtkPageRange  *        </RETURNS>
GtkPrintSettings   *settings, gint               *num_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_page_ranges</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkPageRange       *page_ranges, gint                num_ranges
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_page_set</NAME>
<RETURNS>GtkPageSet             </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_page_set</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, GtkPageSet          page_set
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_default_source</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_default_source</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, const gchar        *default_source
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_media_type</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_media_type</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, const gchar        *media_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_dither</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_dither</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, const gchar        *dither
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_finishings</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_finishings</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, const gchar        *finishings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_get_output_bin</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_set_output_bin</NAME>
<RETURNS>void                   </RETURNS>
GtkPrintSettings   *settings, const gchar        *output_bin
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_to_gvariant</NAME>
<RETURNS>GVariant              *</RETURNS>
GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_settings_new_from_gvariant</NAME>
<RETURNS>GtkPrintSettings      *</RETURNS>
GVariant           *variant
</FUNCTION>
<STRUCT>
<NAME>GtkPrintSettings</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_PRINT_UNIX_DIALOG</NAME>
#define GTK_TYPE_PRINT_UNIX_DIALOG                  (gtk_print_unix_dialog_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PRINT_UNIX_DIALOG</NAME>
#define GTK_PRINT_UNIX_DIALOG(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PRINT_UNIX_DIALOG, GtkPrintUnixDialog))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_UNIX_DIALOG_CLASS</NAME>
#define GTK_PRINT_UNIX_DIALOG_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PRINT_UNIX_DIALOG, GtkPrintUnixDialogClass))
</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>
<MACRO>
<NAME>GTK_IS_PRINT_UNIX_DIALOG_CLASS</NAME>
#define GTK_IS_PRINT_UNIX_DIALOG_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PRINT_UNIX_DIALOG))
</MACRO>
<MACRO>
<NAME>GTK_PRINT_UNIX_DIALOG_GET_CLASS</NAME>
#define GTK_PRINT_UNIX_DIALOG_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PRINT_UNIX_DIALOG, GtkPrintUnixDialogClass))
</MACRO>
<TYPEDEF>
<NAME>GtkPrintUnixDialogPrivate</NAME>
typedef struct GtkPrintUnixDialogPrivate   GtkPrintUnixDialogPrivate;
</TYPEDEF>
<STRUCT>
<NAME>GtkPrintUnixDialog</NAME>
struct _GtkPrintUnixDialog
{
  GtkDialog parent_instance;

  /*< private >*/
  GtkPrintUnixDialogPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkPrintUnixDialogClass</NAME>
struct _GtkPrintUnixDialogClass
{
  GtkDialogClass 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_print_unix_dialog_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_new</NAME>
<RETURNS>GtkWidget  *          </RETURNS>
const gchar *title, GtkWindow   *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_page_setup</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog *dialog, GtkPageSetup       *page_setup
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_page_setup</NAME>
<RETURNS>GtkPageSetup  *       </RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_current_page</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog *dialog, gint                current_page
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_current_page</NAME>
<RETURNS>gint                  </RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_settings</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog *dialog, GtkPrintSettings   *settings
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_settings</NAME>
<RETURNS>GtkPrintSettings  *   </RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_selected_printer</NAME>
<RETURNS>GtkPrinter  *         </RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_add_custom_tab</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog *dialog, GtkWidget          *child, GtkWidget          *tab_label
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_manual_capabilities</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog *dialog, GtkPrintCapabilities capabilities
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_manual_capabilities</NAME>
<RETURNS>GtkPrintCapabilities  </RETURNS>
GtkPrintUnixDialog  *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_support_selection</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog  *dialog, gboolean             support_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_support_selection</NAME>
<RETURNS>gboolean              </RETURNS>
GtkPrintUnixDialog  *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_has_selection</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog  *dialog, gboolean             has_selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_has_selection</NAME>
<RETURNS>gboolean              </RETURNS>
GtkPrintUnixDialog  *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_set_embed_page_setup</NAME>
<RETURNS>void                  </RETURNS>
GtkPrintUnixDialog *dialog, gboolean            embed
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_embed_page_setup</NAME>
<RETURNS>gboolean              </RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<FUNCTION>
<NAME>gtk_print_unix_dialog_get_page_setup_set</NAME>
<RETURNS>gboolean              </RETURNS>
GtkPrintUnixDialog *dialog
</FUNCTION>
<MACRO>
<NAME>MM_PER_INCH</NAME>
#define MM_PER_INCH 25.4
</MACRO>
<MACRO>
<NAME>POINTS_PER_INCH</NAME>
#define POINTS_PER_INCH 72
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PROGRESS_BAR</NAME>
#define GTK_TYPE_PROGRESS_BAR            (gtk_progress_bar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PROGRESS_BAR</NAME>
#define GTK_PROGRESS_BAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PROGRESS_BAR, GtkProgressBar))
</MACRO>
<MACRO>
<NAME>GTK_PROGRESS_BAR_CLASS</NAME>
#define GTK_PROGRESS_BAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS_BAR, GtkProgressBarClass))
</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>
<MACRO>
<NAME>GTK_IS_PROGRESS_BAR_CLASS</NAME>
#define GTK_IS_PROGRESS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PROGRESS_BAR))
</MACRO>
<MACRO>
<NAME>GTK_PROGRESS_BAR_GET_CLASS</NAME>
#define GTK_PROGRESS_BAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PROGRESS_BAR, GtkProgressBarClass))
</MACRO>
<STRUCT>
<NAME>GtkProgressBar</NAME>
struct _GtkProgressBar
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkProgressBarClass</NAME>
struct _GtkProgressBarClass
{
  GtkWidgetClass 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_progress_bar_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_pulse</NAME>
<RETURNS>void        </RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_text</NAME>
<RETURNS>void        </RETURNS>
GtkProgressBar *pbar, const gchar    *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_fraction</NAME>
<RETURNS>void        </RETURNS>
GtkProgressBar *pbar, gdouble         fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_pulse_step</NAME>
<RETURNS>void        </RETURNS>
GtkProgressBar *pbar, gdouble         fraction
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_inverted</NAME>
<RETURNS>void        </RETURNS>
GtkProgressBar *pbar, gboolean        inverted
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_text</NAME>
<RETURNS>const gchar  *      </RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_fraction</NAME>
<RETURNS>gdouble             </RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_pulse_step</NAME>
<RETURNS>gdouble             </RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_inverted</NAME>
<RETURNS>gboolean            </RETURNS>
GtkProgressBar *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_ellipsize</NAME>
<RETURNS>void                </RETURNS>
GtkProgressBar     *pbar, PangoEllipsizeMode  mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_ellipsize</NAME>
<RETURNS>PangoEllipsizeMode  </RETURNS>
GtkProgressBar     *pbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_set_show_text</NAME>
<RETURNS>void                </RETURNS>
GtkProgressBar     *pbar, gboolean            show_text
</FUNCTION>
<FUNCTION>
<NAME>gtk_progress_bar_get_show_text</NAME>
<RETURNS>gboolean            </RETURNS>
GtkProgressBar     *pbar
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL</NAME>
#define GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL         (gtk_property_lookup_list_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_PROPERTY_LOOKUP_LIST_MODEL</NAME>
#define GTK_PROPERTY_LOOKUP_LIST_MODEL(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL, GtkPropertyLookupListModel))
</MACRO>
<MACRO>
<NAME>GTK_PROPERTY_LOOKUP_LIST_MODEL_CLASS</NAME>
#define GTK_PROPERTY_LOOKUP_LIST_MODEL_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST ((k), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL, GtkPropertyLookupListModelClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_PROPERTY_LOOKUP_LIST_MODEL</NAME>
#define GTK_IS_PROPERTY_LOOKUP_LIST_MODEL(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_IS_PROPERTY_LOOKUP_LIST_MODEL_CLASS</NAME>
#define GTK_IS_PROPERTY_LOOKUP_LIST_MODEL_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_PROPERTY_LOOKUP_LIST_MODEL_GET_CLASS</NAME>
#define GTK_PROPERTY_LOOKUP_LIST_MODEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), GTK_TYPE_PROPERTY_LOOKUP_LIST_MODEL, GtkPropertyLookupListModelClass))
</MACRO>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_get_type</NAME>
<RETURNS>GType                            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_new</NAME>
<RETURNS>GtkPropertyLookupListModel  *    </RETURNS>
GType                           item_type, const char                     *property_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_set_object</NAME>
<RETURNS>void                             </RETURNS>
GtkPropertyLookupListModel     *self, gpointer                        object
</FUNCTION>
<FUNCTION>
<NAME>gtk_property_lookup_list_model_get_object</NAME>
<RETURNS>gpointer                         </RETURNS>
GtkPropertyLookupListModel     *self
</FUNCTION>
<STRUCT>
<NAME>GtkPropertyLookupListModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkPropertyLookupListModelClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_QUERY</NAME>
#define GTK_TYPE_QUERY          (gtk_query_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_QUERY</NAME>
#define GTK_QUERY(obj)          (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_QUERY, GtkQuery))
</MACRO>
<MACRO>
<NAME>GTK_QUERY_CLASS</NAME>
#define GTK_QUERY_CLASS(klass)  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_QUERY, GtkQueryClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_QUERY</NAME>
#define GTK_IS_QUERY(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_QUERY))
</MACRO>
<MACRO>
<NAME>GTK_IS_QUERY_CLASS</NAME>
#define GTK_IS_QUERY_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_QUERY))
</MACRO>
<MACRO>
<NAME>GTK_QUERY_GET_CLASS</NAME>
#define GTK_QUERY_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_QUERY, GtkQueryClass))
</MACRO>
<STRUCT>
<NAME>GtkQuery</NAME>
struct _GtkQuery
{
  GObject parent;

  GtkQueryPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkQueryClass</NAME>
struct _GtkQueryClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_query_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_new</NAME>
<RETURNS>GtkQuery     *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_get_text</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkQuery    *query
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_set_text</NAME>
<RETURNS>void          </RETURNS>
GtkQuery    *query, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_get_location</NAME>
<RETURNS>GFile        *</RETURNS>
GtkQuery    *query
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_set_location</NAME>
<RETURNS>void          </RETURNS>
GtkQuery    *query, GFile       *file
</FUNCTION>
<FUNCTION>
<NAME>gtk_query_matches_string</NAME>
<RETURNS>gboolean      </RETURNS>
GtkQuery    *query, const gchar *string
</FUNCTION>
<STRUCT>
<NAME>GtkQueryPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RADIO_BUTTON</NAME>
#define GTK_TYPE_RADIO_BUTTON		       (gtk_radio_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RADIO_BUTTON</NAME>
#define GTK_RADIO_BUTTON(obj)		       (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_BUTTON, GtkRadioButton))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_BUTTON_CLASS</NAME>
#define GTK_RADIO_BUTTON_CLASS(klass)	       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_BUTTON, GtkRadioButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_BUTTON</NAME>
#define GTK_IS_RADIO_BUTTON(obj)	       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_BUTTON_CLASS</NAME>
#define GTK_IS_RADIO_BUTTON_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_BUTTON_GET_CLASS</NAME>
#define GTK_RADIO_BUTTON_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_BUTTON, GtkRadioButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkRadioButton</NAME>
struct _GtkRadioButton
{
  GtkCheckButton parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkRadioButtonClass</NAME>
struct _GtkRadioButtonClass
{
  GtkCheckButtonClass parent_class;

  /* Signals */
  void (*group_changed) (GtkRadioButton *radio_button);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_radio_button_get_type</NAME>
<RETURNS>GType 	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
GSList         *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_from_widget</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkRadioButton *radio_group_member
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_label</NAME>
<RETURNS>GtkWidget * </RETURNS>
GSList         *group, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_label_from_widget</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkRadioButton *radio_group_member, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget * </RETURNS>
GSList         *group, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_new_with_mnemonic_from_widget</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkRadioButton *radio_group_member, const gchar    *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_get_group</NAME>
<RETURNS>GSList *    </RETURNS>
GtkRadioButton *radio_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_set_group</NAME>
<RETURNS>void        </RETURNS>
GtkRadioButton *radio_button, GSList         *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_button_join_group</NAME>
<RETURNS>void             </RETURNS>
GtkRadioButton        *radio_button, GtkRadioButton        *group_source
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_RADIO_MENU_ITEM</NAME>
#define GTK_TYPE_RADIO_MENU_ITEM	      (gtk_radio_menu_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RADIO_MENU_ITEM</NAME>
#define GTK_RADIO_MENU_ITEM(obj)	      (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_MENU_ITEM, GtkRadioMenuItem))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_MENU_ITEM_CLASS</NAME>
#define GTK_RADIO_MENU_ITEM_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_MENU_ITEM, GtkRadioMenuItemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_MENU_ITEM</NAME>
#define GTK_IS_RADIO_MENU_ITEM(obj)	      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_MENU_ITEM_CLASS</NAME>
#define GTK_IS_RADIO_MENU_ITEM_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_MENU_ITEM_GET_CLASS</NAME>
#define GTK_RADIO_MENU_ITEM_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_MENU_ITEM, GtkRadioMenuItemClass))
</MACRO>
<STRUCT>
<NAME>GtkRadioMenuItem</NAME>
struct _GtkRadioMenuItem
{
  GtkCheckMenuItem check_menu_item;

  /*< private >*/
  GtkRadioMenuItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkRadioMenuItemClass</NAME>
struct _GtkRadioMenuItemClass
{
  GtkCheckMenuItemClass parent_class;

  /* Signals */
  void (*group_changed) (GtkRadioMenuItem *radio_menu_item);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_radio_menu_item_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
GSList           *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_new_with_label</NAME>
<RETURNS>GtkWidget * </RETURNS>
GSList           *group, const gchar      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_new_with_mnemonic</NAME>
<RETURNS>GtkWidget * </RETURNS>
GSList           *group, const gchar      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_new_from_widget</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkRadioMenuItem *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_new_with_mnemonic_from_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkRadioMenuItem *group, const gchar      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_new_with_label_from_widget</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkRadioMenuItem *group, const gchar      *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_get_group</NAME>
<RETURNS>GSList *    </RETURNS>
GtkRadioMenuItem *radio_menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_set_group</NAME>
<RETURNS>void        </RETURNS>
GtkRadioMenuItem *radio_menu_item, GSList           *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_menu_item_join_group</NAME>
<RETURNS>void        </RETURNS>
GtkRadioMenuItem *radio_menu_item, GtkRadioMenuItem *group_source
</FUNCTION>
<STRUCT>
<NAME>GtkRadioMenuItemPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RADIO_TOOL_BUTTON</NAME>
#define GTK_TYPE_RADIO_TOOL_BUTTON            (gtk_radio_tool_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RADIO_TOOL_BUTTON</NAME>
#define GTK_RADIO_TOOL_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_TOOL_BUTTON, GtkRadioToolButton))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_TOOL_BUTTON_CLASS</NAME>
#define GTK_RADIO_TOOL_BUTTON_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_TOOL_BUTTON, GtkRadioToolButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_TOOL_BUTTON</NAME>
#define GTK_IS_RADIO_TOOL_BUTTON(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_TOOL_BUTTON_CLASS</NAME>
#define GTK_IS_RADIO_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_TOOL_BUTTON_GET_CLASS</NAME>
#define GTK_RADIO_TOOL_BUTTON_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_RADIO_TOOL_BUTTON, GtkRadioToolButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkRadioToolButton</NAME>
struct _GtkRadioToolButton
{
  GtkToggleToolButton parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkRadioToolButtonClass</NAME>
struct _GtkRadioToolButtonClass
{
  GtkToggleToolButtonClass 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_radio_tool_button_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_tool_button_new</NAME>
<RETURNS>GtkToolItem  *</RETURNS>
GSList             *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_tool_button_new_from_widget</NAME>
<RETURNS>GtkToolItem  *</RETURNS>
GtkRadioToolButton *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_tool_button_get_group</NAME>
<RETURNS>GSList  *     </RETURNS>
GtkRadioToolButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_radio_tool_button_set_group</NAME>
<RETURNS>void          </RETURNS>
GtkRadioToolButton *button, GSList             *group
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_RANGE</NAME>
#define GTK_TYPE_RANGE            (gtk_range_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RANGE</NAME>
#define GTK_RANGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RANGE, GtkRange))
</MACRO>
<MACRO>
<NAME>GTK_RANGE_CLASS</NAME>
#define GTK_RANGE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RANGE, GtkRangeClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RANGE</NAME>
#define GTK_IS_RANGE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RANGE))
</MACRO>
<MACRO>
<NAME>GTK_IS_RANGE_CLASS</NAME>
#define GTK_IS_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RANGE))
</MACRO>
<MACRO>
<NAME>GTK_RANGE_GET_CLASS</NAME>
#define GTK_RANGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RANGE, GtkRangeClass))
</MACRO>
<STRUCT>
<NAME>GtkRange</NAME>
struct _GtkRange
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkRangeClass</NAME>
struct _GtkRangeClass
{
  GtkWidgetClass parent_class;

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

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

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

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

   void (* get_range_size_request) (GtkRange       *range,
                                    GtkOrientation  orientation,
                                    gint           *minimum,
                                    gint           *natural);

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

  gchar *mime_type;

  gchar *app_name;
  gchar *app_exec;

  gchar **groups;

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

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

  void (*changed) (GtkRecentManager *manager);

  /* padding for future expansion */
  void (*_gtk_recent1) (void);
  void (*_gtk_recent2) (void);
  void (*_gtk_recent3) (void);
  void (*_gtk_recent4) (void);
};
</STRUCT>
<ENUM>
<NAME>GtkRecentManagerError</NAME>
typedef enum
{
  GTK_RECENT_MANAGER_ERROR_NOT_FOUND,
  GTK_RECENT_MANAGER_ERROR_INVALID_URI,
  GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING,
  GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED,
  GTK_RECENT_MANAGER_ERROR_READ,
  GTK_RECENT_MANAGER_ERROR_WRITE,
  GTK_RECENT_MANAGER_ERROR_UNKNOWN
} GtkRecentManagerError;
</ENUM>
<MACRO>
<NAME>GTK_RECENT_MANAGER_ERROR</NAME>
#define GTK_RECENT_MANAGER_ERROR	(gtk_recent_manager_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gtk_recent_manager_error_quark</NAME>
<RETURNS>GQuark  	</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_get_type</NAME>
<RETURNS>GType  		  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_new</NAME>
<RETURNS>GtkRecentManager  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_get_default</NAME>
<RETURNS>GtkRecentManager  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_add_item</NAME>
<RETURNS>gboolean           </RETURNS>
GtkRecentManager     *manager, const gchar          *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_add_full</NAME>
<RETURNS>gboolean           </RETURNS>
GtkRecentManager     *manager, const gchar          *uri, const GtkRecentData  *recent_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_remove_item</NAME>
<RETURNS>gboolean           </RETURNS>
GtkRecentManager     *manager, const gchar          *uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_lookup_item</NAME>
<RETURNS>GtkRecentInfo  *   </RETURNS>
GtkRecentManager     *manager, const gchar          *uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_has_item</NAME>
<RETURNS>gboolean           </RETURNS>
GtkRecentManager     *manager, const gchar          *uri
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_move_item</NAME>
<RETURNS>gboolean           </RETURNS>
GtkRecentManager     *manager, const gchar          *uri, const gchar          *new_uri, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_get_items</NAME>
<RETURNS>GList  *           </RETURNS>
GtkRecentManager     *manager
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_manager_purge_items</NAME>
<RETURNS>gint               </RETURNS>
GtkRecentManager     *manager, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_type</NAME>
<RETURNS>GType 	              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_ref</NAME>
<RETURNS>GtkRecentInfo  *       </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_unref</NAME>
<RETURNS>void                   </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_uri</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_display_name</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_description</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_mime_type</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_added</NAME>
<RETURNS>time_t                 </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_modified</NAME>
<RETURNS>time_t                 </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_visited</NAME>
<RETURNS>time_t                 </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_private_hint</NAME>
<RETURNS>gboolean               </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_application_info</NAME>
<RETURNS>gboolean               </RETURNS>
GtkRecentInfo  *info, const gchar    *app_name, const gchar   **app_exec, guint          *count, time_t         *time_
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_create_app_info</NAME>
<RETURNS>GAppInfo  *            </RETURNS>
GtkRecentInfo  *info, const gchar    *app_name, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_applications</NAME>
<RETURNS>gchar  **              </RETURNS>
GtkRecentInfo  *info, gsize          *length
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_last_application</NAME>
<RETURNS>gchar  *               </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_has_application</NAME>
<RETURNS>gboolean               </RETURNS>
GtkRecentInfo  *info, const gchar    *app_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_groups</NAME>
<RETURNS>gchar  **              </RETURNS>
GtkRecentInfo  *info, gsize          *length
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_has_group</NAME>
<RETURNS>gboolean               </RETURNS>
GtkRecentInfo  *info, const gchar    *group_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_gicon</NAME>
<RETURNS>GIcon  *               </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_short_name</NAME>
<RETURNS>gchar  *               </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_uri_display</NAME>
<RETURNS>gchar  *               </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_get_age</NAME>
<RETURNS>gint                   </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_is_local</NAME>
<RETURNS>gboolean               </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_exists</NAME>
<RETURNS>gboolean               </RETURNS>
GtkRecentInfo  *info
</FUNCTION>
<FUNCTION>
<NAME>gtk_recent_info_match</NAME>
<RETURNS>gboolean               </RETURNS>
GtkRecentInfo  *info_a, GtkRecentInfo  *info_b
</FUNCTION>
<STRUCT>
<NAME>GtkRecentInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRecentManagerPrivate</NAME>
</STRUCT>
<FUNCTION>
<NAME>gtk_render_check</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_option</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_arrow</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              angle, gdouble              x, gdouble              y, gdouble              size
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_background</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_background_get_clip</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, gdouble              x, gdouble              y, gdouble              width, gdouble              height, GdkRectangle        *out_clip
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_frame</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_expander</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_focus</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_layout</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, PangoLayout         *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_line</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x0, gdouble              y0, gdouble              x1, gdouble              y1
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_slider</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height, GtkOrientation       orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_handle</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_activity</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, gdouble              width, gdouble              height
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_icon</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, GdkTexture          *texture, gdouble              x, gdouble              y
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_REVEALER</NAME>
#define GTK_TYPE_REVEALER (gtk_revealer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_REVEALER</NAME>
#define GTK_REVEALER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_REVEALER, GtkRevealer))
</MACRO>
<MACRO>
<NAME>GTK_REVEALER_CLASS</NAME>
#define GTK_REVEALER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_REVEALER, GtkRevealerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_REVEALER</NAME>
#define GTK_IS_REVEALER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_REVEALER))
</MACRO>
<MACRO>
<NAME>GTK_IS_REVEALER_CLASS</NAME>
#define GTK_IS_REVEALER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_REVEALER))
</MACRO>
<MACRO>
<NAME>GTK_REVEALER_GET_CLASS</NAME>
#define GTK_REVEALER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_REVEALER, GtkRevealerClass))
</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>
<STRUCT>
<NAME>GtkRevealer</NAME>
struct _GtkRevealer {
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkRevealerClass</NAME>
struct _GtkRevealerClass {
  GtkBinClass parent_class;
};
</STRUCT>
<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>
<MACRO>
<NAME>GTK_TYPE_ROOT</NAME>
#define GTK_TYPE_ROOT               (gtk_root_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkRootInterface</NAME>
struct _GtkRootInterface
{
  /*< private >*/
  GTypeInterface g_iface;

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

  void                  (* get_surface_transform)       (GtkRoot                *root,
                                                         int                    *x,
                                                         int                    *y);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_root_get_for_surface</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GdkSurface *surface
</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>
<FUNCTION>
<NAME>gtk_root_get_display</NAME>
<RETURNS>GdkDisplay  *            </RETURNS>
GtkRoot                *root
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_get_renderer</NAME>
<RETURNS>GskRenderer  *           </RETURNS>
GtkRoot                *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_get_surface_transform</NAME>
<RETURNS>void                     </RETURNS>
GtkRoot                *self, int                    *x, int                    *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_root_install_properties</NAME>
<RETURNS>guint  </RETURNS>
GObjectClass *object_class, guint         first_prop
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SCALE</NAME>
#define GTK_TYPE_SCALE            (gtk_scale_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCALE</NAME>
#define GTK_SCALE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE, GtkScale))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_CLASS</NAME>
#define GTK_SCALE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE, GtkScaleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE</NAME>
#define GTK_IS_SCALE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_CLASS</NAME>
#define GTK_IS_SCALE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_GET_CLASS</NAME>
#define GTK_SCALE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE, GtkScaleClass))
</MACRO>
<STRUCT>
<NAME>GtkScale</NAME>
struct _GtkScale
{
  GtkRange parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleClass</NAME>
struct _GtkScaleClass
{
  GtkRangeClass parent_class;

  gchar* (* format_value) (GtkScale *scale,
                           gdouble   value);

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scale_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_new</NAME>
<RETURNS>GtkWidget        * </RETURNS>
GtkOrientation   orientation, GtkAdjustment   *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_new_with_range</NAME>
<RETURNS>GtkWidget        * </RETURNS>
GtkOrientation   orientation, gdouble          min, gdouble          max, gdouble          step
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_digits</NAME>
<RETURNS>void               </RETURNS>
GtkScale        *scale, gint             digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_digits</NAME>
<RETURNS>gint               </RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_draw_value</NAME>
<RETURNS>void               </RETURNS>
GtkScale        *scale, gboolean         draw_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_draw_value</NAME>
<RETURNS>gboolean           </RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_has_origin</NAME>
<RETURNS>void               </RETURNS>
GtkScale        *scale, gboolean         has_origin
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_has_origin</NAME>
<RETURNS>gboolean           </RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_set_value_pos</NAME>
<RETURNS>void               </RETURNS>
GtkScale        *scale, GtkPositionType  pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_value_pos</NAME>
<RETURNS>GtkPositionType    </RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_layout</NAME>
<RETURNS>PangoLayout      * </RETURNS>
GtkScale        *scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_get_layout_offsets</NAME>
<RETURNS>void               </RETURNS>
GtkScale        *scale, gint            *x, gint            *y
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_add_mark</NAME>
<RETURNS>void               </RETURNS>
GtkScale        *scale, gdouble          value, GtkPositionType  position, const gchar     *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_scale_clear_marks</NAME>
<RETURNS>void               </RETURNS>
GtkScale        *scale
</FUNCTION>
<STRUCT>
<NAME>GtkScalePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCALE_BUTTON</NAME>
#define GTK_TYPE_SCALE_BUTTON                 (gtk_scale_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON</NAME>
#define GTK_SCALE_BUTTON(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCALE_BUTTON, GtkScaleButton))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON_CLASS</NAME>
#define GTK_SCALE_BUTTON_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCALE_BUTTON, GtkScaleButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_BUTTON</NAME>
#define GTK_IS_SCALE_BUTTON(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCALE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCALE_BUTTON_CLASS</NAME>
#define GTK_IS_SCALE_BUTTON_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCALE_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_SCALE_BUTTON_GET_CLASS</NAME>
#define GTK_SCALE_BUTTON_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCALE_BUTTON, GtkScaleButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkScaleButton</NAME>
struct _GtkScaleButton
{
  GtkButton parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleButtonClass</NAME>
struct _GtkScaleButtonClass
{
  GtkButtonClass parent_class;

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

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

  gboolean (* get_border) (GtkScrollable *scrollable,
                           GtkBorder     *border);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scrollable_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_hadjustment</NAME>
<RETURNS>GtkAdjustment        *</RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_hadjustment</NAME>
<RETURNS>void                  </RETURNS>
GtkScrollable       *scrollable, GtkAdjustment       *hadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_vadjustment</NAME>
<RETURNS>GtkAdjustment        *</RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_vadjustment</NAME>
<RETURNS>void                  </RETURNS>
GtkScrollable       *scrollable, GtkAdjustment       *vadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_hscroll_policy</NAME>
<RETURNS>GtkScrollablePolicy   </RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_hscroll_policy</NAME>
<RETURNS>void                  </RETURNS>
GtkScrollable       *scrollable, GtkScrollablePolicy  policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_vscroll_policy</NAME>
<RETURNS>GtkScrollablePolicy   </RETURNS>
GtkScrollable       *scrollable
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_set_vscroll_policy</NAME>
<RETURNS>void                  </RETURNS>
GtkScrollable       *scrollable, GtkScrollablePolicy  policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrollable_get_border</NAME>
<RETURNS>gboolean              </RETURNS>
GtkScrollable       *scrollable, GtkBorder           *border
</FUNCTION>
<STRUCT>
<NAME>GtkScrollable</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCROLLBAR</NAME>
#define GTK_TYPE_SCROLLBAR            (gtk_scrollbar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCROLLBAR</NAME>
#define GTK_SCROLLBAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLBAR, GtkScrollbar))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLBAR_CLASS</NAME>
#define GTK_SCROLLBAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLBAR, GtkScrollbarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLBAR</NAME>
#define GTK_IS_SCROLLBAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLBAR))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLBAR_CLASS</NAME>
#define GTK_IS_SCROLLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLBAR))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLBAR_GET_CLASS</NAME>
#define GTK_SCROLLBAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLBAR, GtkScrollbarClass))
</MACRO>
<STRUCT>
<NAME>GtkScrollbar</NAME>
struct _GtkScrollbar
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkScrollbarClass</NAME>
struct _GtkScrollbarClass
{
  GtkWidgetClass 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_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>
<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_SCROLLED_WINDOW_CLASS</NAME>
#define GTK_SCROLLED_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindowClass))
</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>
<MACRO>
<NAME>GTK_IS_SCROLLED_WINDOW_CLASS</NAME>
#define GTK_IS_SCROLLED_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLED_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW_GET_CLASS</NAME>
#define GTK_SCROLLED_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindowClass))
</MACRO>
<STRUCT>
<NAME>GtkScrolledWindow</NAME>
struct _GtkScrolledWindow
{
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkScrolledWindowClass</NAME>
struct _GtkScrolledWindowClass
{
  GtkBinClass parent_class;

  /*< public >*/

  /* Action signals for keybindings. Do not connect to these signals
   */

  /* Unfortunately, GtkScrollType is deficient in that there is
   * no horizontal/vertical variants for GTK_SCROLL_START/END,
   * so we have to add an additional boolean flag.
   */
  gboolean (*scroll_child) (GtkScrolledWindow *scrolled_window,
	  		    GtkScrollType      scroll,
			    gboolean           horizontal);

  void (* move_focus_out) (GtkScrolledWindow *scrolled_window,
			   GtkDirectionType   direction);

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<ENUM>
<NAME>GtkCornerType</NAME>
typedef enum
{
  GTK_CORNER_TOP_LEFT,
  GTK_CORNER_BOTTOM_LEFT,
  GTK_CORNER_TOP_RIGHT,
  GTK_CORNER_BOTTOM_RIGHT
} GtkCornerType;
</ENUM>
<ENUM>
<NAME>GtkPolicyType</NAME>
typedef enum
{
  GTK_POLICY_ALWAYS,
  GTK_POLICY_AUTOMATIC,
  GTK_POLICY_NEVER,
  GTK_POLICY_EXTERNAL
} GtkPolicyType;
</ENUM>
<FUNCTION>
<NAME>gtk_scrolled_window_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_new</NAME>
<RETURNS>GtkWidget *     </RETURNS>
GtkAdjustment     *hadjustment, GtkAdjustment     *vadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_hadjustment</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, GtkAdjustment     *hadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_vadjustment</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, GtkAdjustment     *vadjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_hadjustment</NAME>
<RETURNS>GtkAdjustment * </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_vadjustment</NAME>
<RETURNS>GtkAdjustment * </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_hscrollbar</NAME>
<RETURNS>GtkWidget *     </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_vscrollbar</NAME>
<RETURNS>GtkWidget *     </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_policy</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, GtkPolicyType      hscrollbar_policy, GtkPolicyType      vscrollbar_policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_policy</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, GtkPolicyType     *hscrollbar_policy, GtkPolicyType     *vscrollbar_policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_placement</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, GtkCornerType      window_placement
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_unset_placement</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_placement</NAME>
<RETURNS>GtkCornerType   </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_shadow_type</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, GtkShadowType      type
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_shadow_type</NAME>
<RETURNS>GtkShadowType   </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_min_content_width</NAME>
<RETURNS>gint            </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_min_content_width</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gint               width
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_min_content_height</NAME>
<RETURNS>gint            </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_min_content_height</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gint               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_kinetic_scrolling</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           kinetic_scrolling
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_kinetic_scrolling</NAME>
<RETURNS>gboolean        </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_capture_button_press</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           capture_button_press
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_capture_button_press</NAME>
<RETURNS>gboolean        </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_overlay_scrolling</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           overlay_scrolling
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_overlay_scrolling</NAME>
<RETURNS>gboolean        </RETURNS>
GtkScrolledWindow   *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_max_content_width</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gint               width
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_max_content_width</NAME>
<RETURNS>gint            </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_max_content_height</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gint               height
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_max_content_height</NAME>
<RETURNS>gint            </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_propagate_natural_width</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           propagate
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_propagate_natural_width</NAME>
<RETURNS>gboolean        </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_set_propagate_natural_height</NAME>
<RETURNS>void            </RETURNS>
GtkScrolledWindow *scrolled_window, gboolean           propagate
</FUNCTION>
<FUNCTION>
<NAME>gtk_scrolled_window_get_propagate_natural_height</NAME>
<RETURNS>gboolean        </RETURNS>
GtkScrolledWindow *scrolled_window
</FUNCTION>
<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_SEARCH_BAR_CLASS</NAME>
#define GTK_SEARCH_BAR_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_BAR, GtkSearchBarClass))
</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>
<MACRO>
<NAME>GTK_IS_SEARCH_BAR_CLASS</NAME>
#define GTK_IS_SEARCH_BAR_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_BAR))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_BAR_GET_CLASS</NAME>
#define GTK_SEARCH_BAR_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_BAR, GtkSearchBarClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchBar</NAME>
struct _GtkSearchBar
{
  /*< private >*/
  GtkBin parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchBarClass</NAME>
struct _GtkSearchBarClass
{
  GtkBinClass 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_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>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENGINE</NAME>
#define GTK_TYPE_SEARCH_ENGINE		(_gtk_search_engine_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE</NAME>
#define GTK_SEARCH_ENGINE(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENGINE, GtkSearchEngine))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_CLASS</NAME>
#define GTK_SEARCH_ENGINE_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENGINE, GtkSearchEngineClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE</NAME>
#define GTK_IS_SEARCH_ENGINE(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENGINE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_CLASS</NAME>
#define GTK_IS_SEARCH_ENGINE_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENGINE))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_GET_CLASS</NAME>
#define GTK_SEARCH_ENGINE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENGINE, GtkSearchEngineClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchHit</NAME>
struct _GtkSearchHit
{
  GFile *file;
  GFileInfo *info; /* may be NULL */
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngine</NAME>
struct _GtkSearchEngine
{
  GObject parent;

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

  GtkSearchEngineQuartzPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineQuartzClass</NAME>
struct _GtkSearchEngineQuartzClass
{
  GtkSearchEngineClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineQuartzPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENGINE_SIMPLE</NAME>
#define GTK_TYPE_SEARCH_ENGINE_SIMPLE		(_gtk_search_engine_simple_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_SIMPLE</NAME>
#define GTK_SEARCH_ENGINE_SIMPLE(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENGINE_SIMPLE, GtkSearchEngineSimple))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_SIMPLE_CLASS</NAME>
#define GTK_SEARCH_ENGINE_SIMPLE_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENGINE_SIMPLE, GtkSearchEngineSimpleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_SIMPLE</NAME>
#define GTK_IS_SEARCH_ENGINE_SIMPLE(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENGINE_SIMPLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_SIMPLE_CLASS</NAME>
#define GTK_IS_SEARCH_ENGINE_SIMPLE_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENGINE_SIMPLE))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_SIMPLE_GET_CLASS</NAME>
#define GTK_SEARCH_ENGINE_SIMPLE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENGINE_SIMPLE, GtkSearchEngineSimpleClass))
</MACRO>
<USER_FUNCTION>
<NAME>GtkSearchEngineSimpleIsIndexed</NAME>
<RETURNS>gboolean </RETURNS>
GFile *location, gpointer data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkSearchEngineSimple</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineSimpleClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENGINE_TRACKER</NAME>
#define GTK_TYPE_SEARCH_ENGINE_TRACKER		(_gtk_search_engine_tracker_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_TRACKER</NAME>
#define GTK_SEARCH_ENGINE_TRACKER(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTracker))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_TRACKER_CLASS</NAME>
#define GTK_SEARCH_ENGINE_TRACKER_CLASS(klass)	(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTrackerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_TRACKER</NAME>
#define GTK_IS_SEARCH_ENGINE_TRACKER(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEARCH_ENGINE_TRACKER))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEARCH_ENGINE_TRACKER_CLASS</NAME>
#define GTK_IS_SEARCH_ENGINE_TRACKER_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENGINE_TRACKER))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENGINE_TRACKER_GET_CLASS</NAME>
#define GTK_SEARCH_ENGINE_TRACKER_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENGINE_TRACKER, GtkSearchEngineTrackerClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchEngineTracker</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSearchEngineTrackerClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEARCH_ENTRY</NAME>
#define GTK_TYPE_SEARCH_ENTRY                 (gtk_search_entry_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENTRY</NAME>
#define GTK_SEARCH_ENTRY(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEARCH_ENTRY, GtkSearchEntry))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENTRY_CLASS</NAME>
#define GTK_SEARCH_ENTRY_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEARCH_ENTRY, GtkSearchEntryClass))
</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>
<MACRO>
<NAME>GTK_IS_SEARCH_ENTRY_CLASS</NAME>
#define GTK_IS_SEARCH_ENTRY_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEARCH_ENTRY))
</MACRO>
<MACRO>
<NAME>GTK_SEARCH_ENTRY_GET_CLASS</NAME>
#define GTK_SEARCH_ENTRY_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEARCH_ENTRY, GtkSearchEntryClass))
</MACRO>
<STRUCT>
<NAME>GtkSearchEntry</NAME>
struct _GtkSearchEntry
{
  GtkWidget parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkSearchEntryClass</NAME>
struct _GtkSearchEntryClass
{
  GtkWidgetClass parent_class;

  void (* activate)       (GtkSearchEntry *entry);
  void (* search_changed) (GtkSearchEntry *entry);
  void (* next_match)     (GtkSearchEntry *entry);
  void (* previous_match) (GtkSearchEntry *entry);
  void (* stop_search)    (GtkSearchEntry *entry);
};
</STRUCT>
<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>
<MACRO>
<NAME>GTK_TYPE_SELECTION_DATA</NAME>
#define GTK_TYPE_SELECTION_DATA (gtk_selection_data_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_content_formats_add_text_targets</NAME>
<RETURNS>GdkContentFormats  *     </RETURNS>
GdkContentFormats *list
</FUNCTION>
<FUNCTION>
<NAME>gtk_content_formats_add_image_targets</NAME>
<RETURNS>GdkContentFormats  *     </RETURNS>
GdkContentFormats *list, gboolean           writable
</FUNCTION>
<FUNCTION>
<NAME>gtk_content_formats_add_uri_targets</NAME>
<RETURNS>GdkContentFormats  *     </RETURNS>
GdkContentFormats *list
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_target</NAME>
<RETURNS>GdkAtom        </RETURNS>
const GtkSelectionData *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_data_type</NAME>
<RETURNS>GdkAtom        </RETURNS>
const GtkSelectionData *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_format</NAME>
<RETURNS>gint           </RETURNS>
const GtkSelectionData *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_data</NAME>
<RETURNS>const guchar  *</RETURNS>
const GtkSelectionData *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_length</NAME>
<RETURNS>gint           </RETURNS>
const GtkSelectionData *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_data_with_length</NAME>
<RETURNS>const guchar  *</RETURNS>
const GtkSelectionData *selection_data, gint                   *length
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_display</NAME>
<RETURNS>GdkDisplay    *</RETURNS>
const GtkSelectionData *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_set</NAME>
<RETURNS>void      </RETURNS>
GtkSelectionData     *selection_data, GdkAtom               type, gint                  format, const guchar         *data, gint                  length
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_set_text</NAME>
<RETURNS>gboolean  </RETURNS>
GtkSelectionData     *selection_data, const gchar          *str, gint                  len
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_text</NAME>
<RETURNS>guchar  * </RETURNS>
const GtkSelectionData     *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_set_pixbuf</NAME>
<RETURNS>gboolean  </RETURNS>
GtkSelectionData  *selection_data, GdkPixbuf         *pixbuf
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_pixbuf</NAME>
<RETURNS>GdkPixbuf  *</RETURNS>
const GtkSelectionData  *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_set_texture</NAME>
<RETURNS>gboolean  </RETURNS>
GtkSelectionData *selection_data, GdkTexture       *texture
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_texture</NAME>
<RETURNS>GdkTexture  *</RETURNS>
const GtkSelectionData *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_set_uris</NAME>
<RETURNS>gboolean  </RETURNS>
GtkSelectionData     *selection_data, gchar               **uris
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_uris</NAME>
<RETURNS>gchar   **</RETURNS>
const GtkSelectionData     *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_targets</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkSelectionData  *selection_data, GdkAtom          **targets, gint              *n_atoms
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_targets_include_text</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkSelectionData  *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_targets_include_image</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkSelectionData  *selection_data, gboolean           writable
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_targets_include_uri</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkSelectionData  *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_targets_include_text</NAME>
<RETURNS>gboolean  </RETURNS>
GdkAtom       *targets, gint           n_targets
</FUNCTION>
<FUNCTION>
<NAME>gtk_targets_include_image</NAME>
<RETURNS>gboolean  </RETURNS>
GdkAtom       *targets, gint           n_targets, gboolean       writable
</FUNCTION>
<FUNCTION>
<NAME>gtk_targets_include_uri</NAME>
<RETURNS>gboolean  </RETURNS>
GdkAtom       *targets, gint           n_targets
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_copy</NAME>
<RETURNS>GtkSelectionData  *</RETURNS>
const GtkSelectionData *data
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_data_free</NAME>
<RETURNS>void               </RETURNS>
GtkSelectionData *data
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SELECTION_MODEL</NAME>
#define GTK_TYPE_SELECTION_MODEL       (gtk_selection_model_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkSelectionModelInterface</NAME>
struct _GtkSelectionModelInterface
{
  /*< private >*/
  GTypeInterface g_iface;

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

  gboolean              (* select_item)                         (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 gboolean                exclusive);
  gboolean              (* unselect_item)                       (GtkSelectionModel      *model,
                                                                 guint                   position);
  gboolean              (* select_range)                        (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                   n_items,
                                                                 gboolean                exclusive);
  gboolean              (* unselect_range)                      (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                   n_items);
  gboolean              (* select_all)                          (GtkSelectionModel      *model);
  gboolean              (* unselect_all)                        (GtkSelectionModel      *model);
  void                  (* query_range)                         (GtkSelectionModel      *model,
                                                                 guint                   position,
                                                                 guint                  *start_range,
                                                                 guint                  *n_items,
                                                                 gboolean               *selected);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_selection_model_is_selected</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSelectionModel      *model, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_select_item</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSelectionModel      *model, guint                   position, gboolean                exclusive
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_unselect_item</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSelectionModel      *model, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_select_range</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSelectionModel      *model, guint                   position, guint                   n_items, gboolean                exclusive
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_unselect_range</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSelectionModel      *model, guint                   position, guint                   n_items
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_select_all</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_unselect_all</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSelectionModel      *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_query_range</NAME>
<RETURNS>void                     </RETURNS>
GtkSelectionModel      *model, guint                   position, guint                  *start_range, guint                  *n_items, gboolean               *selected
</FUNCTION>
<FUNCTION>
<NAME>gtk_selection_model_selection_changed</NAME>
<RETURNS>void                     </RETURNS>
GtkSelectionModel      *model, guint                   position, guint                   n_items
</FUNCTION>
<STRUCT>
<NAME>GtkSelectionModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SEPARATOR</NAME>
#define GTK_TYPE_SEPARATOR                  (gtk_separator_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR</NAME>
#define GTK_SEPARATOR(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR, GtkSeparator))
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_CLASS</NAME>
#define GTK_SEPARATOR_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEPARATOR, GtkSeparatorClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEPARATOR</NAME>
#define GTK_IS_SEPARATOR(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEPARATOR_CLASS</NAME>
#define GTK_IS_SEPARATOR_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEPARATOR))
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_GET_CLASS</NAME>
#define GTK_SEPARATOR_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEPARATOR, GtkSeparatorClass))
</MACRO>
<STRUCT>
<NAME>GtkSeparator</NAME>
struct _GtkSeparator
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkSeparatorClass</NAME>
struct _GtkSeparatorClass
{
  GtkWidgetClass 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_separator_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_separator_new</NAME>
<RETURNS>GtkWidget  * </RETURNS>
GtkOrientation orientation
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SEPARATOR_MENU_ITEM</NAME>
#define GTK_TYPE_SEPARATOR_MENU_ITEM            (gtk_separator_menu_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_MENU_ITEM</NAME>
#define GTK_SEPARATOR_MENU_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR_MENU_ITEM, GtkSeparatorMenuItem))
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_MENU_ITEM_CLASS</NAME>
#define GTK_SEPARATOR_MENU_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEPARATOR_MENU_ITEM, GtkSeparatorMenuItemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEPARATOR_MENU_ITEM</NAME>
#define GTK_IS_SEPARATOR_MENU_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEPARATOR_MENU_ITEM_CLASS</NAME>
#define GTK_IS_SEPARATOR_MENU_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEPARATOR_MENU_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_MENU_ITEM_GET_CLASS</NAME>
#define GTK_SEPARATOR_MENU_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SEPARATOR_MENU_ITEM, GtkSeparatorMenuItemClass))
</MACRO>
<STRUCT>
<NAME>GtkSeparatorMenuItem</NAME>
struct _GtkSeparatorMenuItem
{
  GtkMenuItem menu_item;
};
</STRUCT>
<STRUCT>
<NAME>GtkSeparatorMenuItemClass</NAME>
struct _GtkSeparatorMenuItemClass
{
  GtkMenuItemClass 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_separator_menu_item_get_type</NAME>
<RETURNS>GType 	   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_separator_menu_item_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SEPARATOR_TOOL_ITEM</NAME>
#define GTK_TYPE_SEPARATOR_TOOL_ITEM            (gtk_separator_tool_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_TOOL_ITEM</NAME>
#define GTK_SEPARATOR_TOOL_ITEM(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM, GtkSeparatorToolItem))
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_TOOL_ITEM_CLASS</NAME>
#define GTK_SEPARATOR_TOOL_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SEPARATOR_TOOL_ITEM, GtkSeparatorToolItemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEPARATOR_TOOL_ITEM</NAME>
#define GTK_IS_SEPARATOR_TOOL_ITEM(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_SEPARATOR_TOOL_ITEM_CLASS</NAME>
#define GTK_IS_SEPARATOR_TOOL_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SEPARATOR_TOOL_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_SEPARATOR_TOOL_ITEM_GET_CLASS</NAME>
#define GTK_SEPARATOR_TOOL_ITEM_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_SEPARATOR_TOOL_ITEM, GtkSeparatorToolItemClass))
</MACRO>
<STRUCT>
<NAME>GtkSeparatorToolItem</NAME>
struct _GtkSeparatorToolItem
{
  GtkToolItem parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkSeparatorToolItemClass</NAME>
struct _GtkSeparatorToolItemClass
{
  GtkToolItemClass 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_separator_tool_item_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_separator_tool_item_new</NAME>
<RETURNS>GtkToolItem  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_separator_tool_item_get_draw</NAME>
<RETURNS>gboolean      </RETURNS>
GtkSeparatorToolItem *item
</FUNCTION>
<FUNCTION>
<NAME>gtk_separator_tool_item_set_draw</NAME>
<RETURNS>void          </RETURNS>
GtkSeparatorToolItem *item, gboolean              draw
</FUNCTION>
<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_SETTINGS_CLASS</NAME>
#define GTK_SETTINGS_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SETTINGS, GtkSettingsClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SETTINGS</NAME>
#define GTK_IS_SETTINGS(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SETTINGS))
</MACRO>
<MACRO>
<NAME>GTK_IS_SETTINGS_CLASS</NAME>
#define GTK_IS_SETTINGS_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SETTINGS))
</MACRO>
<MACRO>
<NAME>GTK_SETTINGS_GET_CLASS</NAME>
#define GTK_SETTINGS_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SETTINGS, GtkSettingsClass))
</MACRO>
<STRUCT>
<NAME>GtkSettings</NAME>
struct _GtkSettings
{
  GObject parent_instance;

  /*< private >*/
  GtkSettingsPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSettingsClass</NAME>
struct _GtkSettingsClass
{
  GObjectClass parent_class;

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<STRUCT>
<NAME>GtkSettingsValue</NAME>
struct _GtkSettingsValue
{
  /* origin should be something like "filename:linenumber" for rc files,
   * or e.g. "XProperty" for other sources
   */
  gchar *origin;

  /* valid types are LONG, DOUBLE and STRING corresponding to the token parsed,
   * or a GSTRING holding an unparsed statement
   */
  GValue value;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_settings_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_settings_get_default</NAME>
<RETURNS>GtkSettings *    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_settings_get_for_display</NAME>
<RETURNS>GtkSettings *    </RETURNS>
GdkDisplay *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_rc_property_parse_color</NAME>
<RETURNS>gboolean  </RETURNS>
const GParamSpec *pspec, const GString    *gstring, GValue           *property_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_rc_property_parse_enum</NAME>
<RETURNS>gboolean  </RETURNS>
const GParamSpec *pspec, const GString    *gstring, GValue           *property_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_rc_property_parse_flags</NAME>
<RETURNS>gboolean  </RETURNS>
const GParamSpec *pspec, const GString    *gstring, GValue           *property_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_rc_property_parse_requisition</NAME>
<RETURNS>gboolean  </RETURNS>
const GParamSpec *pspec, const GString    *gstring, GValue           *property_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_rc_property_parse_border</NAME>
<RETURNS>gboolean  </RETURNS>
const GParamSpec *pspec, const GString    *gstring, GValue           *property_value
</FUNCTION>
<FUNCTION>
<NAME>gtk_settings_reset_property</NAME>
<RETURNS>void      </RETURNS>
GtkSettings            *settings, const gchar            *name
</FUNCTION>
<STRUCT>
<NAME>GtkSettingsPrivate</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_SHORTCUT_LABEL_CLASS</NAME>
#define GTK_SHORTCUT_LABEL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SHORTCUT_LABEL, GtkShortcutLabelClass))
</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>
<MACRO>
<NAME>GTK_IS_SHORTCUT_LABEL_CLASS</NAME>
#define GTK_IS_SHORTCUT_LABEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SHORTCUT_LABEL))
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUT_LABEL_GET_CLASS</NAME>
#define GTK_SHORTCUT_LABEL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SHORTCUT_LABEL, GtkShortcutLabelClass))
</MACRO>
<FUNCTION>
<NAME>gtk_shortcut_label_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_new</NAME>
<RETURNS>GtkWidget    *</RETURNS>
const gchar      *accelerator
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_get_accelerator</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkShortcutLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_set_accelerator</NAME>
<RETURNS>void          </RETURNS>
GtkShortcutLabel *self, const gchar      *accelerator
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_get_disabled_text</NAME>
<RETURNS>const gchar  *</RETURNS>
GtkShortcutLabel *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_shortcut_label_set_disabled_text</NAME>
<RETURNS>void          </RETURNS>
GtkShortcutLabel *self, const gchar      *disabled_text
</FUNCTION>
<STRUCT>
<NAME>GtkShortcutLabel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkShortcutLabelClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_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_SHORTCUTS_GROUP_CLASS</NAME>
#define GTK_SHORTCUTS_GROUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SHORTCUTS_GROUP, GtkShortcutsGroupClass))
</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>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_GROUP_CLASS</NAME>
#define GTK_IS_SHORTCUTS_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SHORTCUTS_GROUP))
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_GROUP_GET_CLASS</NAME>
#define GTK_SHORTCUTS_GROUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SHORTCUTS_GROUP, GtkShortcutsGroupClass))
</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_SHORTCUTS_SECTION_CLASS</NAME>
#define GTK_SHORTCUTS_SECTION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SHORTCUTS_SECTION, GtkShortcutsSectionClass))
</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>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_SECTION_CLASS</NAME>
#define GTK_IS_SHORTCUTS_SECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SHORTCUTS_SECTION))
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_SECTION_GET_CLASS</NAME>
#define GTK_SHORTCUTS_SECTION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SHORTCUTS_SECTION, GtkShortcutsSectionClass))
</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_SHORTCUTS_SHORTCUT_CLASS</NAME>
#define GTK_SHORTCUTS_SHORTCUT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SHORTCUTS_SHORTCUT, GtkShortcutsShortcutClass))
</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>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_SHORTCUT_CLASS</NAME>
#define GTK_IS_SHORTCUTS_SHORTCUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SHORTCUTS_SHORTCUT))
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_SHORTCUT_GET_CLASS</NAME>
#define GTK_SHORTCUTS_SHORTCUT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SHORTCUTS_SHORTCUT, GtkShortcutsShortcutClass))
</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_SHORTCUTS_WINDOW_CLASS</NAME>
#define GTK_SHORTCUTS_WINDOW_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SHORTCUTS_WINDOW, GtkShortcutsWindowClass))
</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>
<MACRO>
<NAME>GTK_IS_SHORTCUTS_WINDOW_CLASS</NAME>
#define GTK_IS_SHORTCUTS_WINDOW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SHORTCUTS_WINDOW))
</MACRO>
<MACRO>
<NAME>GTK_SHORTCUTS_WINDOW_GET_CLASS</NAME>
#define GTK_SHORTCUTS_WINDOW_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SHORTCUTS_WINDOW, GtkShortcutsWindowClass))
</MACRO>
<STRUCT>
<NAME>GtkShortcutsWindow</NAME>
struct _GtkShortcutsWindow
{
  GtkWindow window;
};
</STRUCT>
<STRUCT>
<NAME>GtkShortcutsWindowClass</NAME>
struct _GtkShortcutsWindowClass
{
  GtkWindowClass parent_class;

  void (*close)  (GtkShortcutsWindow *self);
  void (*search) (GtkShortcutsWindow *self);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_shortcuts_window_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_show_uri_on_window</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWindow   *parent, const char  *uri, guint32      timestamp, GError     **error
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SINGLE_SELECTION</NAME>
#define GTK_TYPE_SINGLE_SELECTION (gtk_single_selection_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_INVALID_LIST_POSITION</NAME>
#define GTK_INVALID_LIST_POSITION (G_MAXUINT)
</MACRO>
<FUNCTION>
<NAME>gtk_single_selection_new</NAME>
<RETURNS>GtkSingleSelection  * </RETURNS>
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_SIZE_GROUP_CLASS</NAME>
#define GTK_SIZE_GROUP_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SIZE_GROUP, GtkSizeGroupClass))
</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>
<MACRO>
<NAME>GTK_IS_SIZE_GROUP_CLASS</NAME>
#define GTK_IS_SIZE_GROUP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SIZE_GROUP))
</MACRO>
<MACRO>
<NAME>GTK_SIZE_GROUP_GET_CLASS</NAME>
#define GTK_SIZE_GROUP_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SIZE_GROUP, GtkSizeGroupClass))
</MACRO>
<STRUCT>
<NAME>GtkSizeGroup</NAME>
struct _GtkSizeGroup
{
  GObject parent_instance;

  /*< private >*/
  GtkSizeGroupPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkSizeGroupClass</NAME>
struct _GtkSizeGroupClass
{
  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_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>GtkSizeGroupPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRequestedSize</NAME>
struct _GtkRequestedSize
{
  gpointer data;
  gint     minimum_size;
  gint     natural_size;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_distribute_natural_allocation</NAME>
<RETURNS>gint                 </RETURNS>
gint              extra_space, guint             n_requested_sizes, GtkRequestedSize *sizes
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_SLICE_LIST_MODEL</NAME>
#define GTK_TYPE_SLICE_LIST_MODEL (gtk_slice_list_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_slice_list_model_new</NAME>
<RETURNS>GtkSliceListModel  *     </RETURNS>
GListModel             *model, guint                   offset, guint                   size
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_new_for_type</NAME>
<RETURNS>GtkSliceListModel  *     </RETURNS>
GType                   item_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_set_model</NAME>
<RETURNS>void                     </RETURNS>
GtkSliceListModel      *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_get_model</NAME>
<RETURNS>GListModel  *            </RETURNS>
GtkSliceListModel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_set_offset</NAME>
<RETURNS>void                     </RETURNS>
GtkSliceListModel      *self, guint                   offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_get_offset</NAME>
<RETURNS>guint                    </RETURNS>
GtkSliceListModel      *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_set_size</NAME>
<RETURNS>void                     </RETURNS>
GtkSliceListModel      *self, guint                   size
</FUNCTION>
<FUNCTION>
<NAME>gtk_slice_list_model_get_size</NAME>
<RETURNS>guint                    </RETURNS>
GtkSliceListModel      *self
</FUNCTION>
<STRUCT>
<NAME>GtkSliceListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SNAPSHOT</NAME>
#define GTK_TYPE_SNAPSHOT               (gtk_snapshot_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SNAPSHOT</NAME>
#define GTK_SNAPSHOT(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SNAPSHOT, GtkSnapshot))
</MACRO>
<MACRO>
<NAME>GTK_IS_SNAPSHOT</NAME>
#define GTK_IS_SNAPSHOT(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SNAPSHOT))
</MACRO>
<FUNCTION>
<NAME>gtk_snapshot_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_new</NAME>
<RETURNS>GtkSnapshot  *   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_free_to_node</NAME>
<RETURNS>GskRenderNode  * </RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_free_to_paintable</NAME>
<RETURNS>GdkPaintable  *  </RETURNS>
GtkSnapshot            *snapshot, const graphene_size_t  *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_to_node</NAME>
<RETURNS>GskRenderNode  * </RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_to_paintable</NAME>
<RETURNS>GdkPaintable  *  </RETURNS>
GtkSnapshot            *snapshot, const graphene_size_t  *size
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_debug</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const char             *message, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_opacity</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, double                  opacity
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_blur</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, double                  radius
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_color_matrix</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_matrix_t*color_matrix, const graphene_vec4_t  *color_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_repeat</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_rect_t  *child_bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_clip</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_rounded_clip</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_shadow</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const GskShadow        *shadow, gsize                   n_shadows
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_blend</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GskBlendMode            blend_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_push_cross_fade</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, double                  progress
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_pop</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_save</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_restore</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_transform</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GskTransform           *transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_transform_matrix</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_matrix_t*matrix
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_translate</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_point_t *point
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_translate_3d</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_point3d_t*point
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_rotate</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, float                  angle
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_rotate_3d</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, float                   angle, const graphene_vec3_t  *axis
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_scale</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, float                   factor_x, float                   factor_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_scale_3d</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, float                   factor_x, float                   factor_y, float                   factor_z
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_perspective</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, float                   depth
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_node</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GskRenderNode          *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_cairo</NAME>
<RETURNS>cairo_t  *       </RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_texture</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GdkTexture             *texture, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_color</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const GdkRGBA          *color, const graphene_rect_t  *bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_linear_gradient</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_point_t *start_point, const graphene_point_t *end_point, const GskColorStop     *stops, gsize                   n_stops
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_repeating_linear_gradient</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const graphene_rect_t  *bounds, const graphene_point_t *start_point, const graphene_point_t *end_point, const GskColorStop     *stops, gsize                   n_stops
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_border</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *outline, const float             border_width[4], const GdkRGBA           border_color[4]
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_inset_shadow</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *outline, const GdkRGBA          *color, float                   dx, float                   dy, float                   spread, float                   blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_outset_shadow</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, const GskRoundedRect   *outline, const GdkRGBA          *color, float                   dx, float                   dy, float                   spread, float                   blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_append_layout</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, PangoLayout            *layout, const GdkRGBA          *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_background</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, gdouble                 width, gdouble                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_frame</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, gdouble                 width, gdouble                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_focus</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, gdouble                 width, gdouble                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_layout</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, PangoLayout            *layout
</FUNCTION>
<FUNCTION>
<NAME>gtk_snapshot_render_insertion_cursor</NAME>
<RETURNS>void             </RETURNS>
GtkSnapshot            *snapshot, GtkStyleContext        *context, gdouble                 x, gdouble                 y, PangoLayout            *layout, int                     index, PangoDirection          direction
</FUNCTION>
<STRUCT>
<NAME>GtkSnapshotClass</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SORT_LIST_MODEL</NAME>
#define GTK_TYPE_SORT_LIST_MODEL (gtk_sort_list_model_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_sort_list_model_new</NAME>
<RETURNS>GtkSortListModel  *      </RETURNS>
GListModel             *model, GCompareDataFunc        sort_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_new_for_type</NAME>
<RETURNS>GtkSortListModel  *      </RETURNS>
GType                   item_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_set_sort_func</NAME>
<RETURNS>void                     </RETURNS>
GtkSortListModel       *self, GCompareDataFunc        sort_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_has_sort</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkSortListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_set_model</NAME>
<RETURNS>void                     </RETURNS>
GtkSortListModel       *self, GListModel             *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_get_model</NAME>
<RETURNS>GListModel  *            </RETURNS>
GtkSortListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_sort_list_model_resort</NAME>
<RETURNS>void                     </RETURNS>
GtkSortListModel       *self
</FUNCTION>
<STRUCT>
<NAME>GtkSortListModel</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SPIN_BUTTON</NAME>
#define GTK_TYPE_SPIN_BUTTON                  (gtk_spin_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SPIN_BUTTON</NAME>
#define GTK_SPIN_BUTTON(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SPIN_BUTTON, GtkSpinButton))
</MACRO>
<MACRO>
<NAME>GTK_SPIN_BUTTON_CLASS</NAME>
#define GTK_SPIN_BUTTON_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SPIN_BUTTON, GtkSpinButtonClass))
</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_IS_SPIN_BUTTON_CLASS</NAME>
#define GTK_IS_SPIN_BUTTON_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SPIN_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_SPIN_BUTTON_GET_CLASS</NAME>
#define GTK_SPIN_BUTTON_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SPIN_BUTTON, GtkSpinButtonClass))
</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>
<STRUCT>
<NAME>GtkSpinButton</NAME>
struct _GtkSpinButton
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkSpinButtonClass</NAME>
struct _GtkSpinButtonClass
{
  GtkWidgetClass parent_class;

  gint (*input)  (GtkSpinButton *spin_button,
		  gdouble       *new_value);
  gint (*output) (GtkSpinButton *spin_button);
  void (*value_changed) (GtkSpinButton *spin_button);

  /* Action signals for keybindings, do not connect to these */
  void (*change_value) (GtkSpinButton *spin_button,
			GtkScrollType  scroll);

  void (*wrapped) (GtkSpinButton *spin_button);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_spin_button_get_type</NAME>
<RETURNS>GType 		</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_configure</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, GtkAdjustment  *adjustment, gdouble	    climb_rate, guint	    digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_new</NAME>
<RETURNS>GtkWidget *	</RETURNS>
GtkAdjustment  *adjustment, gdouble	    climb_rate, guint	    digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_new_with_range</NAME>
<RETURNS>GtkWidget *	</RETURNS>
gdouble  min, gdouble  max, gdouble  step
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_adjustment</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, GtkAdjustment  *adjustment
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_adjustment</NAME>
<RETURNS>GtkAdjustment *	</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_digits</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, guint	    digits
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_digits</NAME>
<RETURNS>guint            </RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_increments</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, gdouble         step, gdouble         page
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_increments</NAME>
<RETURNS>void             </RETURNS>
GtkSpinButton  *spin_button, gdouble        *step, gdouble        *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_range</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, gdouble         min, gdouble         max
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_range</NAME>
<RETURNS>void             </RETURNS>
GtkSpinButton  *spin_button, gdouble        *min, gdouble        *max
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_value</NAME>
<RETURNS>gdouble 		</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_value_as_int</NAME>
<RETURNS>gint 		</RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_value</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, gdouble	    value
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_update_policy</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, GtkSpinButtonUpdatePolicy  policy
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_update_policy</NAME>
<RETURNS>GtkSpinButtonUpdatePolicy  </RETURNS>
GtkSpinButton *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_numeric</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, gboolean	    numeric
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_numeric</NAME>
<RETURNS>gboolean         </RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_spin</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, GtkSpinType     direction, gdouble	    increment
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_wrap</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, gboolean	    wrap
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_wrap</NAME>
<RETURNS>gboolean         </RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_set_snap_to_ticks</NAME>
<RETURNS>void 		</RETURNS>
GtkSpinButton  *spin_button, gboolean	    snap_to_ticks
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_get_snap_to_ticks</NAME>
<RETURNS>gboolean         </RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_spin_button_update</NAME>
<RETURNS>void             </RETURNS>
GtkSpinButton  *spin_button
</FUNCTION>
<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_SPINNER_CLASS</NAME>
#define GTK_SPINNER_CLASS(obj)     (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_SPINNER,  GtkSpinnerClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPINNER</NAME>
#define GTK_IS_SPINNER(obj)        (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SPINNER))
</MACRO>
<MACRO>
<NAME>GTK_IS_SPINNER_CLASS</NAME>
#define GTK_IS_SPINNER_CLASS(obj)  (G_TYPE_CHECK_CLASS_TYPE ((obj), GTK_TYPE_SPINNER))
</MACRO>
<MACRO>
<NAME>GTK_SPINNER_GET_CLASS</NAME>
#define GTK_SPINNER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SPINNER, GtkSpinnerClass))
</MACRO>
<STRUCT>
<NAME>GtkSpinner</NAME>
struct _GtkSpinner
{
  GtkWidget parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkSpinnerClass</NAME>
struct _GtkSpinnerClass
{
  GtkWidgetClass 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_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>
<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_STACK_CLASS</NAME>
#define GTK_STACK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STACK, GtkStackClass))
</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_IS_STACK_CLASS</NAME>
#define GTK_IS_STACK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STACK))
</MACRO>
<MACRO>
<NAME>GTK_STACK_GET_CLASS</NAME>
#define GTK_STACK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STACK, GtkStackClass))
</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_STACK_PAGE_CLASS</NAME>
#define GTK_STACK_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STACK_PAGE, GtkStackPageClass))
</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>
<MACRO>
<NAME>GTK_IS_STACK_PAGE_CLASS</NAME>
#define GTK_IS_STACK_PAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STACK_PAGE))
</MACRO>
<MACRO>
<NAME>GTK_STACK_PAGE_GET_CLASS</NAME>
#define GTK_STACK_PAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STACK_PAGE, GtkStackPageClass))
</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>
<STRUCT>
<NAME>GtkStack</NAME>
struct _GtkStack {
  GtkContainer parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkStackClass</NAME>
struct _GtkStackClass {
  GtkContainerClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_stack_page_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_new</NAME>
<RETURNS>GtkWidget  *            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_add_named</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, GtkWidget              *child, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_add_titled</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, GtkWidget              *child, const gchar            *name, const gchar            *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_page</NAME>
<RETURNS>GtkStackPage  *         </RETURNS>
GtkStack               *stack, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_page_get_child</NAME>
<RETURNS>GtkWidget  *            </RETURNS>
GtkStackPage           *page
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_child_by_name</NAME>
<RETURNS>GtkWidget  *            </RETURNS>
GtkStack               *stack, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_visible_child</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, GtkWidget              *child
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_visible_child</NAME>
<RETURNS>GtkWidget  *            </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_visible_child_name</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_visible_child_name</NAME>
<RETURNS>const gchar  *          </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_visible_child_full</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, const gchar            *name, GtkStackTransitionType  transition
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_homogeneous</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, gboolean                homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_homogeneous</NAME>
<RETURNS>gboolean                </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_hhomogeneous</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, gboolean                hhomogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_hhomogeneous</NAME>
<RETURNS>gboolean                </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_vhomogeneous</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, gboolean                vhomogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_vhomogeneous</NAME>
<RETURNS>gboolean                </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_transition_duration</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, guint                   duration
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_transition_duration</NAME>
<RETURNS>guint                   </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_transition_type</NAME>
<RETURNS>void                    </RETURNS>
GtkStack               *stack, GtkStackTransitionType  transition
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_transition_type</NAME>
<RETURNS>GtkStackTransitionType  </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_transition_running</NAME>
<RETURNS>gboolean                </RETURNS>
GtkStack               *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_set_interpolate_size</NAME>
<RETURNS>void                    </RETURNS>
GtkStack *stack, gboolean  interpolate_size
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_interpolate_size</NAME>
<RETURNS>gboolean                </RETURNS>
GtkStack *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_get_pages</NAME>
<RETURNS>GtkSelectionModel  *    </RETURNS>
GtkStack *stack
</FUNCTION>
<STRUCT>
<NAME>GtkStackPage</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkStackPageClass</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>
<MACRO>
<NAME>GTK_STACK_SIDEBAR_CLASS</NAME>
#define GTK_STACK_SIDEBAR_CLASS(klass)   (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STACK_SIDEBAR, GtkStackSidebarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_STACK_SIDEBAR_CLASS</NAME>
#define GTK_IS_STACK_SIDEBAR_CLASS(klass)(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STACK_SIDEBAR))
</MACRO>
<MACRO>
<NAME>GTK_STACK_SIDEBAR_GET_CLASS</NAME>
#define GTK_STACK_SIDEBAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STACK_SIDEBAR, GtkStackSidebarClass))
</MACRO>
<STRUCT>
<NAME>GtkStackSidebar</NAME>
struct _GtkStackSidebar
{
  GtkBin parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkStackSidebarClass</NAME>
struct _GtkStackSidebarClass
{
  GtkBinClass 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_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 *sidebar, GtkStack        *stack
</FUNCTION>
<FUNCTION>
<NAME>gtk_stack_sidebar_get_stack</NAME>
<RETURNS>GtkStack  *  </RETURNS>
GtkStackSidebar *sidebar
</FUNCTION>
<STRUCT>
<NAME>GtkStackSidebarPrivate</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_STACK_SWITCHER_CLASS</NAME>
#define GTK_STACK_SWITCHER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STACK_SWITCHER, GtkStackSwitcherClass))
</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>
<MACRO>
<NAME>GTK_IS_STACK_SWITCHER_CLASS</NAME>
#define GTK_IS_STACK_SWITCHER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STACK_SWITCHER))
</MACRO>
<MACRO>
<NAME>GTK_STACK_SWITCHER_GET_CLASS</NAME>
#define GTK_STACK_SWITCHER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STACK_SWITCHER, GtkStackSwitcherClass))
</MACRO>
<STRUCT>
<NAME>GtkStackSwitcher</NAME>
struct _GtkStackSwitcher
{
  GtkBox widget;
};
</STRUCT>
<STRUCT>
<NAME>GtkStackSwitcherClass</NAME>
struct _GtkStackSwitcherClass
{
  GtkBoxClass 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_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>
<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_STATUSBAR_CLASS</NAME>
#define GTK_STATUSBAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_STATUSBAR, GtkStatusbarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_STATUSBAR</NAME>
#define GTK_IS_STATUSBAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_STATUSBAR))
</MACRO>
<MACRO>
<NAME>GTK_IS_STATUSBAR_CLASS</NAME>
#define GTK_IS_STATUSBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_STATUSBAR))
</MACRO>
<MACRO>
<NAME>GTK_STATUSBAR_GET_CLASS</NAME>
#define GTK_STATUSBAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_STATUSBAR, GtkStatusbarClass))
</MACRO>
<STRUCT>
<NAME>GtkStatusbar</NAME>
struct _GtkStatusbar
{
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkStatusbarClass</NAME>
struct _GtkStatusbarClass
{
  GtkWidgetClass parent_class;

  void	(*text_pushed)	(GtkStatusbar	*statusbar,
			 guint		 context_id,
			 const gchar	*text);
  void	(*text_popped)	(GtkStatusbar	*statusbar,
			 guint		 context_id,
			 const gchar	*text);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_statusbar_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_get_context_id</NAME>
<RETURNS>guint 	   </RETURNS>
GtkStatusbar *statusbar, const gchar  *context_description
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_push</NAME>
<RETURNS>guint       </RETURNS>
GtkStatusbar *statusbar, guint	       context_id, const gchar  *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_pop</NAME>
<RETURNS>void        </RETURNS>
GtkStatusbar *statusbar, guint	       context_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_remove</NAME>
<RETURNS>void        </RETURNS>
GtkStatusbar *statusbar, guint	       context_id, guint         message_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_remove_all</NAME>
<RETURNS>void        </RETURNS>
GtkStatusbar *statusbar, guint	       context_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_statusbar_get_message_area</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkStatusbar *statusbar
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_STYLE_CONTEXT</NAME>
#define GTK_TYPE_STYLE_CONTEXT         (gtk_style_context_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CONTEXT</NAME>
#define GTK_STYLE_CONTEXT(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContext))
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CONTEXT_CLASS</NAME>
#define GTK_STYLE_CONTEXT_CLASS(c)     (G_TYPE_CHECK_CLASS_CAST    ((c), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_STYLE_CONTEXT</NAME>
#define GTK_IS_STYLE_CONTEXT(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_STYLE_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_IS_STYLE_CONTEXT_CLASS</NAME>
#define GTK_IS_STYLE_CONTEXT_CLASS(c)  (G_TYPE_CHECK_CLASS_TYPE    ((c), GTK_TYPE_STYLE_CONTEXT))
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CONTEXT_GET_CLASS</NAME>
#define GTK_STYLE_CONTEXT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS  ((o), GTK_TYPE_STYLE_CONTEXT, GtkStyleContextClass))
</MACRO>
<STRUCT>
<NAME>GtkStyleContext</NAME>
struct _GtkStyleContext
{
  GObject parent_object;
};
</STRUCT>
<STRUCT>
<NAME>GtkStyleContextClass</NAME>
struct _GtkStyleContextClass
{
  GObjectClass parent_class;

  void (* changed) (GtkStyleContext *context);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_BACKGROUND_COLOR</NAME>
#define GTK_STYLE_PROPERTY_BACKGROUND_COLOR "background-color"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_COLOR</NAME>
#define GTK_STYLE_PROPERTY_COLOR "color"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_FONT</NAME>
#define GTK_STYLE_PROPERTY_FONT "font"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_PADDING</NAME>
#define GTK_STYLE_PROPERTY_PADDING "padding"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_BORDER_WIDTH</NAME>
#define GTK_STYLE_PROPERTY_BORDER_WIDTH "border-width"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_MARGIN</NAME>
#define GTK_STYLE_PROPERTY_MARGIN "margin"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_BORDER_RADIUS</NAME>
#define GTK_STYLE_PROPERTY_BORDER_RADIUS "border-radius"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_BORDER_STYLE</NAME>
#define GTK_STYLE_PROPERTY_BORDER_STYLE "border-style"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_BORDER_COLOR</NAME>
#define GTK_STYLE_PROPERTY_BORDER_COLOR "border-color"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_PROPERTY_BACKGROUND_IMAGE</NAME>
#define GTK_STYLE_PROPERTY_BACKGROUND_IMAGE "background-image"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CELL</NAME>
#define GTK_STYLE_CLASS_CELL "cell"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DIM_LABEL</NAME>
#define GTK_STYLE_CLASS_DIM_LABEL "dim-label"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ENTRY</NAME>
#define GTK_STYLE_CLASS_ENTRY "entry"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LABEL</NAME>
#define GTK_STYLE_CLASS_LABEL "label"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_COMBOBOX_ENTRY</NAME>
#define GTK_STYLE_CLASS_COMBOBOX_ENTRY "combobox-entry"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_BUTTON</NAME>
#define GTK_STYLE_CLASS_BUTTON "button"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LIST</NAME>
#define GTK_STYLE_CLASS_LIST "list"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LIST_ROW</NAME>
#define GTK_STYLE_CLASS_LIST_ROW "list-row"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CALENDAR</NAME>
#define GTK_STYLE_CLASS_CALENDAR "calendar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SLIDER</NAME>
#define GTK_STYLE_CLASS_SLIDER "slider"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_BACKGROUND</NAME>
#define GTK_STYLE_CLASS_BACKGROUND "background"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RUBBERBAND</NAME>
#define GTK_STYLE_CLASS_RUBBERBAND "rubberband"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CSD</NAME>
#define GTK_STYLE_CLASS_CSD "csd"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOOLTIP</NAME>
#define GTK_STYLE_CLASS_TOOLTIP "tooltip"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MENU</NAME>
#define GTK_STYLE_CLASS_MENU "menu"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CONTEXT_MENU</NAME>
#define GTK_STYLE_CLASS_CONTEXT_MENU "context-menu"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOUCH_SELECTION</NAME>
#define GTK_STYLE_CLASS_TOUCH_SELECTION "touch-selection"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MENUBAR</NAME>
#define GTK_STYLE_CLASS_MENUBAR "menubar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MENUITEM</NAME>
#define GTK_STYLE_CLASS_MENUITEM "menuitem"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOOLBAR</NAME>
#define GTK_STYLE_CLASS_TOOLBAR "toolbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PRIMARY_TOOLBAR</NAME>
#define GTK_STYLE_CLASS_PRIMARY_TOOLBAR "primary-toolbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_INLINE_TOOLBAR</NAME>
#define GTK_STYLE_CLASS_INLINE_TOOLBAR "inline-toolbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_STATUSBAR</NAME>
#define GTK_STYLE_CLASS_STATUSBAR "statusbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RADIO</NAME>
#define GTK_STYLE_CLASS_RADIO "radio"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CHECK</NAME>
#define GTK_STYLE_CLASS_CHECK "check"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DEFAULT</NAME>
#define GTK_STYLE_CLASS_DEFAULT "default"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TROUGH</NAME>
#define GTK_STYLE_CLASS_TROUGH "trough"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCROLLBAR</NAME>
#define GTK_STYLE_CLASS_SCROLLBAR "scrollbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCROLLBARS_JUNCTION</NAME>
#define GTK_STYLE_CLASS_SCROLLBARS_JUNCTION "scrollbars-junction"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCALE</NAME>
#define GTK_STYLE_CLASS_SCALE "scale"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE</NAME>
#define GTK_STYLE_CLASS_SCALE_HAS_MARKS_ABOVE "scale-has-marks-above"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW</NAME>
#define GTK_STYLE_CLASS_SCALE_HAS_MARKS_BELOW "scale-has-marks-below"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_HEADER</NAME>
#define GTK_STYLE_CLASS_HEADER "header"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ACCELERATOR</NAME>
#define GTK_STYLE_CLASS_ACCELERATOR "accelerator"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RAISED</NAME>
#define GTK_STYLE_CLASS_RAISED "raised"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LINKED</NAME>
#define GTK_STYLE_CLASS_LINKED "linked"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DOCK</NAME>
#define GTK_STYLE_CLASS_DOCK "dock"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PROGRESSBAR</NAME>
#define GTK_STYLE_CLASS_PROGRESSBAR "progressbar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SPINNER</NAME>
#define GTK_STYLE_CLASS_SPINNER "spinner"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MARK</NAME>
#define GTK_STYLE_CLASS_MARK "mark"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_EXPANDER</NAME>
#define GTK_STYLE_CLASS_EXPANDER "expander"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SPINBUTTON</NAME>
#define GTK_STYLE_CLASS_SPINBUTTON "spinbutton"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_NOTEBOOK</NAME>
#define GTK_STYLE_CLASS_NOTEBOOK "notebook"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_VIEW</NAME>
#define GTK_STYLE_CLASS_VIEW "view"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SIDEBAR</NAME>
#define GTK_STYLE_CLASS_SIDEBAR "sidebar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_IMAGE</NAME>
#define GTK_STYLE_CLASS_IMAGE "image"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_HIGHLIGHT</NAME>
#define GTK_STYLE_CLASS_HIGHLIGHT "highlight"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_FRAME</NAME>
#define GTK_STYLE_CLASS_FRAME "frame"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DND</NAME>
#define GTK_STYLE_CLASS_DND "dnd"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PANE_SEPARATOR</NAME>
#define GTK_STYLE_CLASS_PANE_SEPARATOR "pane-separator"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SEPARATOR</NAME>
#define GTK_STYLE_CLASS_SEPARATOR "separator"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_INFO</NAME>
#define GTK_STYLE_CLASS_INFO "info"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_WARNING</NAME>
#define GTK_STYLE_CLASS_WARNING "warning"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_QUESTION</NAME>
#define GTK_STYLE_CLASS_QUESTION "question"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ERROR</NAME>
#define GTK_STYLE_CLASS_ERROR "error"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_HORIZONTAL</NAME>
#define GTK_STYLE_CLASS_HORIZONTAL "horizontal"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_VERTICAL</NAME>
#define GTK_STYLE_CLASS_VERTICAL "vertical"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TOP</NAME>
#define GTK_STYLE_CLASS_TOP "top"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_BOTTOM</NAME>
#define GTK_STYLE_CLASS_BOTTOM "bottom"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LEFT</NAME>
#define GTK_STYLE_CLASS_LEFT "left"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_RIGHT</NAME>
#define GTK_STYLE_CLASS_RIGHT "right"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PULSE</NAME>
#define GTK_STYLE_CLASS_PULSE "pulse"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_ARROW</NAME>
#define GTK_STYLE_CLASS_ARROW "arrow"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_OSD</NAME>
#define GTK_STYLE_CLASS_OSD "osd"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_LEVEL_BAR</NAME>
#define GTK_STYLE_CLASS_LEVEL_BAR "level-bar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_CURSOR_HANDLE</NAME>
#define GTK_STYLE_CLASS_CURSOR_HANDLE "cursor-handle"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_INSERTION_CURSOR</NAME>
#define GTK_STYLE_CLASS_INSERTION_CURSOR "insertion-cursor"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TITLEBAR</NAME>
#define GTK_STYLE_CLASS_TITLEBAR "titlebar"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_TITLE</NAME>
#define GTK_STYLE_CLASS_TITLE "title"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SUBTITLE</NAME>
#define GTK_STYLE_CLASS_SUBTITLE "subtitle"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_NEEDS_ATTENTION</NAME>
#define GTK_STYLE_CLASS_NEEDS_ATTENTION "needs-attention"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_SUGGESTED_ACTION</NAME>
#define GTK_STYLE_CLASS_SUGGESTED_ACTION "suggested-action"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_DESTRUCTIVE_ACTION</NAME>
#define GTK_STYLE_CLASS_DESTRUCTIVE_ACTION "destructive-action"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_POPOVER</NAME>
#define GTK_STYLE_CLASS_POPOVER "popover"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_POPUP</NAME>
#define GTK_STYLE_CLASS_POPUP "popup"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MESSAGE_DIALOG</NAME>
#define GTK_STYLE_CLASS_MESSAGE_DIALOG "message-dialog"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_FLAT</NAME>
#define GTK_STYLE_CLASS_FLAT "flat"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_READ_ONLY</NAME>
#define GTK_STYLE_CLASS_READ_ONLY "read-only"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_OVERSHOOT</NAME>
#define GTK_STYLE_CLASS_OVERSHOOT "overshoot"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_UNDERSHOOT</NAME>
#define GTK_STYLE_CLASS_UNDERSHOOT "undershoot"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_PAPER</NAME>
#define GTK_STYLE_CLASS_PAPER "paper"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_MONOSPACE</NAME>
#define GTK_STYLE_CLASS_MONOSPACE "monospace"
</MACRO>
<MACRO>
<NAME>GTK_STYLE_CLASS_WIDE</NAME>
#define GTK_STYLE_CLASS_WIDE "wide"
</MACRO>
<FUNCTION>
<NAME>gtk_style_context_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_new</NAME>
<RETURNS>GtkStyleContext  * </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_get_section</NAME>
<RETURNS>GtkCssSection  * </RETURNS>
GtkStyleContext *context, const gchar     *property
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_property</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext *context, const gchar     *property, GValue          *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_valist</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext *context, const char      *first_property_name, va_list          args
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext *context, const char      *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_state</NAME>
<RETURNS>void           </RETURNS>
GtkStyleContext *context, GtkStateFlags    flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_state</NAME>
<RETURNS>GtkStateFlags  </RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_scale</NAME>
<RETURNS>void           </RETURNS>
GtkStyleContext *context, gint             scale
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_scale</NAME>
<RETURNS>gint           </RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_path</NAME>
<RETURNS>void           </RETURNS>
GtkStyleContext *context, GtkWidgetPath   *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_path</NAME>
<RETURNS>const GtkWidgetPath  * </RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_parent</NAME>
<RETURNS>void           </RETURNS>
GtkStyleContext *context, GtkStyleContext *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_parent</NAME>
<RETURNS>GtkStyleContext  *</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_list_classes</NAME>
<RETURNS>GList  *  </RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_add_class</NAME>
<RETURNS>void      </RETURNS>
GtkStyleContext *context, const gchar     *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_remove_class</NAME>
<RETURNS>void      </RETURNS>
GtkStyleContext *context, const gchar     *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_has_class</NAME>
<RETURNS>gboolean  </RETURNS>
GtkStyleContext *context, const gchar     *class_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_set_display</NAME>
<RETURNS>void         </RETURNS>
GtkStyleContext *context, GdkDisplay      *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_display</NAME>
<RETURNS>GdkDisplay  *</RETURNS>
GtkStyleContext *context
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_lookup_color</NAME>
<RETURNS>gboolean  </RETURNS>
GtkStyleContext *context, const gchar     *color_name, GdkRGBA         *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_color</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext *context, GdkRGBA         *color
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_border</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext *context, GtkBorder       *border
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_padding</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext *context, GtkBorder       *padding
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_get_margin</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext *context, GtkBorder       *margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_style_context_reset_widgets</NAME>
<RETURNS>void  </RETURNS>
GdkDisplay      *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_render_insertion_cursor</NAME>
<RETURNS>void  </RETURNS>
GtkStyleContext     *context, cairo_t             *cr, gdouble              x, gdouble              y, PangoLayout         *layout, int                  index, PangoDirection       direction
</FUNCTION>
<ENUM>
<NAME>GtkStyleContextPrintFlags</NAME>
typedef enum {
  GTK_STYLE_CONTEXT_PRINT_NONE         = 0,
  GTK_STYLE_CONTEXT_PRINT_RECURSE      = 1 << 0,
  GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE   = 1 << 1
} 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>
<MACRO>
<NAME>GTK_SWITCH_CLASS</NAME>
#define GTK_SWITCH_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SWITCH, GtkSwitchClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SWITCH_CLASS</NAME>
#define GTK_IS_SWITCH_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SWITCH))
</MACRO>
<MACRO>
<NAME>GTK_SWITCH_GET_CLASS</NAME>
#define GTK_SWITCH_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SWITCH, GtkSwitchClass))
</MACRO>
<STRUCT>
<NAME>GtkSwitch</NAME>
struct _GtkSwitch
{
  /*< private >*/
  GtkWidget parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkSwitchClass</NAME>
struct _GtkSwitchClass
{
  GtkWidgetClass parent_class;

  /*< public >*/

  void (* activate) (GtkSwitch *sw);

  gboolean (* state_set) (GtkSwitch *sw, gboolean state);
  /*< private >*/

  void (* _switch_padding_1) (void);
  void (* _switch_padding_2) (void);
  void (* _switch_padding_3) (void);
  void (* _switch_padding_4) (void);
  void (* _switch_padding_5) (void);
};
</STRUCT>
<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 *sw, gboolean   is_active
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_get_active</NAME>
<RETURNS>gboolean         </RETURNS>
GtkSwitch *sw
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_set_state</NAME>
<RETURNS>void             </RETURNS>
GtkSwitch *sw, gboolean   state
</FUNCTION>
<FUNCTION>
<NAME>gtk_switch_get_state</NAME>
<RETURNS>gboolean         </RETURNS>
GtkSwitch *sw
</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>gint             </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_text_length</NAME>
<RETURNS>guint16          </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_activates_default</NAME>
<RETURNS>void             </RETURNS>
GtkText         *self, gboolean         activates
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_activates_default</NAME>
<RETURNS>gboolean         </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_placeholder_text</NAME>
<RETURNS>const char  *    </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_placeholder_text</NAME>
<RETURNS>void             </RETURNS>
GtkText         *self, const char      *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_input_purpose</NAME>
<RETURNS>void             </RETURNS>
GtkText         *self, GtkInputPurpose  purpose
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_input_purpose</NAME>
<RETURNS>GtkInputPurpose  </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_input_hints</NAME>
<RETURNS>void             </RETURNS>
GtkText         *self, GtkInputHints    hints
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_input_hints</NAME>
<RETURNS>GtkInputHints    </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_attributes</NAME>
<RETURNS>void             </RETURNS>
GtkText         *self, PangoAttrList   *attrs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_attributes</NAME>
<RETURNS>PangoAttrList  * </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_set_tabs</NAME>
<RETURNS>void             </RETURNS>
GtkText         *self, PangoTabArray   *tabs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_get_tabs</NAME>
<RETURNS>PangoTabArray  * </RETURNS>
GtkText         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_grab_focus_without_selecting</NAME>
<RETURNS>void             </RETURNS>
GtkText         *self
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT_ATTRIBUTES</NAME>
#define GTK_TYPE_TEXT_ATTRIBUTES     (gtk_text_attributes_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkTextAppearance</NAME>
struct _GtkTextAppearance
{
  GdkRGBA *bg_rgba;
  GdkRGBA *fg_rgba;
  GdkRGBA *underline_rgba;
  GdkRGBA *strikethrough_rgba;

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

  guint underline : 4;          /* PangoUnderline */
  guint strikethrough : 1;

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

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

  GtkTextAppearance appearance;

  GtkJustification justification;
  GtkTextDirection direction;

  PangoFontDescription *font;

  gdouble font_scale;

  gint left_margin;
  gint right_margin;
  gint indent;

  gint pixels_above_lines;
  gint pixels_below_lines;
  gint pixels_inside_wrap;

  PangoTabArray *tabs;

  GtkWrapMode wrap_mode;

  PangoLanguage *language;

  guint invisible : 1;
  guint bg_full_height : 1;
  guint editable : 1;
  guint no_fallback: 1;

  GdkRGBA *pg_bg_rgba;

  gint letter_spacing;

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

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

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

  void (* insert_texture)         (GtkTextBuffer      *buffer,
                                   GtkTextIter        *iter,
                                   GdkTexture         *texture);

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

  /*< private >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_buffer_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_new</NAME>
<RETURNS>GtkTextBuffer  *</RETURNS>
GtkTextTagTable *table
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_line_count</NAME>
<RETURNS>gint            </RETURNS>
GtkTextBuffer   *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_char_count</NAME>
<RETURNS>gint            </RETURNS>
GtkTextBuffer   *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_tag_table</NAME>
<RETURNS>GtkTextTagTable * </RETURNS>
GtkTextBuffer  *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_set_text</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, const gchar   *text, gint           len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, const gchar   *text, gint           len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_at_cursor</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, const gchar   *text, gint           len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_interactive</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, const gchar   *text, gint           len, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_interactive_at_cursor</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextBuffer *buffer, const gchar   *text, gint           len, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_range</NAME>
<RETURNS>void      </RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_range_interactive</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const GtkTextIter *start, const GtkTextIter *end, gboolean           default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_with_tags</NAME>
<RETURNS>void     </RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const gchar       *text, gint               len, GtkTextTag        *first_tag, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_with_tags_by_name</NAME>
<RETURNS>void     </RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const gchar       *text, gint               len, const gchar       *first_tag_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_markup</NAME>
<RETURNS>void      </RETURNS>
GtkTextBuffer     *buffer, GtkTextIter       *iter, const gchar       *markup, gint               len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete</NAME>
<RETURNS>void      </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_interactive</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start_iter, GtkTextIter   *end_iter, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_backspace</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gboolean       interactive, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_text</NAME>
<RETURNS>gchar           *</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *start, const GtkTextIter *end, gboolean           include_hidden_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_slice</NAME>
<RETURNS>gchar           *</RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *start, const GtkTextIter *end, gboolean           include_hidden_chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_texture</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, GdkTexture    *texture
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_insert_child_anchor</NAME>
<RETURNS>void                </RETURNS>
GtkTextBuffer      *buffer, GtkTextIter        *iter, GtkTextChildAnchor *anchor
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_create_child_anchor</NAME>
<RETURNS>GtkTextChildAnchor  *</RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_add_mark</NAME>
<RETURNS>void            </RETURNS>
GtkTextBuffer     *buffer, GtkTextMark       *mark, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_create_mark</NAME>
<RETURNS>GtkTextMark    *</RETURNS>
GtkTextBuffer     *buffer, const gchar       *mark_name, const GtkTextIter *where, gboolean           left_gravity
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_move_mark</NAME>
<RETURNS>void            </RETURNS>
GtkTextBuffer     *buffer, GtkTextMark       *mark, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_mark</NAME>
<RETURNS>void            </RETURNS>
GtkTextBuffer     *buffer, GtkTextMark       *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_mark</NAME>
<RETURNS>GtkTextMark *   </RETURNS>
GtkTextBuffer     *buffer, const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_move_mark_by_name</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, const gchar       *name, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_mark_by_name</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_insert</NAME>
<RETURNS>GtkTextMark * </RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_selection_bound</NAME>
<RETURNS>GtkTextMark * </RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_place_cursor</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *where
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_select_range</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *ins, const GtkTextIter *bound
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_apply_tag</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, GtkTextTag        *tag, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_tag</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, GtkTextTag        *tag, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_apply_tag_by_name</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, const gchar       *name, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_tag_by_name</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, const gchar       *name, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_all_tags</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_create_tag</NAME>
<RETURNS>GtkTextTag     *</RETURNS>
GtkTextBuffer *buffer, const gchar   *tag_name, const gchar   *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line_offset</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           line_number, gint           char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line_index</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           line_number, gint           byte_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_offset</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_line</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, gint           line_number
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_start_iter</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_end_iter</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_bounds</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_mark</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *iter, GtkTextMark   *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_iter_at_child_anchor</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer      *buffer, GtkTextIter        *iter, GtkTextChildAnchor *anchor
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_modified</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_set_modified</NAME>
<RETURNS>void             </RETURNS>
GtkTextBuffer *buffer, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_has_selection</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_add_selection_clipboard</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, GdkClipboard      *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_remove_selection_clipboard</NAME>
<RETURNS>void  </RETURNS>
GtkTextBuffer     *buffer, GdkClipboard      *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_cut_clipboard</NAME>
<RETURNS>void             </RETURNS>
GtkTextBuffer *buffer, GdkClipboard  *clipboard, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_copy_clipboard</NAME>
<RETURNS>void             </RETURNS>
GtkTextBuffer *buffer, GdkClipboard  *clipboard
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_paste_clipboard</NAME>
<RETURNS>void             </RETURNS>
GtkTextBuffer *buffer, GdkClipboard  *clipboard, GtkTextIter   *override_location, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_get_selection_bounds</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_delete_selection</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTextBuffer *buffer, gboolean       interactive, gboolean       default_editable
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_buffer_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>GList *              </RETURNS>
GtkTextChildAnchor *anchor
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_child_anchor_get_deleted</NAME>
<RETURNS>gboolean             </RETURNS>
GtkTextChildAnchor *anchor
</FUNCTION>
<ENUM>
<NAME>GtkTextSearchFlags</NAME>
typedef enum {
  GTK_TEXT_SEARCH_VISIBLE_ONLY     = 1 << 0,
  GTK_TEXT_SEARCH_TEXT_ONLY        = 1 << 1,
  GTK_TEXT_SEARCH_CASE_INSENSITIVE = 1 << 2
  /* Possible future plans: SEARCH_REGEXP */
} GtkTextSearchFlags;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_TEXT_ITER</NAME>
#define GTK_TYPE_TEXT_ITER     (gtk_text_iter_get_type ())
</MACRO>
<STRUCT>
<NAME>GtkTextIter</NAME>
struct _GtkTextIter {
  /* GtkTextIter is an opaque datatype; ignore all these fields.
   * Initialize the iter with gtk_text_buffer_get_iter_*
   * functions
   */
  /*< private >*/
  gpointer dummy1;
  gpointer dummy2;
  gint dummy3;
  gint dummy4;
  gint dummy5;
  gint dummy6;
  gint dummy7;
  gint dummy8;
  gpointer dummy9;
  gpointer dummy10;
  gint dummy11;
  gint dummy12;
  /* padding */
  gint dummy13;
  gpointer dummy14;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_text_iter_get_buffer</NAME>
<RETURNS>GtkTextBuffer  *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_copy</NAME>
<RETURNS>GtkTextIter  *</RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_free</NAME>
<RETURNS>void          </RETURNS>
GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_assign</NAME>
<RETURNS>void          </RETURNS>
GtkTextIter       *iter, const GtkTextIter *other
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_offset</NAME>
<RETURNS>gint  </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line</NAME>
<RETURNS>gint  </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line_offset</NAME>
<RETURNS>gint  </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_line_index</NAME>
<RETURNS>gint  </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_line_offset</NAME>
<RETURNS>gint  </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_line_index</NAME>
<RETURNS>gint  </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_char</NAME>
<RETURNS>gunichar  </RETURNS>
const GtkTextIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_slice</NAME>
<RETURNS>gchar    *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_text</NAME>
<RETURNS>gchar    *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_slice</NAME>
<RETURNS>gchar    *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_visible_text</NAME>
<RETURNS>gchar    *</RETURNS>
const GtkTextIter  *start, const GtkTextIter  *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_texture</NAME>
<RETURNS>GdkTexture  * </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_marks</NAME>
<RETURNS>GSList   *  </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_child_anchor</NAME>
<RETURNS>GtkTextChildAnchor * </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_toggled_tags</NAME>
<RETURNS>GSList   *</RETURNS>
const GtkTextIter  *iter, gboolean            toggled_on
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_tag</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter  *iter, GtkTextTag         *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_tag</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter  *iter, GtkTextTag         *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_toggles_tag</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter  *iter, GtkTextTag         *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_has_tag</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter, GtkTextTag          *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_tags</NAME>
<RETURNS>GSList   *</RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_editable</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter, gboolean             default_setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_can_insert</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter, gboolean             default_editability
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_word</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_word</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_inside_word</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_sentence</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_sentence</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_inside_sentence</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_starts_line</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_ends_line</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_is_cursor_position</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_chars_in_line</NAME>
<RETURNS>gint      </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_bytes_in_line</NAME>
<RETURNS>gint      </RETURNS>
const GtkTextIter   *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_get_language</NAME>
<RETURNS>PangoLanguage * </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_is_end</NAME>
<RETURNS>gboolean        </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_is_start</NAME>
<RETURNS>gboolean        </RETURNS>
const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_char</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_char</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_chars</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_chars</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_line</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_line</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_lines</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_lines</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_word_end</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_word_start</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_word_ends</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_word_starts</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_line</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_line</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_lines</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_lines</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_word_end</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_word_start</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_word_ends</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_word_starts</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_sentence_end</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_sentence_start</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_sentence_ends</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_sentence_starts</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_cursor_position</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_cursor_position</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_cursor_positions</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_cursor_positions</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_cursor_position</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_cursor_position</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_visible_cursor_positions</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_visible_cursor_positions</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, gint         count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_offset</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *iter, gint         char_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *iter, gint         line_number
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line_offset</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *iter, gint         char_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_line_index</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *iter, gint         byte_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_to_end</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_to_line_end</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_visible_line_offset</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *iter, gint         char_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_set_visible_line_index</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *iter, gint         byte_on_line
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_to_tag_toggle</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, GtkTextTag  *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_to_tag_toggle</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter *iter, GtkTextTag  *tag
</FUNCTION>
<USER_FUNCTION>
<NAME>GtkTextCharPredicate</NAME>
<RETURNS>gboolean </RETURNS>
gunichar ch, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_find_char</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter          *iter, GtkTextCharPredicate  pred, gpointer              user_data, const GtkTextIter    *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_find_char</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextIter          *iter, GtkTextCharPredicate  pred, gpointer              user_data, const GtkTextIter    *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_forward_search</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter *iter, const gchar       *str, GtkTextSearchFlags flags, GtkTextIter       *match_start, GtkTextIter       *match_end, const GtkTextIter *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_backward_search</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter *iter, const gchar       *str, GtkTextSearchFlags flags, GtkTextIter       *match_start, GtkTextIter       *match_end, const GtkTextIter *limit
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_equal</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter *lhs, const GtkTextIter *rhs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_compare</NAME>
<RETURNS>gint      </RETURNS>
const GtkTextIter *lhs, const GtkTextIter *rhs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_in_range</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkTextIter *iter, const GtkTextIter *start, const GtkTextIter *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_iter_order</NAME>
<RETURNS>void      </RETURNS>
GtkTextIter *first, GtkTextIter *second
</FUNCTION>
<STRUCT>
<NAME>GtkTextBuffer</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TEXT_MARK</NAME>
#define GTK_TYPE_TEXT_MARK              (gtk_text_mark_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_MARK</NAME>
#define GTK_TEXT_MARK(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GTK_TYPE_TEXT_MARK, GtkTextMark))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_MARK_CLASS</NAME>
#define GTK_TEXT_MARK_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_MARK, GtkTextMarkClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_MARK</NAME>
#define GTK_IS_TEXT_MARK(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GTK_TYPE_TEXT_MARK))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_MARK_CLASS</NAME>
#define GTK_IS_TEXT_MARK_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_MARK))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_MARK_GET_CLASS</NAME>
#define GTK_TEXT_MARK_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_MARK, GtkTextMarkClass))
</MACRO>
<STRUCT>
<NAME>GtkTextMark</NAME>
struct _GtkTextMark
{
  GObject parent_instance;

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

  /* 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_mark_get_type</NAME>
<RETURNS>GType                  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_new</NAME>
<RETURNS>GtkTextMark           *</RETURNS>
const gchar *name, gboolean     left_gravity
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_set_visible</NAME>
<RETURNS>void                   </RETURNS>
GtkTextMark *mark, gboolean     setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_visible</NAME>
<RETURNS>gboolean               </RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_name</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_deleted</NAME>
<RETURNS>gboolean               </RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_buffer</NAME>
<RETURNS>GtkTextBuffer *        </RETURNS>
GtkTextMark *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_mark_get_left_gravity</NAME>
<RETURNS>gboolean               </RETURNS>
GtkTextMark *mark
</FUNCTION>
<MACRO>
<NAME>GTK_TEXT_CLASS</NAME>
#define GTK_TEXT_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT, GtkTextClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_CLASS</NAME>
#define GTK_IS_TEXT_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_GET_CLASS</NAME>
#define GTK_TEXT_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT, GtkTextClass))
</MACRO>
<STRUCT>
<NAME>GtkTextClass</NAME>
struct _GtkTextClass
{
  GtkWidgetClass parent_class;

  /* Hook to customize right-click popup */
  void (* populate_popup)     (GtkText         *self,
                               GtkWidget       *popup);

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

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

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

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

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

  /* 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_tag_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_new</NAME>
<RETURNS>GtkTextTag   *</RETURNS>
const gchar       *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_get_priority</NAME>
<RETURNS>gint          </RETURNS>
GtkTextTag        *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_set_priority</NAME>
<RETURNS>void          </RETURNS>
GtkTextTag        *tag, gint               priority
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_changed</NAME>
<RETURNS>void          </RETURNS>
GtkTextTag        *tag, gboolean           size_changed
</FUNCTION>
<STRUCT>
<NAME>GtkTextIter</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextTagPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextTagTable</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkTextTagTableForeach</NAME>
<RETURNS>void </RETURNS>
GtkTextTag *tag, gpointer data
</USER_FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT_TAG_TABLE</NAME>
#define GTK_TYPE_TEXT_TAG_TABLE            (gtk_text_tag_table_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_TAG_TABLE</NAME>
#define GTK_TEXT_TAG_TABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTable))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_TAG_TABLE_CLASS</NAME>
#define GTK_TEXT_TAG_TABLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTableClass))
</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>
<MACRO>
<NAME>GTK_IS_TEXT_TAG_TABLE_CLASS</NAME>
#define GTK_IS_TEXT_TAG_TABLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_TAG_TABLE))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_TAG_TABLE_GET_CLASS</NAME>
#define GTK_TEXT_TAG_TABLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_TAG_TABLE, GtkTextTagTableClass))
</MACRO>
<STRUCT>
<NAME>GtkTextTagTable</NAME>
struct _GtkTextTagTable
{
  GObject parent_instance;

  GtkTextTagTablePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTextTagTableClass</NAME>
struct _GtkTextTagTableClass
{
  GObjectClass parent_class;

  void (* tag_changed) (GtkTextTagTable *table, GtkTextTag *tag, gboolean size_changed);
  void (* tag_added) (GtkTextTagTable *table, GtkTextTag *tag);
  void (* tag_removed) (GtkTextTagTable *table, GtkTextTag *tag);

  /* 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_tag_table_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_new</NAME>
<RETURNS>GtkTextTagTable  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_add</NAME>
<RETURNS>gboolean          </RETURNS>
GtkTextTagTable        *table, GtkTextTag             *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_remove</NAME>
<RETURNS>void              </RETURNS>
GtkTextTagTable        *table, GtkTextTag             *tag
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_lookup</NAME>
<RETURNS>GtkTextTag       *</RETURNS>
GtkTextTagTable        *table, const gchar            *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_foreach</NAME>
<RETURNS>void              </RETURNS>
GtkTextTagTable        *table, GtkTextTagTableForeach  func, gpointer                data
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_tag_table_get_size</NAME>
<RETURNS>gint              </RETURNS>
GtkTextTagTable        *table
</FUNCTION>
<STRUCT>
<NAME>GtkTextTagTablePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TEXT_UNKNOWN_CHAR</NAME>
#define GTK_TEXT_UNKNOWN_CHAR 0xFFFC
</MACRO>
<MACRO>
<NAME>GTK_TEXT_UNKNOWN_CHAR_UTF8_LEN</NAME>
#define GTK_TEXT_UNKNOWN_CHAR_UTF8_LEN 3
</MACRO>
<FUNCTION>
<NAME>gtk_text_unknown_char_utf8_gtk_tests_only</NAME>
<RETURNS>const gchar  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_byte_begins_utf8_char</NAME>
<RETURNS>gboolean  </RETURNS>
const gchar *byte
</FUNCTION>
<STRUCT>
<NAME>GtkTextCounter</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextLineSegment</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextLineSegmentClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextMarkBody</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTextToggleBody</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GtkTextUtilCharChosenFunc</NAME>
<RETURNS>void </RETURNS>
const char *text,
                                            gpointer    data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_text_util_create_drag_icon</NAME>
<RETURNS>GdkPaintable  *    </RETURNS>
GtkWidget     *widget, gchar         *text, gssize         len
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_util_create_rich_drag_icon</NAME>
<RETURNS>GdkPaintable  *    </RETURNS>
GtkWidget     *widget, GtkTextBuffer *buffer, GtkTextIter   *start, GtkTextIter   *end
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TEXT_VIEW</NAME>
#define GTK_TYPE_TEXT_VIEW             (gtk_text_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW</NAME>
#define GTK_TEXT_VIEW(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_VIEW, GtkTextView))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW_CLASS</NAME>
#define GTK_TEXT_VIEW_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_VIEW, GtkTextViewClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_VIEW</NAME>
#define GTK_IS_TEXT_VIEW(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_IS_TEXT_VIEW_CLASS</NAME>
#define GTK_IS_TEXT_VIEW_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_VIEW))
</MACRO>
<MACRO>
<NAME>GTK_TEXT_VIEW_GET_CLASS</NAME>
#define GTK_TEXT_VIEW_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_VIEW, GtkTextViewClass))
</MACRO>
<ENUM>
<NAME>GtkTextWindowType</NAME>
typedef enum
{
  GTK_TEXT_WINDOW_PRIVATE,
  GTK_TEXT_WINDOW_WIDGET,
  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
{
  GtkContainer parent_instance;

  /*< private >*/

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

  /*< public >*/

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

  /*< private >*/

  /* 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_view_get_type</NAME>
<RETURNS>GType           </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_new</NAME>
<RETURNS>GtkWidget  *    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_new_with_buffer</NAME>
<RETURNS>GtkWidget  *    </RETURNS>
GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_buffer</NAME>
<RETURNS>void            </RETURNS>
GtkTextView   *text_view, GtkTextBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_buffer</NAME>
<RETURNS>GtkTextBuffer  *</RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_scroll_to_iter</NAME>
<RETURNS>gboolean        </RETURNS>
GtkTextView   *text_view, GtkTextIter   *iter, gdouble        within_margin, gboolean       use_align, gdouble        xalign, gdouble        yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_scroll_to_mark</NAME>
<RETURNS>void            </RETURNS>
GtkTextView   *text_view, GtkTextMark   *mark, gdouble        within_margin, gboolean       use_align, gdouble        xalign, gdouble        yalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_scroll_mark_onscreen</NAME>
<RETURNS>void            </RETURNS>
GtkTextView   *text_view, GtkTextMark   *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_move_mark_onscreen</NAME>
<RETURNS>gboolean        </RETURNS>
GtkTextView   *text_view, GtkTextMark   *mark
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_place_cursor_onscreen</NAME>
<RETURNS>gboolean        </RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_visible_rect</NAME>
<RETURNS>void            </RETURNS>
GtkTextView   *text_view, GdkRectangle  *visible_rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_cursor_visible</NAME>
<RETURNS>void            </RETURNS>
GtkTextView   *text_view, gboolean       setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_cursor_visible</NAME>
<RETURNS>gboolean        </RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_reset_cursor_blink</NAME>
<RETURNS>void            </RETURNS>
GtkTextView   *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_cursor_locations</NAME>
<RETURNS>void            </RETURNS>
GtkTextView       *text_view, const GtkTextIter *iter, GdkRectangle      *strong, GdkRectangle      *weak
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_iter_location</NAME>
<RETURNS>void            </RETURNS>
GtkTextView   *text_view, const GtkTextIter *iter, GdkRectangle  *location
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_iter_at_location</NAME>
<RETURNS>gboolean        </RETURNS>
GtkTextView   *text_view, GtkTextIter   *iter, gint           x, gint           y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_iter_at_position</NAME>
<RETURNS>gboolean        </RETURNS>
GtkTextView   *text_view, GtkTextIter   *iter, gint          *trailing, gint           x, gint           y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_line_yrange</NAME>
<RETURNS>void            </RETURNS>
GtkTextView       *text_view, const GtkTextIter *iter, gint              *y, gint              *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_line_at_y</NAME>
<RETURNS>void            </RETURNS>
GtkTextView       *text_view, GtkTextIter       *target_iter, gint               y, gint              *line_top
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_buffer_to_surface_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTextView       *text_view, GtkTextWindowType  win, gint               buffer_x, gint               buffer_y, gint              *window_x, gint              *window_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_window_to_buffer_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTextView       *text_view, GtkTextWindowType  win, gint               window_x, gint               window_y, gint              *buffer_x, gint              *buffer_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_border_window_size</NAME>
<RETURNS>void  </RETURNS>
GtkTextView       *text_view, GtkTextWindowType  type, gint               size
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_border_window_size</NAME>
<RETURNS>gint  </RETURNS>
GtkTextView       *text_view, GtkTextWindowType  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_forward_display_line</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_backward_display_line</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_forward_display_line_end</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_backward_display_line_start</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_starts_display_line</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextView       *text_view, const GtkTextIter *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_move_visually</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTextView       *text_view, GtkTextIter       *iter, gint               count
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_im_context_filter_keypress</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTextView       *text_view, GdkEventKey       *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_reset_im_context</NAME>
<RETURNS>void             </RETURNS>
GtkTextView       *text_view
</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_child_in_window</NAME>
<RETURNS>void  </RETURNS>
GtkTextView          *text_view, GtkWidget            *child, GtkTextWindowType     which_window, gint                  xpos, gint                  ypos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_move_child</NAME>
<RETURNS>void  </RETURNS>
GtkTextView          *text_view, GtkWidget            *child, gint                  xpos, gint                  ypos
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_wrap_mode</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, GtkWrapMode       wrap_mode
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_wrap_mode</NAME>
<RETURNS>GtkWrapMode       </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_editable</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gboolean          setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_editable</NAME>
<RETURNS>gboolean          </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_overwrite</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gboolean          overwrite
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_overwrite</NAME>
<RETURNS>gboolean          </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_accepts_tab</NAME>
<RETURNS>void 		 </RETURNS>
GtkTextView	*text_view, gboolean		 accepts_tab
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_accepts_tab</NAME>
<RETURNS>gboolean 	 </RETURNS>
GtkTextView	*text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_above_lines</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              pixels_above_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_above_lines</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_below_lines</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              pixels_below_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_below_lines</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_pixels_inside_wrap</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              pixels_inside_wrap
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_pixels_inside_wrap</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_justification</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, GtkJustification  justification
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_justification</NAME>
<RETURNS>GtkJustification  </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_left_margin</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              left_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_left_margin</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_right_margin</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              right_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_right_margin</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_top_margin</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              top_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_top_margin</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_bottom_margin</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              bottom_margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_bottom_margin</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_indent</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gint              indent
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_indent</NAME>
<RETURNS>gint              </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_tabs</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, PangoTabArray    *tabs
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_tabs</NAME>
<RETURNS>PangoTabArray *   </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_input_purpose</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, GtkInputPurpose   purpose
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_input_purpose</NAME>
<RETURNS>GtkInputPurpose   </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_input_hints</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, GtkInputHints     hints
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_input_hints</NAME>
<RETURNS>GtkInputHints     </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_set_monospace</NAME>
<RETURNS>void              </RETURNS>
GtkTextView      *text_view, gboolean          monospace
</FUNCTION>
<FUNCTION>
<NAME>gtk_text_view_get_monospace</NAME>
<RETURNS>gboolean          </RETURNS>
GtkTextView      *text_view
</FUNCTION>
<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);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_toggle_button_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_new_with_label</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar     *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_new_with_mnemonic</NAME>
<RETURNS>GtkWidget * </RETURNS>
const gchar     *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_set_active</NAME>
<RETURNS>void        </RETURNS>
GtkToggleButton *toggle_button, gboolean         is_active
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_get_active</NAME>
<RETURNS>gboolean    </RETURNS>
GtkToggleButton *toggle_button
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_button_toggled</NAME>
<RETURNS>void        </RETURNS>
GtkToggleButton *toggle_button
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TOGGLE_TOOL_BUTTON</NAME>
#define GTK_TYPE_TOGGLE_TOOL_BUTTON             (gtk_toggle_tool_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_TOOL_BUTTON</NAME>
#define GTK_TOGGLE_TOOL_BUTTON(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON, GtkToggleToolButton))
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_TOOL_BUTTON_CLASS</NAME>
#define GTK_TOGGLE_TOOL_BUTTON_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOGGLE_TOOL_BUTTON, GtkToggleToolButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOGGLE_TOOL_BUTTON</NAME>
#define GTK_IS_TOGGLE_TOOL_BUTTON(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOGGLE_TOOL_BUTTON_CLASS</NAME>
#define GTK_IS_TOGGLE_TOOL_BUTTON_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOGGLE_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_TOGGLE_TOOL_BUTTON_GET_CLASS</NAME>
#define GTK_TOGGLE_TOOL_BUTTON_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOGGLE_TOOL_BUTTON, GtkToggleToolButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkToggleToolButton</NAME>
struct _GtkToggleToolButton
{
  GtkToolButton parent;

  /*< private >*/
  GtkToggleToolButtonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkToggleToolButtonClass</NAME>
struct _GtkToggleToolButtonClass
{
  GtkToolButtonClass parent_class;

  /*< public >*/

  /* signal */
  void (* toggled) (GtkToggleToolButton *button);

  /*< 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_toggle_tool_button_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_tool_button_new</NAME>
<RETURNS>GtkToolItem  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_tool_button_set_active</NAME>
<RETURNS>void          </RETURNS>
GtkToggleToolButton *button, gboolean             is_active
</FUNCTION>
<FUNCTION>
<NAME>gtk_toggle_tool_button_get_active</NAME>
<RETURNS>gboolean      </RETURNS>
GtkToggleToolButton *button
</FUNCTION>
<STRUCT>
<NAME>GtkToggleToolButtonPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOOLBAR</NAME>
#define GTK_TYPE_TOOLBAR            (gtk_toolbar_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOOLBAR</NAME>
#define GTK_TOOLBAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOLBAR, GtkToolbar))
</MACRO>
<MACRO>
<NAME>GTK_TOOLBAR_CLASS</NAME>
#define GTK_TOOLBAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLBAR, GtkToolbarClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOLBAR</NAME>
#define GTK_IS_TOOLBAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOLBAR))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOLBAR_CLASS</NAME>
#define GTK_IS_TOOLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLBAR))
</MACRO>
<MACRO>
<NAME>GTK_TOOLBAR_GET_CLASS</NAME>
#define GTK_TOOLBAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TOOLBAR, GtkToolbarClass))
</MACRO>
<STRUCT>
<NAME>GtkToolbar</NAME>
struct _GtkToolbar
{
  GtkContainer container;

  GtkToolbarPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkToolbarClass</NAME>
struct _GtkToolbarClass
{
  GtkContainerClass parent_class;

  /* signals */
  void     (* orientation_changed) (GtkToolbar       *toolbar,
				    GtkOrientation    orientation);
  void     (* style_changed)       (GtkToolbar       *toolbar,
				    GtkToolbarStyle   style);
  gboolean (* popup_context_menu)  (GtkToolbar       *toolbar,
				    gint              x,
				    gint              y,
				    gint              button_number);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_toolbar_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_new</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_insert</NAME>
<RETURNS>void             </RETURNS>
GtkToolbar      *toolbar, GtkToolItem     *item, gint             pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_get_item_index</NAME>
<RETURNS>gint             </RETURNS>
GtkToolbar      *toolbar, GtkToolItem     *item
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_get_n_items</NAME>
<RETURNS>gint             </RETURNS>
GtkToolbar      *toolbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_get_nth_item</NAME>
<RETURNS>GtkToolItem  *   </RETURNS>
GtkToolbar      *toolbar, gint             n
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_get_show_arrow</NAME>
<RETURNS>gboolean         </RETURNS>
GtkToolbar      *toolbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_set_show_arrow</NAME>
<RETURNS>void             </RETURNS>
GtkToolbar      *toolbar, gboolean         show_arrow
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_get_style</NAME>
<RETURNS>GtkToolbarStyle  </RETURNS>
GtkToolbar      *toolbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_set_style</NAME>
<RETURNS>void             </RETURNS>
GtkToolbar      *toolbar, GtkToolbarStyle  style
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_unset_style</NAME>
<RETURNS>void             </RETURNS>
GtkToolbar      *toolbar
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_get_drop_index</NAME>
<RETURNS>gint             </RETURNS>
GtkToolbar      *toolbar, gint             x, gint             y
</FUNCTION>
<FUNCTION>
<NAME>gtk_toolbar_set_drop_highlight_item</NAME>
<RETURNS>void             </RETURNS>
GtkToolbar      *toolbar, GtkToolItem     *tool_item, gint             index_
</FUNCTION>
<STRUCT>
<NAME>GtkToolbarPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOOL_BUTTON</NAME>
#define GTK_TYPE_TOOL_BUTTON            (gtk_tool_button_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOOL_BUTTON</NAME>
#define GTK_TOOL_BUTTON(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOL_BUTTON, GtkToolButton))
</MACRO>
<MACRO>
<NAME>GTK_TOOL_BUTTON_CLASS</NAME>
#define GTK_TOOL_BUTTON_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOL_BUTTON, GtkToolButtonClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOL_BUTTON</NAME>
#define GTK_IS_TOOL_BUTTON(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOL_BUTTON_CLASS</NAME>
#define GTK_IS_TOOL_BUTTON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOL_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_TOOL_BUTTON_GET_CLASS</NAME>
#define GTK_TOOL_BUTTON_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_TOOL_BUTTON, GtkToolButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkToolButton</NAME>
struct _GtkToolButton
{
  GtkToolItem parent;

  /*< private >*/
  GtkToolButtonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkToolButtonClass</NAME>
struct _GtkToolButtonClass
{
  GtkToolItemClass parent_class;

  GType button_type;

  /*< public >*/

  /* signal */
  void       (* clicked)             (GtkToolButton    *tool_item);

  /*< 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_tool_button_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_new</NAME>
<RETURNS>GtkToolItem  *</RETURNS>
GtkWidget   *icon_widget, const gchar *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_set_label</NAME>
<RETURNS>void                   </RETURNS>
GtkToolButton *button, const gchar   *label
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_get_label</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkToolButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_set_use_underline</NAME>
<RETURNS>void                   </RETURNS>
GtkToolButton *button, gboolean       use_underline
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_get_use_underline</NAME>
<RETURNS>gboolean               </RETURNS>
GtkToolButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_set_icon_name</NAME>
<RETURNS>void                   </RETURNS>
GtkToolButton *button, const gchar   *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_get_icon_name</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkToolButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_set_icon_widget</NAME>
<RETURNS>void                   </RETURNS>
GtkToolButton *button, GtkWidget     *icon_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_get_icon_widget</NAME>
<RETURNS>GtkWidget  *           </RETURNS>
GtkToolButton *button
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_set_label_widget</NAME>
<RETURNS>void                   </RETURNS>
GtkToolButton *button, GtkWidget     *label_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_button_get_label_widget</NAME>
<RETURNS>GtkWidget  *           </RETURNS>
GtkToolButton *button
</FUNCTION>
<STRUCT>
<NAME>GtkToolButtonPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOOL_ITEM</NAME>
#define GTK_TYPE_TOOL_ITEM            (gtk_tool_item_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOOL_ITEM</NAME>
#define GTK_TOOL_ITEM(o)              (G_TYPE_CHECK_INSTANCE_CAST ((o), GTK_TYPE_TOOL_ITEM, GtkToolItem))
</MACRO>
<MACRO>
<NAME>GTK_TOOL_ITEM_CLASS</NAME>
#define GTK_TOOL_ITEM_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOL_ITEM, GtkToolItemClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOL_ITEM</NAME>
#define GTK_IS_TOOL_ITEM(o)           (G_TYPE_CHECK_INSTANCE_TYPE ((o), GTK_TYPE_TOOL_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOL_ITEM_CLASS</NAME>
#define GTK_IS_TOOL_ITEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOL_ITEM))
</MACRO>
<MACRO>
<NAME>GTK_TOOL_ITEM_GET_CLASS</NAME>
#define GTK_TOOL_ITEM_GET_CLASS(o)    (G_TYPE_INSTANCE_GET_CLASS((o), GTK_TYPE_TOOL_ITEM, GtkToolItemClass))
</MACRO>
<STRUCT>
<NAME>GtkToolItem</NAME>
struct _GtkToolItem
{
  GtkBin parent;

  /*< private >*/
  GtkToolItemPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkToolItemClass</NAME>
struct _GtkToolItemClass
{
  GtkBinClass parent_class;

  /* signals */
  gboolean   (* create_menu_proxy)    (GtkToolItem *tool_item);
  void       (* toolbar_reconfigured) (GtkToolItem *tool_item);

  /*< 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_tool_item_get_type</NAME>
<RETURNS>GType         </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_new</NAME>
<RETURNS>GtkToolItem  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_homogeneous</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, gboolean     homogeneous
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_homogeneous</NAME>
<RETURNS>gboolean         </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_expand</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, gboolean     expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_expand</NAME>
<RETURNS>gboolean         </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_tooltip_text</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_tooltip_markup</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, const gchar *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_visible_horizontal</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, gboolean     visible_horizontal
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_visible_horizontal</NAME>
<RETURNS>gboolean         </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_visible_vertical</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, gboolean     visible_vertical
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_visible_vertical</NAME>
<RETURNS>gboolean         </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_is_important</NAME>
<RETURNS>gboolean         </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_is_important</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, gboolean     is_important
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_ellipsize_mode</NAME>
<RETURNS>PangoEllipsizeMode  </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_orientation</NAME>
<RETURNS>GtkOrientation   </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_toolbar_style</NAME>
<RETURNS>GtkToolbarStyle  </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_text_alignment</NAME>
<RETURNS>gfloat           </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_text_orientation</NAME>
<RETURNS>GtkOrientation   </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_text_size_group</NAME>
<RETURNS>GtkSizeGroup  *  </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_retrieve_proxy_menu_item</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_get_proxy_menu_item</NAME>
<RETURNS>GtkWidget  *     </RETURNS>
GtkToolItem *tool_item, const gchar *menu_item_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_set_proxy_menu_item</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item, const gchar *menu_item_id, GtkWidget   *menu_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_rebuild_menu</NAME>
<RETURNS>void 		</RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_item_toolbar_reconfigured</NAME>
<RETURNS>void             </RETURNS>
GtkToolItem *tool_item
</FUNCTION>
<STRUCT>
<NAME>GtkToolItemPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOOL_SHELL</NAME>
#define GTK_TYPE_TOOL_SHELL            (gtk_tool_shell_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOOL_SHELL</NAME>
#define GTK_TOOL_SHELL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOL_SHELL, GtkToolShell))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOL_SHELL</NAME>
#define GTK_IS_TOOL_SHELL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOL_SHELL))
</MACRO>
<MACRO>
<NAME>GTK_TOOL_SHELL_GET_IFACE</NAME>
#define GTK_TOOL_SHELL_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TOOL_SHELL, GtkToolShellIface))
</MACRO>
<STRUCT>
<NAME>GtkToolShellIface</NAME>
struct _GtkToolShellIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/
  GtkOrientation     (*get_orientation)      (GtkToolShell *shell);
  GtkToolbarStyle    (*get_style)            (GtkToolShell *shell);
  void               (*rebuild_menu)         (GtkToolShell *shell);
  GtkOrientation     (*get_text_orientation) (GtkToolShell *shell);
  gfloat             (*get_text_alignment)   (GtkToolShell *shell);
  PangoEllipsizeMode (*get_ellipsize_mode)   (GtkToolShell *shell);
  GtkSizeGroup *     (*get_text_size_group)  (GtkToolShell *shell);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tool_shell_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_shell_get_orientation</NAME>
<RETURNS>GtkOrientation      </RETURNS>
GtkToolShell *shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_shell_get_style</NAME>
<RETURNS>GtkToolbarStyle     </RETURNS>
GtkToolShell *shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_shell_rebuild_menu</NAME>
<RETURNS>void                </RETURNS>
GtkToolShell *shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_shell_get_text_orientation</NAME>
<RETURNS>GtkOrientation      </RETURNS>
GtkToolShell *shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_shell_get_text_alignment</NAME>
<RETURNS>gfloat              </RETURNS>
GtkToolShell *shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_shell_get_ellipsize_mode</NAME>
<RETURNS>PangoEllipsizeMode  </RETURNS>
GtkToolShell *shell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tool_shell_get_text_size_group</NAME>
<RETURNS>GtkSizeGroup  *     </RETURNS>
GtkToolShell *shell
</FUNCTION>
<STRUCT>
<NAME>GtkToolShell</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TOOLTIP</NAME>
#define GTK_TYPE_TOOLTIP                 (gtk_tooltip_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TOOLTIP</NAME>
#define GTK_TOOLTIP(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TOOLTIP, GtkTooltip))
</MACRO>
<MACRO>
<NAME>GTK_IS_TOOLTIP</NAME>
#define GTK_IS_TOOLTIP(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TOOLTIP))
</MACRO>
<FUNCTION>
<NAME>gtk_tooltip_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_markup</NAME>
<RETURNS>void  </RETURNS>
GtkTooltip         *tooltip, const gchar        *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_text</NAME>
<RETURNS>void  </RETURNS>
GtkTooltip         *tooltip, const gchar        *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_icon</NAME>
<RETURNS>void  </RETURNS>
GtkTooltip         *tooltip, GdkPaintable       *paintable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_icon_from_icon_name</NAME>
<RETURNS>void  </RETURNS>
GtkTooltip         *tooltip, const gchar        *icon_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_icon_from_gicon</NAME>
<RETURNS>void  </RETURNS>
GtkTooltip         *tooltip, GIcon              *gicon
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_custom</NAME>
<RETURNS>void  </RETURNS>
GtkTooltip         *tooltip, GtkWidget          *custom_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_tooltip_set_tip_area</NAME>
<RETURNS>void  </RETURNS>
GtkTooltip         *tooltip, const GdkRectangle *rect
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_TRASH_MONITOR</NAME>
#define GTK_TYPE_TRASH_MONITOR			(_gtk_trash_monitor_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TRASH_MONITOR</NAME>
#define GTK_TRASH_MONITOR(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TRASH_MONITOR, GtkTrashMonitor))
</MACRO>
<MACRO>
<NAME>GTK_TRASH_MONITOR_CLASS</NAME>
#define GTK_TRASH_MONITOR_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TRASH_MONITOR, GtkTrashMonitorClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TRASH_MONITOR</NAME>
#define GTK_IS_TRASH_MONITOR(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TRASH_MONITOR))
</MACRO>
<MACRO>
<NAME>GTK_IS_TRASH_MONITOR_CLASS</NAME>
#define GTK_IS_TRASH_MONITOR_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TRASH_MONITOR))
</MACRO>
<MACRO>
<NAME>GTK_TRASH_MONITOR_GET_CLASS</NAME>
#define GTK_TRASH_MONITOR_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TRASH_MONITOR, GtkTrashMonitorClass))
</MACRO>
<STRUCT>
<NAME>GtkTrashMonitor</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTrashMonitorClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeDataList</NAME>
struct _GtkTreeDataList
{
  GtkTreeDataList *next;

  union {
    gint	   v_int;
    gint8          v_char;
    guint8         v_uchar;
    guint	   v_uint;
    glong	   v_long;
    gulong	   v_ulong;
    gint64	   v_int64;
    guint64        v_uint64;
    gfloat	   v_float;
    gdouble        v_double;
    gpointer	   v_pointer;
  } data;
};
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_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);

  gboolean     (* drag_data_get)        (GtkTreeDragSource   *drag_source,
                                         GtkTreePath         *path,
                                         GtkSelectionData    *selection_data);

  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>gboolean  </RETURNS>
GtkTreeDragSource *drag_source, GtkTreePath       *path, GtkSelectionData  *selection_data
</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,
                                       GtkSelectionData  *selection_data);

  gboolean     (* row_drop_possible)  (GtkTreeDragDest   *drag_dest,
                                       GtkTreePath       *dest_path,
				       GtkSelectionData  *selection_data);
};
</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, GtkSelectionData  *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_drag_dest_row_drop_possible</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTreeDragDest   *drag_dest, GtkTreePath       *dest_path, GtkSelectionData  *selection_data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_set_row_drag_data</NAME>
<RETURNS>gboolean  </RETURNS>
GtkSelectionData  *selection_data, GtkTreeModel      *tree_model, GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_get_row_drag_data</NAME>
<RETURNS>gboolean  </RETURNS>
GtkSelectionData  *selection_data, GtkTreeModel     **tree_model, GtkTreePath      **path
</FUNCTION>
<STRUCT>
<NAME>GtkTreeDragDest</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeDragSource</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_LIST_MODEL</NAME>
#define GTK_TYPE_TREE_LIST_MODEL (gtk_tree_list_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_LIST_ROW</NAME>
#define GTK_TYPE_TREE_LIST_ROW (gtk_tree_list_row_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeListModelCreateModelFunc</NAME>
<RETURNS>GListModel *</RETURNS>
gpointer item, gpointer user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_new</NAME>
<RETURNS>GtkTreeListModel  *      </RETURNS>
gboolean                passthrough, GListModel             *root, gboolean                autoexpand, GtkTreeListModelCreateModelFunc create_func, gpointer                user_data, GDestroyNotify          user_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_model</NAME>
<RETURNS>GListModel  *            </RETURNS>
GtkTreeListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_passthrough</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_set_autoexpand</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeListModel       *self, gboolean                autoexpand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_autoexpand</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeListModel       *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_child_row</NAME>
<RETURNS>GtkTreeListRow  *        </RETURNS>
GtkTreeListModel       *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_model_get_row</NAME>
<RETURNS>GtkTreeListRow  *        </RETURNS>
GtkTreeListModel       *self, guint                   position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_item</NAME>
<RETURNS>gpointer                 </RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_set_expanded</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeListRow         *self, gboolean                expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_expanded</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_is_expandable</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_position</NAME>
<RETURNS>guint                    </RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_depth</NAME>
<RETURNS>guint                    </RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_children</NAME>
<RETURNS>GListModel  *            </RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_parent</NAME>
<RETURNS>GtkTreeListRow  *        </RETURNS>
GtkTreeListRow         *self
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_list_row_get_child_row</NAME>
<RETURNS>GtkTreeListRow  *        </RETURNS>
GtkTreeListRow         *self, guint                   position
</FUNCTION>
<STRUCT>
<NAME>GtkTreeListModel</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeListRow</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_MENU</NAME>
#define GTK_TYPE_TREE_MENU		  (_gtk_tree_menu_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_MENU</NAME>
#define GTK_TREE_MENU(obj)		  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MENU, GtkTreeMenu))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MENU_CLASS</NAME>
#define GTK_TREE_MENU_CLASS(klass)	  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_MENU, GtkTreeMenuClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MENU</NAME>
#define GTK_IS_TREE_MENU(obj)	  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MENU))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MENU_CLASS</NAME>
#define GTK_IS_TREE_MENU_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_MENU))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MENU_GET_CLASS</NAME>
#define GTK_TREE_MENU_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_MENU, GtkTreeMenuClass))
</MACRO>
<STRUCT>
<NAME>GtkTreeMenu</NAME>
struct _GtkTreeMenu
{
  GtkMenu parent_instance;

  /*< private >*/
  GtkTreeMenuPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeMenuClass</NAME>
struct _GtkTreeMenuClass
{
  GtkMenuClass parent_class;

  /*< 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>
<STRUCT>
<NAME>GtkTreeMenuPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_MODEL</NAME>
#define GTK_TYPE_TREE_MODEL            (gtk_tree_model_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL</NAME>
#define GTK_TREE_MODEL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_MODEL, GtkTreeModel))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_MODEL</NAME>
#define GTK_IS_TREE_MODEL(obj)	       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_MODEL))
</MACRO>
<MACRO>
<NAME>GTK_TREE_MODEL_GET_IFACE</NAME>
#define GTK_TREE_MODEL_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_MODEL, GtkTreeModelIface))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_ITER</NAME>
#define GTK_TYPE_TREE_ITER             (gtk_tree_iter_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_PATH</NAME>
#define GTK_TYPE_TREE_PATH             (gtk_tree_path_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_ROW_REFERENCE</NAME>
#define GTK_TYPE_TREE_ROW_REFERENCE    (gtk_tree_row_reference_get_type ())
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeModelForeachFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data
</USER_FUNCTION>
<ENUM>
<NAME>GtkTreeModelFlags</NAME>
typedef enum
{
  GTK_TREE_MODEL_ITERS_PERSIST = 1 << 0,
  GTK_TREE_MODEL_LIST_ONLY = 1 << 1
} GtkTreeModelFlags;
</ENUM>
<STRUCT>
<NAME>GtkTreeIter</NAME>
struct _GtkTreeIter
{
  gint stamp;
  gpointer user_data;
  gpointer user_data2;
  gpointer user_data3;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeModelIface</NAME>
struct _GtkTreeModelIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

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

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

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

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

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

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</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>
<ENUM>
<NAME>GtkTreeRBNodeColor</NAME>
typedef enum
{
  GTK_TREE_RBNODE_BLACK = 1 << 0,
  GTK_TREE_RBNODE_RED = 1 << 1,
  GTK_TREE_RBNODE_IS_PARENT = 1 << 2,
  GTK_TREE_RBNODE_IS_SELECTED = 1 << 3,
  GTK_TREE_RBNODE_IS_PRELIT = 1 << 4,
  GTK_TREE_RBNODE_INVALID = 1 << 7,
  GTK_TREE_RBNODE_COLUMN_INVALID = 1 << 8,
  GTK_TREE_RBNODE_DESCENDANTS_INVALID = 1 << 9,
  GTK_TREE_RBNODE_NON_COLORS = GTK_TREE_RBNODE_IS_PARENT |
                            GTK_TREE_RBNODE_IS_SELECTED |
                            GTK_TREE_RBNODE_IS_PRELIT |
                          GTK_TREE_RBNODE_INVALID |
                          GTK_TREE_RBNODE_COLUMN_INVALID |
                          GTK_TREE_RBNODE_DESCENDANTS_INVALID
} GtkTreeRBNodeColor;
</ENUM>
<USER_FUNCTION>
<NAME>GtkTreeRBTreeTraverseFunc</NAME>
<RETURNS>void </RETURNS>
GtkTreeRBTree  *tree,
                                       GtkTreeRBNode  *node,
                                       gpointer  data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTreeRBTree</NAME>
struct _GtkTreeRBTree
{
  GtkTreeRBNode *root;
  GtkTreeRBTree *parent_tree;
  GtkTreeRBNode *parent_node;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeRBNode</NAME>
struct _GtkTreeRBNode
{
  guint flags : 14;

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

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

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

  /* Child trees */
  GtkTreeRBTree *children;
};
</STRUCT>
<MACRO>
<NAME>GTK_TREE_RBNODE_GET_COLOR</NAME>
#define GTK_TREE_RBNODE_GET_COLOR(node)                (node?(((node->flags&GTK_TREE_RBNODE_RED)==GTK_TREE_RBNODE_RED)?GTK_TREE_RBNODE_RED:GTK_TREE_RBNODE_BLACK):GTK_TREE_RBNODE_BLACK)
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_SET_COLOR</NAME>
#define GTK_TREE_RBNODE_SET_COLOR(node,color)         if((node->flags&color)!=color)node->flags=node->flags^(GTK_TREE_RBNODE_RED|GTK_TREE_RBNODE_BLACK)
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_GET_HEIGHT</NAME>
#define GTK_TREE_RBNODE_GET_HEIGHT(node)                 (node->offset-(node->left->offset+node->right->offset+(node->children?node->children->root->offset:0)))
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_SET_FLAG</NAME>
#define GTK_TREE_RBNODE_SET_FLAG(node, flag)           G_STMT_START{ (node->flags|=flag); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_UNSET_FLAG</NAME>
#define GTK_TREE_RBNODE_UNSET_FLAG(node, flag)         G_STMT_START{ (node->flags&=~(flag)); }G_STMT_END
</MACRO>
<MACRO>
<NAME>GTK_TREE_RBNODE_FLAG_SET</NAME>
#define GTK_TREE_RBNODE_FLAG_SET(node, flag)         (node?(((node->flags&flag)==flag)?TRUE:FALSE):FALSE)
</MACRO>
<FUNCTION>
<NAME>gtk_tree_rbtree_new</NAME>
<RETURNS>GtkTreeRBTree  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_free</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_remove</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_destroy</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_insert_before</NAME>
<RETURNS>GtkTreeRBNode  * </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, gint                           height, gboolean                       valid
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_insert_after</NAME>
<RETURNS>GtkTreeRBNode  * </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, gint                           height, gboolean                       valid
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_remove_node</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_is_nil</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_reorder</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, gint                          *new_order, gint                           length
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_contains</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBTree                 *potential_child
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_find_count</NAME>
<RETURNS>GtkTreeRBNode  * </RETURNS>
GtkTreeRBTree                 *tree, gint                           count
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_set_height</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, gint                           height
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_mark_invalid</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_mark_valid</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_column_invalid</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_mark_invalid</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_set_fixed_height</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, gint                           height, gboolean                       mark_valid
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_find_offset</NAME>
<RETURNS>gint             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_node_get_index</NAME>
<RETURNS>guint            </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_find_index</NAME>
<RETURNS>gboolean         </RETURNS>
GtkTreeRBTree                 *tree, guint                          index, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_find_offset</NAME>
<RETURNS>gint             </RETURNS>
GtkTreeRBTree                 *tree, gint                           offset, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_traverse</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, GTraverseType                  order, GtkTreeRBTreeTraverseFunc      func, gpointer                       data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_first</NAME>
<RETURNS>GtkTreeRBNode  * </RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_next</NAME>
<RETURNS>GtkTreeRBNode  * </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_prev</NAME>
<RETURNS>GtkTreeRBNode  * </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_next_full</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_prev_full</NAME>
<RETURNS>void             </RETURNS>
GtkTreeRBTree                 *tree, GtkTreeRBNode                 *node, GtkTreeRBTree                **new_tree, GtkTreeRBNode                **new_node
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_rbtree_get_depth</NAME>
<RETURNS>gint             </RETURNS>
GtkTreeRBTree                 *tree
</FUNCTION>
<STRUCT>
<NAME>GtkTreeRBTreeView</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_SELECTION</NAME>
#define GTK_TYPE_TREE_SELECTION			(gtk_tree_selection_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_SELECTION</NAME>
#define GTK_TREE_SELECTION(obj)			(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_SELECTION, GtkTreeSelection))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SELECTION_CLASS</NAME>
#define GTK_TREE_SELECTION_CLASS(klass)		(G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_SELECTION, GtkTreeSelectionClass))
</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>
<MACRO>
<NAME>GTK_IS_TREE_SELECTION_CLASS</NAME>
#define GTK_IS_TREE_SELECTION_CLASS(klass)	(G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_SELECTION))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SELECTION_GET_CLASS</NAME>
#define GTK_TREE_SELECTION_GET_CLASS(obj)	(G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_SELECTION, GtkTreeSelectionClass))
</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>
<STRUCT>
<NAME>GtkTreeSelection</NAME>
struct _GtkTreeSelection
{
  /*< private >*/
  GObject parent;

  GtkTreeSelectionPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeSelectionClass</NAME>
struct _GtkTreeSelectionClass
{
  GObjectClass parent_class;

  /*< public >*/

  void (* changed) (GtkTreeSelection *selection);

  /*< 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_tree_selection_get_type</NAME>
<RETURNS>GType             </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_set_mode</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkSelectionMode             type
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_mode</NAME>
<RETURNS>GtkSelectionMode  </RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_set_select_function</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreeSelectionFunc         func, gpointer                     data, GDestroyNotify               destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_user_data</NAME>
<RETURNS>gpointer          </RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_tree_view</NAME>
<RETURNS>GtkTreeView *     </RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_select_function</NAME>
<RETURNS>GtkTreeSelectionFunc  </RETURNS>
GtkTreeSelection        *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_selected</NAME>
<RETURNS>gboolean          </RETURNS>
GtkTreeSelection            *selection, GtkTreeModel               **model, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_get_selected_rows</NAME>
<RETURNS>GList  *          </RETURNS>
GtkTreeSelection            *selection, GtkTreeModel               **model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_count_selected_rows</NAME>
<RETURNS>gint              </RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_selected_foreach</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreeSelectionForeachFunc  func, gpointer                     data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_path</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_path</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_iter</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_iter</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_path_is_selected</NAME>
<RETURNS>gboolean          </RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_iter_is_selected</NAME>
<RETURNS>gboolean          </RETURNS>
GtkTreeSelection            *selection, GtkTreeIter                 *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_all</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_all</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_select_range</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *start_path, GtkTreePath                 *end_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_selection_unselect_range</NAME>
<RETURNS>void              </RETURNS>
GtkTreeSelection            *selection, GtkTreePath                 *start_path, GtkTreePath                 *end_path
</FUNCTION>
<STRUCT>
<NAME>GtkTreeSelectionPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_TREE_SORTABLE</NAME>
#define GTK_TYPE_TREE_SORTABLE            (gtk_tree_sortable_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE</NAME>
#define GTK_TREE_SORTABLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_SORTABLE, GtkTreeSortable))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_CLASS</NAME>
#define GTK_TREE_SORTABLE_CLASS(obj)      (G_TYPE_CHECK_CLASS_CAST ((obj), GTK_TYPE_TREE_SORTABLE, GtkTreeSortableIface))
</MACRO>
<MACRO>
<NAME>GTK_IS_TREE_SORTABLE</NAME>
#define GTK_IS_TREE_SORTABLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_SORTABLE))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_GET_IFACE</NAME>
#define GTK_TREE_SORTABLE_GET_IFACE(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GTK_TYPE_TREE_SORTABLE, GtkTreeSortableIface))
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID</NAME>
#define GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID (-1)
</MACRO>
<MACRO>
<NAME>GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID</NAME>
#define GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID (-2)
</MACRO>
<USER_FUNCTION>
<NAME>GtkTreeIterCompareFunc</NAME>
<RETURNS>gint </RETURNS>
GtkTreeModel *model,
					 GtkTreeIter  *a,
					 GtkTreeIter  *b,
					 gpointer      user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkTreeSortableIface</NAME>
struct _GtkTreeSortableIface
{
  /*< private >*/
  GTypeInterface g_iface;

  /*< public >*/

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

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

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

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_store_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_new</NAME>
<RETURNS>GtkTreeStore  *</RETURNS>
gint          n_columns, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_newv</NAME>
<RETURNS>GtkTreeStore  *</RETURNS>
gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_column_types</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, gint          n_columns, GType        *types
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_value</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, gint          column, GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_valuesv</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_set_valist</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, va_list       var_args
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_remove</NAME>
<RETURNS>gboolean       </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, gint          position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_before</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_after</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, GtkTreeIter  *sibling
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_with_values</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, gint          position, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_insert_with_valuesv</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent, gint          position, gint         *columns, GValue       *values, gint          n_values
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_prepend</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_append</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *parent
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_is_ancestor</NAME>
<RETURNS>gboolean       </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *descendant
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_iter_depth</NAME>
<RETURNS>gint           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_clear</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_iter_is_valid</NAME>
<RETURNS>gboolean       </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_reorder</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *parent, gint         *new_order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_swap</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *a, GtkTreeIter  *b
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_move_before</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_store_move_after</NAME>
<RETURNS>void           </RETURNS>
GtkTreeStore *tree_store, GtkTreeIter  *iter, GtkTreeIter  *position
</FUNCTION>
<STRUCT>
<NAME>GtkTreeStorePrivate</NAME>
</STRUCT>
<ENUM>
<NAME>GtkTreeViewDropPosition</NAME>
typedef enum
{
  /* drop before/after this row */
  GTK_TREE_VIEW_DROP_BEFORE,
  GTK_TREE_VIEW_DROP_AFTER,
  /* drop as a child of this row (with fallback to before or after
   * if into is not possible)
   */
  GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
  GTK_TREE_VIEW_DROP_INTO_OR_AFTER
} GtkTreeViewDropPosition;
</ENUM>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW</NAME>
#define GTK_TYPE_TREE_VIEW		(gtk_tree_view_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW</NAME>
#define GTK_TREE_VIEW(obj)		(G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_VIEW, GtkTreeView))
</MACRO>
<MACRO>
<NAME>GTK_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</NAME>
#define GTK_IS_TREE_VIEW(obj)		(G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_VIEW))
</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>
<STRUCT>
<NAME>GtkTreeView</NAME>
struct _GtkTreeView
{
  GtkContainer parent;

  /*< private >*/
  GtkTreeViewPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeViewClass</NAME>
struct _GtkTreeViewClass
{
  GtkContainerClass 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,
				           gint               count);
  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);

  /* 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>
<USER_FUNCTION>
<NAME>GtkTreeViewColumnDropFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkTreeView             *tree_view,
						GtkTreeViewColumn       *column,
						GtkTreeViewColumn       *prev_column,
						GtkTreeViewColumn       *next_column,
						gpointer                 data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewMappingFunc</NAME>
<RETURNS>void </RETURNS>
GtkTreeView             *tree_view,
						GtkTreePath             *path,
						gpointer                 user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewSearchEqualFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkTreeModel            *model,
						gint                     column,
						const gchar             *key,
						GtkTreeIter             *iter,
						gpointer                 search_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewRowSeparatorFunc</NAME>
<RETURNS>gboolean </RETURNS>
GtkTreeModel      *model,
						 GtkTreeIter       *iter,
						 gpointer           data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTreeViewSearchPositionFunc</NAME>
<RETURNS>void </RETURNS>
GtkTreeView  *tree_view,
						   GtkWidget    *search_dialog,
						   gpointer      user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_type</NAME>
<RETURNS>GType                   </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_new</NAME>
<RETURNS>GtkWidget              *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_new_with_model</NAME>
<RETURNS>GtkWidget              *</RETURNS>
GtkTreeModel              *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_model</NAME>
<RETURNS>GtkTreeModel           *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_model</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeModel              *model
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_selection</NAME>
<RETURNS>GtkTreeSelection       *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_headers_visible</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_headers_visible</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, gboolean                   headers_visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_columns_autosize</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_headers_clickable</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_headers_clickable</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, gboolean                   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_activate_on_single_click</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_activate_on_single_click</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, gboolean                   single
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_append_column</NAME>
<RETURNS>gint                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_remove_column</NAME>
<RETURNS>gint                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column</NAME>
<RETURNS>gint                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column, gint                       position
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column_with_attributes</NAME>
<RETURNS>gint                    </RETURNS>
GtkTreeView               *tree_view, gint                       position, const gchar               *title, GtkCellRenderer           *cell, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_insert_column_with_data_func</NAME>
<RETURNS>gint                    </RETURNS>
GtkTreeView               *tree_view, gint                       position, const gchar               *title, GtkCellRenderer           *cell, GtkTreeCellDataFunc        func, gpointer                   data, GDestroyNotify             dnotify
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_n_columns</NAME>
<RETURNS>guint                   </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_column</NAME>
<RETURNS>GtkTreeViewColumn      *</RETURNS>
GtkTreeView               *tree_view, gint                       n
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_columns</NAME>
<RETURNS>GList                  *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_move_column_after</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column, GtkTreeViewColumn         *base_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_expander_column</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_expander_column</NAME>
<RETURNS>GtkTreeViewColumn      *</RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_column_drag_function</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeViewColumnDropFunc  func, gpointer                   user_data, GDestroyNotify             destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_scroll_to_point</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, gint                       tree_x, gint                       tree_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_scroll_to_cell</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column, gboolean                   use_align, gfloat                     row_align, gfloat                     col_align
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_row_activated</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_expand_all</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_collapse_all</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_expand_to_path</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_expand_row</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, gboolean                   open_all
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_collapse_row</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_map_expanded_rows</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreeViewMappingFunc     func, gpointer                   data
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_row_expanded</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_reorderable</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, gboolean                   reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_reorderable</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_cursor</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *focus_column, gboolean                   start_editing
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_cursor_on_cell</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *focus_column, GtkCellRenderer           *focus_cell, gboolean                   start_editing
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_cursor</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath              **path, GtkTreeViewColumn        **focus_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_path_at_pos</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view, gint                       x, gint                       y, GtkTreePath              **path, GtkTreeViewColumn        **column, gint                      *cell_x, gint                      *cell_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_cell_area</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column, GdkRectangle              *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_background_area</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewColumn         *column, GdkRectangle              *rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_visible_rect</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GdkRectangle              *visible_rect
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_visible_range</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view, GtkTreePath              **start_path, GtkTreePath              **end_path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_is_blank_at_pos</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view, gint                       x, gint                       y, GtkTreePath              **path, GtkTreeViewColumn        **column, gint                      *cell_x, gint                      *cell_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_enable_model_drag_source</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GdkModifierType            start_button_mask, GdkContentFormats         *formats, GdkDragAction              actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_enable_model_drag_dest</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GdkContentFormats         *formats, GdkDragAction              actions
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_unset_rows_drag_source</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_unset_rows_drag_dest</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_drag_dest_row</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path, GtkTreeViewDropPosition    pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_drag_dest_row</NAME>
<RETURNS>void                    </RETURNS>
GtkTreeView               *tree_view, GtkTreePath              **path, GtkTreeViewDropPosition   *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_dest_row_at_pos</NAME>
<RETURNS>gboolean                </RETURNS>
GtkTreeView               *tree_view, gint                       drag_x, gint                       drag_y, GtkTreePath              **path, GtkTreeViewDropPosition   *pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_create_row_drag_icon</NAME>
<RETURNS>GdkPaintable           *</RETURNS>
GtkTreeView               *tree_view, GtkTreePath               *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_enable_search</NAME>
<RETURNS>void                        </RETURNS>
GtkTreeView                *tree_view, gboolean                    enable_search
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_enable_search</NAME>
<RETURNS>gboolean                    </RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_search_column</NAME>
<RETURNS>gint                        </RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_column</NAME>
<RETURNS>void                        </RETURNS>
GtkTreeView                *tree_view, gint                        column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_search_equal_func</NAME>
<RETURNS>GtkTreeViewSearchEqualFunc  </RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_equal_func</NAME>
<RETURNS>void                        </RETURNS>
GtkTreeView                *tree_view, GtkTreeViewSearchEqualFunc  search_equal_func, gpointer                    search_user_data, GDestroyNotify              search_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_search_entry</NAME>
<RETURNS>GtkEditable                   *</RETURNS>
GtkTreeView                   *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_entry</NAME>
<RETURNS>void                           </RETURNS>
GtkTreeView                   *tree_view, GtkEditable                   *entry
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_search_position_func</NAME>
<RETURNS>GtkTreeViewSearchPositionFunc  </RETURNS>
GtkTreeView                   *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_search_position_func</NAME>
<RETURNS>void                           </RETURNS>
GtkTreeView                   *tree_view, GtkTreeViewSearchPositionFunc  func, gpointer                       data, GDestroyNotify                 destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_widget_to_tree_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTreeView *tree_view, gint         wx, gint         wy, gint        *tx, gint        *ty
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_tree_to_widget_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTreeView *tree_view, gint         tx, gint         ty, gint        *wx, gint        *wy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_widget_to_bin_window_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTreeView *tree_view, gint         wx, gint         wy, gint        *bx, gint        *by
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_bin_window_to_widget_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTreeView *tree_view, gint         bx, gint         by, gint        *wx, gint        *wy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_tree_to_bin_window_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTreeView *tree_view, gint         tx, gint         ty, gint        *bx, gint        *by
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_convert_bin_window_to_tree_coords</NAME>
<RETURNS>void  </RETURNS>
GtkTreeView *tree_view, gint         bx, gint         by, gint        *tx, gint        *ty
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_fixed_height_mode</NAME>
<RETURNS>void      </RETURNS>
GtkTreeView          *tree_view, gboolean              enable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_fixed_height_mode</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_hover_selection</NAME>
<RETURNS>void      </RETURNS>
GtkTreeView          *tree_view, gboolean              hover
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_hover_selection</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_hover_expand</NAME>
<RETURNS>void      </RETURNS>
GtkTreeView          *tree_view, gboolean              expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_hover_expand</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_rubber_banding</NAME>
<RETURNS>void      </RETURNS>
GtkTreeView          *tree_view, gboolean              enable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_rubber_banding</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTreeView          *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_is_rubber_banding_active</NAME>
<RETURNS>gboolean  </RETURNS>
GtkTreeView       *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_row_separator_func</NAME>
<RETURNS>GtkTreeViewRowSeparatorFunc  </RETURNS>
GtkTreeView               *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_row_separator_func</NAME>
<RETURNS>void                         </RETURNS>
GtkTreeView                *tree_view, GtkTreeViewRowSeparatorFunc func, gpointer                    data, GDestroyNotify              destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_grid_lines</NAME>
<RETURNS>GtkTreeViewGridLines         </RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_grid_lines</NAME>
<RETURNS>void                         </RETURNS>
GtkTreeView                *tree_view, GtkTreeViewGridLines        grid_lines
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_enable_tree_lines</NAME>
<RETURNS>gboolean                     </RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_enable_tree_lines</NAME>
<RETURNS>void                         </RETURNS>
GtkTreeView                *tree_view, gboolean                    enabled
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_show_expanders</NAME>
<RETURNS>void                         </RETURNS>
GtkTreeView                *tree_view, gboolean                    enabled
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_show_expanders</NAME>
<RETURNS>gboolean                     </RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_level_indentation</NAME>
<RETURNS>void                         </RETURNS>
GtkTreeView                *tree_view, gint                        indentation
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_level_indentation</NAME>
<RETURNS>gint                         </RETURNS>
GtkTreeView                *tree_view
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_tooltip_row</NAME>
<RETURNS>void           </RETURNS>
GtkTreeView       *tree_view, GtkTooltip        *tooltip, GtkTreePath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_tooltip_cell</NAME>
<RETURNS>void           </RETURNS>
GtkTreeView       *tree_view, GtkTooltip        *tooltip, GtkTreePath       *path, GtkTreeViewColumn *column, GtkCellRenderer   *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_tooltip_context</NAME>
<RETURNS>gboolean       </RETURNS>
GtkTreeView       *tree_view, gint              *x, gint              *y, gboolean           keyboard_tip, GtkTreeModel     **model, GtkTreePath      **path, GtkTreeIter       *iter
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_set_tooltip_column</NAME>
<RETURNS>void           </RETURNS>
GtkTreeView       *tree_view, gint               column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_get_tooltip_column</NAME>
<RETURNS>gint           </RETURNS>
GtkTreeView       *tree_view
</FUNCTION>
<STRUCT>
<NAME>GtkTreeSelection</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeSelectionClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTreeViewPrivate</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_TREE_VIEW_COLUMN_CLASS</NAME>
#define GTK_TREE_VIEW_COLUMN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TREE_VIEW_COLUMN, GtkTreeViewColumnClass))
</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>
<MACRO>
<NAME>GTK_IS_TREE_VIEW_COLUMN_CLASS</NAME>
#define GTK_IS_TREE_VIEW_COLUMN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TREE_VIEW_COLUMN))
</MACRO>
<MACRO>
<NAME>GTK_TREE_VIEW_COLUMN_GET_CLASS</NAME>
#define GTK_TREE_VIEW_COLUMN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TREE_VIEW_COLUMN, GtkTreeViewColumnClass))
</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>
<STRUCT>
<NAME>GtkTreeViewColumn</NAME>
struct _GtkTreeViewColumn
{
  GInitiallyUnowned parent_instance;

  GtkTreeViewColumnPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkTreeViewColumnClass</NAME>
struct _GtkTreeViewColumnClass
{
  GInitiallyUnownedClass parent_class;

  void (*clicked) (GtkTreeViewColumn *tree_column);

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
  void (*_gtk_reserved4) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_tree_view_column_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_new</NAME>
<RETURNS>GtkTreeViewColumn       *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_new_with_area</NAME>
<RETURNS>GtkTreeViewColumn       *</RETURNS>
GtkCellArea             *area
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_new_with_attributes</NAME>
<RETURNS>GtkTreeViewColumn       *</RETURNS>
const gchar             *title, GtkCellRenderer         *cell, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_pack_start</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell, gboolean                 expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_pack_end</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell, gboolean                 expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_clear</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_add_attribute</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, const gchar             *attribute, gint                     column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_attributes</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_cell_data_func</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, GtkTreeCellDataFunc      func, gpointer                 func_data, GDestroyNotify           destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_clear_attributes</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_spacing</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gint                     spacing
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_spacing</NAME>
<RETURNS>gint                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_visible</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_visible</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_resizable</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 resizable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_resizable</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sizing</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkTreeViewColumnSizing  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sizing</NAME>
<RETURNS>GtkTreeViewColumnSizing  </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_x_offset</NAME>
<RETURNS>gint                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_width</NAME>
<RETURNS>gint                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_fixed_width</NAME>
<RETURNS>gint                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_fixed_width</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gint                     fixed_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_min_width</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gint                     min_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_min_width</NAME>
<RETURNS>gint                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_max_width</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gint                     max_width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_max_width</NAME>
<RETURNS>gint                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_clicked</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_title</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, const gchar             *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_title</NAME>
<RETURNS>const gchar  *           </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_expand</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_expand</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_clickable</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 clickable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_clickable</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_widget</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkWidget               *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_widget</NAME>
<RETURNS>GtkWidget               *</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_alignment</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gfloat                   xalign
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_alignment</NAME>
<RETURNS>gfloat                   </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_reorderable</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 reorderable
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_reorderable</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sort_column_id</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gint                     sort_column_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sort_column_id</NAME>
<RETURNS>gint                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sort_indicator</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, gboolean                 setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sort_indicator</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_set_sort_order</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkSortType              order
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_sort_order</NAME>
<RETURNS>GtkSortType              </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_set_cell_data</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkTreeModel            *tree_model, GtkTreeIter             *iter, gboolean                 is_expander, gboolean                 is_expanded
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_get_size</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, const GdkRectangle      *cell_area, gint                    *x_offset, gint                    *y_offset, gint                    *width, gint                    *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_is_visible</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_focus_cell</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_cell_get_position</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkTreeViewColumn       *tree_column, GtkCellRenderer         *cell_renderer, gint                    *x_offset, gint                    *width
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_queue_resize</NAME>
<RETURNS>void                     </RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_tree_view</NAME>
<RETURNS>GtkWidget               *</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<FUNCTION>
<NAME>gtk_tree_view_column_get_button</NAME>
<RETURNS>GtkWidget               *</RETURNS>
GtkTreeViewColumn       *tree_column
</FUNCTION>
<STRUCT>
<NAME>GtkTreeViewColumnPrivate</NAME>
</STRUCT>
<TYPEDEF>
<NAME>GtkSnapshot</NAME>
typedef GdkSnapshot                    GtkSnapshot;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GtkRcPropertyParser</NAME>
<RETURNS>gboolean </RETURNS>
const GParamSpec *pspec,
                                         const GString    *rc_string,
                                         GValue           *property_value
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkBuilderConnectFunc</NAME>
<RETURNS>void </RETURNS>
GtkBuilder    *builder,
				       GObject       *object,
				       const gchar   *signal_name,
				       const gchar   *handler_name,
				       GObject       *connect_object,
				       GConnectFlags  flags,
				       gpointer       user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkAdjustment</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkBuilder</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkClipboard</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkEventController</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkGesture</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkLayoutManager</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRequisition</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkRoot</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSelectionData</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkSettings</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkStyleContext</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkTooltip</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWidget</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWidgetPath</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_VIEWPORT_CLASS</NAME>
#define GTK_VIEWPORT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VIEWPORT, GtkViewportClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_VIEWPORT</NAME>
#define GTK_IS_VIEWPORT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_VIEWPORT))
</MACRO>
<MACRO>
<NAME>GTK_IS_VIEWPORT_CLASS</NAME>
#define GTK_IS_VIEWPORT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VIEWPORT))
</MACRO>
<MACRO>
<NAME>GTK_VIEWPORT_GET_CLASS</NAME>
#define GTK_VIEWPORT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VIEWPORT, GtkViewportClass))
</MACRO>
<STRUCT>
<NAME>GtkViewport</NAME>
struct _GtkViewport
{
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkViewportClass</NAME>
struct _GtkViewportClass
{
  GtkBinClass 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_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_set_shadow_type</NAME>
<RETURNS>void            </RETURNS>
GtkViewport   *viewport, GtkShadowType  type
</FUNCTION>
<FUNCTION>
<NAME>gtk_viewport_get_shadow_type</NAME>
<RETURNS>GtkShadowType   </RETURNS>
GtkViewport   *viewport
</FUNCTION>
<STRUCT>
<NAME>GtkViewportPrivate</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_VOLUME_BUTTON_CLASS</NAME>
#define GTK_VOLUME_BUTTON_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_VOLUME_BUTTON, GtkVolumeButtonClass))
</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>
<MACRO>
<NAME>GTK_IS_VOLUME_BUTTON_CLASS</NAME>
#define GTK_IS_VOLUME_BUTTON_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_VOLUME_BUTTON))
</MACRO>
<MACRO>
<NAME>GTK_VOLUME_BUTTON_GET_CLASS</NAME>
#define GTK_VOLUME_BUTTON_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_VOLUME_BUTTON, GtkVolumeButtonClass))
</MACRO>
<STRUCT>
<NAME>GtkVolumeButton</NAME>
struct _GtkVolumeButton
{
  GtkScaleButton  parent;
};
</STRUCT>
<STRUCT>
<NAME>GtkVolumeButtonClass</NAME>
struct _GtkVolumeButtonClass
{
  GtkScaleButtonClass 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_volume_button_get_type</NAME>
<RETURNS>GType 		</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_volume_button_new</NAME>
<RETURNS>GtkWidget *	</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_WIDGET</NAME>
#define GTK_TYPE_WIDGET                   (gtk_widget_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_WIDGET</NAME>
#define GTK_WIDGET(widget)                (G_TYPE_CHECK_INSTANCE_CAST ((widget), GTK_TYPE_WIDGET, GtkWidget))
</MACRO>
<MACRO>
<NAME>GTK_WIDGET_CLASS</NAME>
#define GTK_WIDGET_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_WIDGET, GtkWidgetClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_WIDGET</NAME>
#define GTK_IS_WIDGET(widget)             (G_TYPE_CHECK_INSTANCE_TYPE ((widget), GTK_TYPE_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_IS_WIDGET_CLASS</NAME>
#define GTK_IS_WIDGET_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_WIDGET))
</MACRO>
<MACRO>
<NAME>GTK_WIDGET_GET_CLASS</NAME>
#define GTK_WIDGET_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_WIDGET, GtkWidgetClass))
</MACRO>
<MACRO>
<NAME>GTK_TYPE_REQUISITION</NAME>
#define GTK_TYPE_REQUISITION              (gtk_requisition_get_type ())
</MACRO>
<TYPEDEF>
<NAME>GtkAllocation</NAME>
typedef         GdkRectangle       GtkAllocation;
</TYPEDEF>
<USER_FUNCTION>
<NAME>GtkCallback</NAME>
<RETURNS>void </RETURNS>
GtkWidget        *widget,
                                    gpointer          data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GtkTickCallback</NAME>
<RETURNS>gboolean </RETURNS>
GtkWidget     *widget,
                                     GdkFrameClock *frame_clock,
                                     gpointer       user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GtkRequisition</NAME>
struct _GtkRequisition
{
  gint width;
  gint height;
};
</STRUCT>
<STRUCT>
<NAME>GtkWidget</NAME>
struct _GtkWidget
{
  GInitiallyUnowned parent_instance;

  /*< private >*/

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

  /*< public >*/

  guint activate_signal;

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

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

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

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

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

  /* Source side drag signals */
  void     (* drag_begin)          (GtkWidget          *widget,
                                    GdkDrag            *drag);
  void     (* drag_end)            (GtkWidget          *widget,
                                    GdkDrag            *drag);
  void     (* drag_data_get)       (GtkWidget          *widget,
                                    GdkDrag            *drag,
                                    GtkSelectionData   *selection_data);
  void     (* drag_data_delete)    (GtkWidget          *widget,
                                    GdkDrag            *drag);

  /* Target side drag signals */
  void     (* drag_leave)          (GtkWidget          *widget,
                                    GdkDrop            *drop);
  gboolean (* drag_motion)         (GtkWidget          *widget,
                                    GdkDrop            *drop,
                                    gint                x,
                                    gint                y);
  gboolean (* drag_drop)           (GtkWidget          *widget,
                                    GdkDrop            *drop,
                                    gint                x,
                                    gint                y);
  void     (* drag_data_received)  (GtkWidget          *widget,
                                    GdkDrop            *drop,
                                    GtkSelectionData   *selection_data);
  gboolean (* drag_failed)         (GtkWidget          *widget,
                                    GdkDrag            *drag,
                                    GtkDragResult       result);

  /* Signals used only for keybindings */
  gboolean (* popup_menu)          (GtkWidget          *widget);

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

  gboolean     (* can_activate_accel) (GtkWidget *widget,
                                       guint      signal_id);


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

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

  void         (* style_updated)          (GtkWidget *widget);

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

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

  /*< private >*/

  GtkWidgetClassPrivate *priv;

  /* Padding for future expansion */
  void (*_gtk_reserved7) (void);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_widget_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
GType                type, const gchar         *first_property_name, ...
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_destroy</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_destroyed</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget, GtkWidget          **widget_pointer
</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_resize_no_redraw</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_add_accelerator</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget, const gchar         *accel_signal, GtkAccelGroup       *accel_group, guint                accel_key, GdkModifierType      accel_mods, GtkAccelFlags        accel_flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_remove_accelerator</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget, GtkAccelGroup       *accel_group, guint                accel_key, GdkModifierType      accel_mods
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_accel_path</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget, const gchar         *accel_path, GtkAccelGroup       *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_list_accel_closures</NAME>
<RETURNS>GList *     </RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_can_activate_accel</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget, guint                signal_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_mnemonic_activate</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget, gboolean             group_cycling
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_event</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget, const GdkEvent      *event
</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_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>void        </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_has_grab</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_device_is_shadowed</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget, GdkDevice           *device
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_name</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget    *widget, const gchar  *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_name</NAME>
<RETURNS>const gchar  *         </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_state_flags</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget     *widget, GtkStateFlags  flags, gboolean       clear
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_unset_state_flags</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget     *widget, GtkStateFlags  flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_state_flags</NAME>
<RETURNS>GtkStateFlags          </RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_sensitive</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget    *widget, gboolean      sensitive
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_sensitive</NAME>
<RETURNS>gboolean               </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_sensitive</NAME>
<RETURNS>gboolean               </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_visible</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget    *widget, gboolean      visible
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_visible</NAME>
<RETURNS>gboolean               </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_visible</NAME>
<RETURNS>gboolean               </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_has_surface</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget    *widget, gboolean      has_surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_has_surface</NAME>
<RETURNS>gboolean               </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_toplevel</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_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_set_surface</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget    *widget, GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_surface</NAME>
<RETURNS>GdkSurface            * </RETURNS>
GtkWidget    *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_register_surface</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget    *widget, GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_unregister_surface</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget    *widget, GdkSurface    *surface
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocated_width</NAME>
<RETURNS>int                    </RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocated_height</NAME>
<RETURNS>int                    </RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocated_baseline</NAME>
<RETURNS>int                    </RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_allocation</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget     *widget, GtkAllocation *allocation
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_transform</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkWidget              *widget, GtkWidget              *target, graphene_matrix_t      *out_transform
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_bounds</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkWidget              *widget, GtkWidget              *target, graphene_rect_t        *out_bounds
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_point</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkWidget              *widget, GtkWidget              *target, const graphene_point_t *point, graphene_point_t       *out_point
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_width</NAME>
<RETURNS>int                    </RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_height</NAME>
<RETURNS>int                    </RETURNS>
GtkWidget     *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_child_focus</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget, GtkDirectionType     direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_keynav_failed</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget           *widget, GtkDirectionType     direction
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_error_bell</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_size_request</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget, gint                 width, gint                 height
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_size_request</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget, gint                *width, gint                *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_opacity</NAME>
<RETURNS>void        </RETURNS>
GtkWidget           *widget, double               opacity
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_opacity</NAME>
<RETURNS>double      </RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_overflow</NAME>
<RETURNS>void          </RETURNS>
GtkWidget           *widget, GtkOverflow          overflow
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_overflow</NAME>
<RETURNS>GtkOverflow   </RETURNS>
GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_toplevel</NAME>
<RETURNS>GtkWidget *   </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_ancestor</NAME>
<RETURNS>GtkWidget *   </RETURNS>
GtkWidget      *widget, GType           widget_type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_scale_factor</NAME>
<RETURNS>gint           </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_display</NAME>
<RETURNS>GdkDisplay  *  </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_settings</NAME>
<RETURNS>GtkSettings *  </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_clipboard</NAME>
<RETURNS>GdkClipboard  *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_primary_clipboard</NAME>
<RETURNS>GdkClipboard  *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_hexpand</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_hexpand</NAME>
<RETURNS>void      </RETURNS>
GtkWidget      *widget, gboolean        expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_hexpand_set</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_hexpand_set</NAME>
<RETURNS>void      </RETURNS>
GtkWidget      *widget, gboolean        set
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_vexpand</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_vexpand</NAME>
<RETURNS>void      </RETURNS>
GtkWidget      *widget, gboolean        expand
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_vexpand_set</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_vexpand_set</NAME>
<RETURNS>void      </RETURNS>
GtkWidget      *widget, gboolean        set
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_queue_compute_expand</NAME>
<RETURNS>void      </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_compute_expand</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWidget      *widget, GtkOrientation  orientation
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_support_multidevice</NAME>
<RETURNS>gboolean          </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_support_multidevice</NAME>
<RETURNS>void              </RETURNS>
GtkWidget      *widget, gboolean        support_multidevice
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_accessible_type</NAME>
<RETURNS>void              </RETURNS>
GtkWidgetClass     *widget_class, GType               type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_accessible_role</NAME>
<RETURNS>void              </RETURNS>
GtkWidgetClass     *widget_class, AtkRole             role
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_accessible</NAME>
<RETURNS>AtkObject *       </RETURNS>
GtkWidget          *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_halign</NAME>
<RETURNS>GtkAlign  </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_halign</NAME>
<RETURNS>void      </RETURNS>
GtkWidget *widget, GtkAlign   align
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_valign</NAME>
<RETURNS>GtkAlign  </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_valign</NAME>
<RETURNS>void      </RETURNS>
GtkWidget *widget, GtkAlign   align
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_start</NAME>
<RETURNS>gint      </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_start</NAME>
<RETURNS>void      </RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_end</NAME>
<RETURNS>gint      </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_end</NAME>
<RETURNS>void      </RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_top</NAME>
<RETURNS>gint      </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_top</NAME>
<RETURNS>void      </RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_margin_bottom</NAME>
<RETURNS>gint      </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_margin_bottom</NAME>
<RETURNS>void      </RETURNS>
GtkWidget *widget, gint       margin
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_is_ancestor</NAME>
<RETURNS>gboolean      </RETURNS>
GtkWidget      *widget, GtkWidget      *ancestor
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_translate_coordinates</NAME>
<RETURNS>gboolean      </RETURNS>
GtkWidget  *src_widget, GtkWidget  *dest_widget, gint        src_x, gint        src_y, gint       *dest_x, gint       *dest_y
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_contains</NAME>
<RETURNS>gboolean      </RETURNS>
GtkWidget  *widget, gdouble     x, gdouble     y
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_pick</NAME>
<RETURNS>GtkWidget  *  </RETURNS>
GtkWidget   *widget, gdouble      x, gdouble      y, GtkPickFlags flags
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_add_controller</NAME>
<RETURNS>void          </RETURNS>
GtkWidget          *widget, GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_remove_controller</NAME>
<RETURNS>void          </RETURNS>
GtkWidget          *widget, GtkEventController *controller
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_reset_style</NAME>
<RETURNS>void        </RETURNS>
GtkWidget      *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_create_pango_context</NAME>
<RETURNS>PangoContext  *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_pango_context</NAME>
<RETURNS>PangoContext  *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_font_options</NAME>
<RETURNS>void  </RETURNS>
GtkWidget                  *widget, const cairo_font_options_t *options
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_font_options</NAME>
<RETURNS>const cairo_font_options_t  *</RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_create_pango_layout</NAME>
<RETURNS>PangoLayout   *</RETURNS>
GtkWidget   *widget, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_direction</NAME>
<RETURNS>void              </RETURNS>
GtkWidget        *widget, GtkTextDirection  dir
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_direction</NAME>
<RETURNS>GtkTextDirection  </RETURNS>
GtkWidget        *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_default_direction</NAME>
<RETURNS>void              </RETURNS>
GtkTextDirection  dir
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_default_direction</NAME>
<RETURNS>GtkTextDirection  </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_input_shape_combine_region</NAME>
<RETURNS>void          </RETURNS>
GtkWidget *widget, cairo_region_t *region
</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_set_tooltip_window</NAME>
<RETURNS>void                   </RETURNS>
GtkWidget   *widget, GtkWindow   *custom_window
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_tooltip_window</NAME>
<RETURNS>GtkWindow  *</RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_trigger_tooltip_query</NAME>
<RETURNS>void        </RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_tooltip_text</NAME>
<RETURNS>void        </RETURNS>
GtkWidget   *widget, const gchar *text
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_tooltip_text</NAME>
<RETURNS>gchar  *    </RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_tooltip_markup</NAME>
<RETURNS>void        </RETURNS>
GtkWidget   *widget, const gchar *markup
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_tooltip_markup</NAME>
<RETURNS>gchar  *    </RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_set_has_tooltip</NAME>
<RETURNS>void        </RETURNS>
GtkWidget   *widget, gboolean     has_tooltip
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_has_tooltip</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWidget   *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_new</NAME>
<RETURNS>GtkRequisition  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_copy</NAME>
<RETURNS>GtkRequisition  *</RETURNS>
const GtkRequisition *requisition
</FUNCTION>
<FUNCTION>
<NAME>gtk_requisition_free</NAME>
<RETURNS>void             </RETURNS>
GtkRequisition       *requisition
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_in_destruction</NAME>
<RETURNS>gboolean      </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_style_context</NAME>
<RETURNS>GtkStyleContext  * </RETURNS>
GtkWidget *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_path</NAME>
<RETURNS>GtkWidgetPath  *   </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_get_modifier_mask</NAME>
<RETURNS>GdkModifierType    </RETURNS>
GtkWidget         *widget, GdkModifierIntent  intent
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_insert_action_group</NAME>
<RETURNS>void                     </RETURNS>
GtkWidget    *widget, const gchar  *name, GActionGroup *group
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_add_tick_callback</NAME>
<RETURNS>guint  </RETURNS>
GtkWidget       *widget, GtkTickCallback  callback, gpointer         user_data, GDestroyNotify   notify
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_remove_tick_callback</NAME>
<RETURNS>void  </RETURNS>
GtkWidget       *widget, guint            id
</FUNCTION>
<MACRO>
<NAME>gtk_widget_class_bind_template_callback</NAME>
#define gtk_widget_class_bind_template_callback(widget_class, callback) \
  gtk_widget_class_bind_template_callback_full (GTK_WIDGET_CLASS (widget_class), \
                                                #callback, \
                                                G_CALLBACK (callback))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child</NAME>
#define gtk_widget_class_bind_template_child(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             FALSE, \
                                             G_STRUCT_OFFSET (TypeName, member_name))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child_internal</NAME>
#define gtk_widget_class_bind_template_child_internal(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             TRUE, \
                                             G_STRUCT_OFFSET (TypeName, member_name))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child_private</NAME>
#define gtk_widget_class_bind_template_child_private(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             FALSE, \
                                             G_PRIVATE_OFFSET (TypeName, member_name))
</MACRO>
<MACRO>
<NAME>gtk_widget_class_bind_template_child_internal_private</NAME>
#define gtk_widget_class_bind_template_child_internal_private(widget_class, TypeName, member_name) \
  gtk_widget_class_bind_template_child_full (widget_class, \
                                             #member_name, \
                                             TRUE, \
                                             G_PRIVATE_OFFSET (TypeName, member_name))
</MACRO>
<FUNCTION>
<NAME>gtk_widget_init_template</NAME>
<RETURNS>void     </RETURNS>
GtkWidget             *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_template_child</NAME>
<RETURNS>GObject  *</RETURNS>
GtkWidget             *widget, GType                  widget_type, const gchar           *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_template</NAME>
<RETURNS>void     </RETURNS>
GtkWidgetClass        *widget_class, GBytes                *template_bytes
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_template_from_resource</NAME>
<RETURNS>void     </RETURNS>
GtkWidgetClass        *widget_class, const gchar           *resource_name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_bind_template_callback_full</NAME>
<RETURNS>void     </RETURNS>
GtkWidgetClass        *widget_class, const gchar           *callback_name, GCallback              callback_symbol
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_set_connect_func</NAME>
<RETURNS>void     </RETURNS>
GtkWidgetClass        *widget_class, GtkBuilderConnectFunc  connect_func, gpointer               connect_data, GDestroyNotify         connect_data_destroy
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_class_bind_template_child_full</NAME>
<RETURNS>void     </RETURNS>
GtkWidgetClass        *widget_class, const gchar           *name, gboolean               internal_child, gssize                 struct_offset
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_get_action_group</NAME>
<RETURNS>GActionGroup            *</RETURNS>
GtkWidget             *widget, const gchar           *prefix
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_list_action_prefixes</NAME>
<RETURNS>const gchar  **          </RETURNS>
GtkWidget             *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_activate_action</NAME>
<RETURNS>void                     </RETURNS>
GtkWidget  *widget, const char *name, GVariant   *parameter
</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>
<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_WIDGET_PATH</NAME>
#define GTK_TYPE_WIDGET_PATH (gtk_widget_path_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_widget_path_get_type</NAME>
<RETURNS>GType            </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_new</NAME>
<RETURNS>GtkWidgetPath  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_copy</NAME>
<RETURNS>GtkWidgetPath  * </RETURNS>
const GtkWidgetPath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_ref</NAME>
<RETURNS>GtkWidgetPath  * </RETURNS>
GtkWidgetPath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_unref</NAME>
<RETURNS>void             </RETURNS>
GtkWidgetPath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_free</NAME>
<RETURNS>void             </RETURNS>
GtkWidgetPath       *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_to_string</NAME>
<RETURNS>char  *          </RETURNS>
const GtkWidgetPath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_length</NAME>
<RETURNS>gint             </RETURNS>
const GtkWidgetPath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_append_type</NAME>
<RETURNS>gint             </RETURNS>
GtkWidgetPath       *path, GType                type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_prepend_type</NAME>
<RETURNS>void             </RETURNS>
GtkWidgetPath       *path, GType                type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_append_with_siblings</NAME>
<RETURNS>gint             </RETURNS>
GtkWidgetPath       *path, GtkWidgetPath       *siblings, guint                sibling_index
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_append_for_widget</NAME>
<RETURNS>gint             </RETURNS>
GtkWidgetPath       *path, GtkWidget           *widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_get_object_type</NAME>
<RETURNS>GType                </RETURNS>
const GtkWidgetPath *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_set_object_type</NAME>
<RETURNS>void                 </RETURNS>
GtkWidgetPath       *path, gint                 pos, GType                type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_get_object_name</NAME>
<RETURNS>const char  *        </RETURNS>
const GtkWidgetPath *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_set_object_name</NAME>
<RETURNS>void                 </RETURNS>
GtkWidgetPath       *path, gint                 pos, const char          *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_get_siblings</NAME>
<RETURNS>const GtkWidgetPath  *</RETURNS>
const GtkWidgetPath *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_get_sibling_index</NAME>
<RETURNS>guint                </RETURNS>
const GtkWidgetPath *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_get_name</NAME>
<RETURNS>const gchar  *          </RETURNS>
const GtkWidgetPath *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_set_name</NAME>
<RETURNS>void                    </RETURNS>
GtkWidgetPath       *path, gint                 pos, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_has_name</NAME>
<RETURNS>gboolean                </RETURNS>
const GtkWidgetPath *path, gint                 pos, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_has_qname</NAME>
<RETURNS>gboolean                </RETURNS>
const GtkWidgetPath *path, gint                 pos, GQuark               qname
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_get_state</NAME>
<RETURNS>GtkStateFlags           </RETURNS>
const GtkWidgetPath *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_set_state</NAME>
<RETURNS>void                    </RETURNS>
GtkWidgetPath       *path, gint                 pos, GtkStateFlags        state
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_add_class</NAME>
<RETURNS>void      </RETURNS>
GtkWidgetPath       *path, gint                 pos, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_remove_class</NAME>
<RETURNS>void      </RETURNS>
GtkWidgetPath       *path, gint                 pos, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_clear_classes</NAME>
<RETURNS>void      </RETURNS>
GtkWidgetPath       *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_list_classes</NAME>
<RETURNS>GSList  * </RETURNS>
const GtkWidgetPath *path, gint                 pos
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_has_class</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkWidgetPath *path, gint                 pos, const gchar         *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_iter_has_qclass</NAME>
<RETURNS>gboolean  </RETURNS>
const GtkWidgetPath *path, gint                 pos, GQuark               qname
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_get_object_type</NAME>
<RETURNS>GType            </RETURNS>
const GtkWidgetPath *path
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_is_type</NAME>
<RETURNS>gboolean         </RETURNS>
const GtkWidgetPath *path, GType                type
</FUNCTION>
<FUNCTION>
<NAME>gtk_widget_path_has_parent</NAME>
<RETURNS>gboolean         </RETURNS>
const GtkWidgetPath *path, GType                type
</FUNCTION>
<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
{
  GtkBin parent_instance;
};
</STRUCT>
<STRUCT>
<NAME>GtkWindowClass</NAME>
struct _GtkWindowClass
{
  GtkBinClass 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 >*/

  /* Padding for future expansion */
  void (*_gtk_reserved1) (void);
  void (*_gtk_reserved2) (void);
  void (*_gtk_reserved3) (void);
};
</STRUCT>
<ENUM>
<NAME>GtkWindowType</NAME>
typedef enum
{
  GTK_WINDOW_TOPLEVEL,
  GTK_WINDOW_POPUP
} GtkWindowType;
</ENUM>
<ENUM>
<NAME>GtkWindowPosition</NAME>
typedef enum
{
  GTK_WIN_POS_NONE,
  GTK_WIN_POS_CENTER,
  GTK_WIN_POS_MOUSE,
  GTK_WIN_POS_CENTER_ALWAYS,
  GTK_WIN_POS_CENTER_ON_PARENT
} GtkWindowPosition;
</ENUM>
<FUNCTION>
<NAME>gtk_window_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_new</NAME>
<RETURNS>GtkWidget * </RETURNS>
GtkWindowType        type
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_title</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, const gchar         *title
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_title</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_startup_id</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, const gchar         *startup_id
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_add_accel_group</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, GtkAccelGroup	    *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_remove_accel_group</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, GtkAccelGroup	    *accel_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_position</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, GtkWindowPosition    position
</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_attached_to</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, GtkWidget           *attach_widget
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_attached_to</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_type_hint</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, GdkSurfaceTypeHint    hint
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_type_hint</NAME>
<RETURNS>GdkSurfaceTypeHint  </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_accept_focus</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_accept_focus</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_focus_on_map</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_focus_on_map</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_destroy_with_parent</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_destroy_with_parent</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_hide_on_close</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_hide_on_close</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_mnemonics_visible</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_mnemonics_visible</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_focus_visible</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, gboolean             setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_focus_visible</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_resizable</NAME>
<RETURNS>void        </RETURNS>
GtkWindow           *window, gboolean             resizable
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_resizable</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_display</NAME>
<RETURNS>void 	   </RETURNS>
GtkWindow	    *window, GdkDisplay          *display
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_is_active</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow           *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_decorated</NAME>
<RETURNS>void        </RETURNS>
GtkWindow *window, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_decorated</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_deletable</NAME>
<RETURNS>void        </RETURNS>
GtkWindow *window, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_deletable</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_icon_name</NAME>
<RETURNS>void        </RETURNS>
GtkWindow   *window, const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_icon_name</NAME>
<RETURNS>const gchar  * </RETURNS>
GtkWindow  *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_default_icon_name</NAME>
<RETURNS>void        </RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_default_icon_name</NAME>
<RETURNS>const gchar  * </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_auto_startup_notification</NAME>
<RETURNS>void        </RETURNS>
gboolean setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_modal</NAME>
<RETURNS>void        </RETURNS>
GtkWindow *window, gboolean   modal
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_modal</NAME>
<RETURNS>gboolean    </RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_toplevels</NAME>
<RETURNS>GListModel  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_list_toplevels</NAME>
<RETURNS>GList *     </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_has_user_ref_count</NAME>
<RETURNS>void        </RETURNS>
GtkWindow *window, gboolean   setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_add_mnemonic</NAME>
<RETURNS>void      </RETURNS>
GtkWindow       *window, guint            keyval, GtkWidget       *target
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_remove_mnemonic</NAME>
<RETURNS>void      </RETURNS>
GtkWindow       *window, guint            keyval, GtkWidget       *target
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_mnemonic_activate</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWindow       *window, guint            keyval, GdkModifierType  modifier
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_mnemonic_modifier</NAME>
<RETURNS>void      </RETURNS>
GtkWindow       *window, GdkModifierType  modifier
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_mnemonic_modifier</NAME>
<RETURNS>GdkModifierType  </RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_activate_key</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWindow        *window, GdkEventKey      *event
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_propagate_key_event</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWindow        *window, GdkEventKey      *event
</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_iconify</NAME>
<RETURNS>void      </RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_deiconify</NAME>
<RETURNS>void      </RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_stick</NAME>
<RETURNS>void      </RETURNS>
GtkWindow *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_unstick</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_keep_above</NAME>
<RETURNS>void      </RETURNS>
GtkWindow *window, gboolean setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_keep_below</NAME>
<RETURNS>void      </RETURNS>
GtkWindow *window, gboolean setting
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_begin_resize_drag</NAME>
<RETURNS>void  </RETURNS>
GtkWindow     *window, GdkSurfaceEdge  edge, gint           button, gint           x, gint           y, guint32        timestamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_begin_move_drag</NAME>
<RETURNS>void  </RETURNS>
GtkWindow     *window, gint           button, gint           x, gint           y, guint32        timestamp
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_set_default_size</NAME>
<RETURNS>void      </RETURNS>
GtkWindow   *window, gint         width, gint         height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_default_size</NAME>
<RETURNS>void      </RETURNS>
GtkWindow   *window, gint        *width, gint        *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_resize</NAME>
<RETURNS>void      </RETURNS>
GtkWindow   *window, gint         width, gint         height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_size</NAME>
<RETURNS>void      </RETURNS>
GtkWindow   *window, gint        *width, gint        *height
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_group</NAME>
<RETURNS>GtkWindowGroup  *</RETURNS>
GtkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_has_group</NAME>
<RETURNS>gboolean  </RETURNS>
GtkWindow   *window
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_get_window_type</NAME>
<RETURNS>GtkWindowType  </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_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_set_interactive_debugging</NAME>
<RETURNS>void      </RETURNS>
gboolean enable
</FUNCTION>
<STRUCT>
<NAME>GtkWindowGeometryInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWindowGroup</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWindowGroupClass</NAME>
</STRUCT>
<STRUCT>
<NAME>GtkWindowGroupPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_WINDOW_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>
<FUNCTION>
<NAME>gtk_window_group_get_current_grab</NAME>
<RETURNS>GtkWidget  *      </RETURNS>
GtkWindowGroup *window_group
</FUNCTION>
<FUNCTION>
<NAME>gtk_window_group_get_current_device_grab</NAME>
<RETURNS>GtkWidget  *      </RETURNS>
GtkWindowGroup *window_group, GdkDevice      *device
</FUNCTION>
<MACRO>
<NAME>IMR_COMPOSITIONWINDOW</NAME>
#   define IMR_COMPOSITIONWINDOW           0x0001
</MACRO>
<MACRO>
<NAME>IMR_CANDIDATEWINDOW</NAME>
#   define IMR_CANDIDATEWINDOW             0x0002
</MACRO>
<MACRO>
<NAME>IMR_COMPOSITIONFONT</NAME>
#   define IMR_COMPOSITIONFONT             0x0003
</MACRO>
<MACRO>
<NAME>IMR_RECONVERTSTRING</NAME>
#   define IMR_RECONVERTSTRING             0x0004
</MACRO>
<MACRO>
<NAME>IMR_CONFIRMRECONVERTSTRING</NAME>
#   define IMR_CONFIRMRECONVERTSTRING      0x0005
</MACRO>
<MACRO>
<NAME>IMR_QUERYCHARPOSITION</NAME>
#   define IMR_QUERYCHARPOSITION           0x0006
</MACRO>
<FUNCTION>
<NAME>get_language_name</NAME>
<RETURNS>const char  * </RETURNS>
PangoLanguage *language
</FUNCTION>
<FUNCTION>
<NAME>get_language_name_for_tag</NAME>
<RETURNS>const char  * </RETURNS>
guint32 tag
</FUNCTION>
<STRUCT>
<NAME>NamedTag</NAME>
typedef struct {
  unsigned int tag;
  const char *name;
} NamedTag;
</STRUCT>
<MACRO>
<NAME>MAKE_TAG</NAME>
#define MAKE_TAG(a,b,c,d) (unsigned int)(((a) << 24) | ((b) << 16) | ((c) <<  8) | (d))
</MACRO>
<FUNCTION>
<NAME>get_script_name</NAME>
<RETURNS>const char  * </RETURNS>
GUnicodeScript script
</FUNCTION>
<FUNCTION>
<NAME>get_script_name_for_tag</NAME>
<RETURNS>const char  * </RETURNS>
guint32 tag
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE            (gtk_boolean_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_BOOLEAN_CELL_ACCESSIBLE</NAME>
#define GTK_BOOLEAN_CELL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE, GtkBooleanCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_BOOLEAN_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_BOOLEAN_CELL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GAIL_BOOLEAN_CELL, GtkBooleanCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOOLEAN_CELL_ACCESSIBLE</NAME>
#define GTK_IS_BOOLEAN_CELL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_BOOLEAN_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_BOOLEAN_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_BOOLEAN_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_BOOLEAN_CELL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_BOOLEAN_CELL_ACCESSIBLE, GtkBooleanCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkBooleanCellAccessible</NAME>
struct _GtkBooleanCellAccessible
{
  GtkRendererCellAccessible parent;

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

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

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

  GtkCheckMenuItemAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkCheckMenuItemAccessibleClass</NAME>
struct _GtkCheckMenuItemAccessibleClass
{
  GtkMenuItemAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_check_menu_item_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCheckMenuItemAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_COLOR_SWATCH_ACCESSIBLE</NAME>
#define GTK_TYPE_COLOR_SWATCH_ACCESSIBLE                         (_gtk_color_swatch_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_COLOR_SWATCH_ACCESSIBLE</NAME>
#define GTK_COLOR_SWATCH_ACCESSIBLE(obj)                         (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE, GtkColorSwatchAccessible))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_SWATCH_ACCESSIBLE_CLASS</NAME>
#define GTK_COLOR_SWATCH_ACCESSIBLE_CLASS(klass)                       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE, GtkColorSwatchAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_SWATCH_ACCESSIBLE</NAME>
#define GTK_IS_COLOR_SWATCH_ACCESSIBLE(obj)                      (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_COLOR_SWATCH_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_COLOR_SWATCH_ACCESSIBLE_CLASS(klass)              (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_COLOR_SWATCH_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_COLOR_SWATCH_ACCESSIBLE_GET_CLASS(obj)             (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_COLOR_SWATCH_ACCESSIBLE, GtkColorSwatchAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkColorSwatchAccessible</NAME>
struct _GtkColorSwatchAccessible
{
  GtkWidgetAccessible parent;

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

  GtkComboBoxAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkComboBoxAccessibleClass</NAME>
struct _GtkComboBoxAccessibleClass
{
  GtkContainerAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_combo_box_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkComboBoxAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CONTAINER_ACCESSIBLE</NAME>
#define GTK_TYPE_CONTAINER_ACCESSIBLE                  (gtk_container_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_ACCESSIBLE</NAME>
#define GTK_CONTAINER_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER_ACCESSIBLE, GtkContainerAccessible))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_ACCESSIBLE_CLASS</NAME>
#define GTK_CONTAINER_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER_ACCESSIBLE, GtkContainerAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER_ACCESSIBLE</NAME>
#define GTK_IS_CONTAINER_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_CONTAINER_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_CONTAINER_ACCESSIBLE_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CONTAINER_ACCESSIBLE, GtkContainerAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkContainerAccessible</NAME>
struct _GtkContainerAccessible
{
  GtkWidgetAccessible parent;

  GtkContainerAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkContainerAccessibleClass</NAME>
struct _GtkContainerAccessibleClass
{
  GtkWidgetAccessibleClass parent_class;

  gint (*add_gtk)    (GtkContainer *container,
                      GtkWidget    *widget,
                      gpointer     data);
  gint (*remove_gtk) (GtkContainer *container,
                      GtkWidget    *widget,
                      gpointer     data);
};
</STRUCT>
<FUNCTION>
<NAME>gtk_container_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkContainerAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CONTAINER_CELL_ACCESSIBLE</NAME>
#define GTK_TYPE_CONTAINER_CELL_ACCESSIBLE            (gtk_container_cell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_CELL_ACCESSIBLE</NAME>
#define GTK_CONTAINER_CELL_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_CONTAINER_CELL_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER_CELL_ACCESSIBLE</NAME>
#define GTK_IS_CONTAINER_CELL_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_CONTAINER_CELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_CONTAINER_CELL_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_CONTAINER_CELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_CONTAINER_CELL_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CONTAINER_CELL_ACCESSIBLE, GtkContainerCellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkContainerCellAccessible</NAME>
struct _GtkContainerCellAccessible
{
  GtkCellAccessible parent;

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

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

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

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

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

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

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

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

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

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

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

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

  GtkLockButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkLockButtonAccessibleClass</NAME>
struct _GtkLockButtonAccessibleClass
{
  GtkButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_lock_button_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkLockButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_ACCESSIBLE</NAME>
#define GTK_TYPE_MENU_ACCESSIBLE                          (gtk_menu_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_ACCESSIBLE</NAME>
#define GTK_MENU_ACCESSIBLE(obj)                          (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ACCESSIBLE, GtkMenuAccessible))
</MACRO>
<MACRO>
<NAME>GTK_MENU_ACCESSIBLE_CLASS</NAME>
#define GTK_MENU_ACCESSIBLE_CLASS(klass)                  (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ACCESSIBLE, GtkMenuAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_ACCESSIBLE</NAME>
#define GTK_IS_MENU_ACCESSIBLE(obj)                       (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_MENU_ACCESSIBLE_CLASS(klass)               (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_MENU_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_MENU_ACCESSIBLE_GET_CLASS(obj)                (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_ACCESSIBLE, GtkMenuAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuAccessible</NAME>
struct _GtkMenuAccessible
{
  GtkMenuShellAccessible parent;

  GtkMenuAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuAccessibleClass</NAME>
struct _GtkMenuAccessibleClass
{
  GtkMenuShellAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_menu_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkMenuAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_BUTTON_ACCESSIBLE</NAME>
#define GTK_TYPE_MENU_BUTTON_ACCESSIBLE               (gtk_menu_button_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON_ACCESSIBLE</NAME>
#define GTK_MENU_BUTTON_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_BUTTON_ACCESSIBLE, GtkMenuButtonAccessible))
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_MENU_BUTTON_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_BUTTON_ACCESSIBLE, GtkMenuButtonAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_BUTTON_ACCESSIBLE</NAME>
#define GTK_IS_MENU_BUTTON_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_BUTTON_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_MENU_BUTTON_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_BUTTON_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_MENU_BUTTON_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_MENU_BUTTON_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_BUTTON_ACCESSIBLE, GtkMenuButtonAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuButtonAccessible</NAME>
struct _GtkMenuButtonAccessible
{
  GtkToggleButtonAccessible parent;

  GtkMenuButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuButtonAccessibleClass</NAME>
struct _GtkMenuButtonAccessibleClass
{
  GtkToggleButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_menu_button_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkMenuButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_ITEM_ACCESSIBLE</NAME>
#define GTK_TYPE_MENU_ITEM_ACCESSIBLE                     (gtk_menu_item_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_ITEM_ACCESSIBLE</NAME>
#define GTK_MENU_ITEM_ACCESSIBLE(obj)                     (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessible))
</MACRO>
<MACRO>
<NAME>GTK_MENU_ITEM_ACCESSIBLE_CLASS</NAME>
#define GTK_MENU_ITEM_ACCESSIBLE_CLASS(klass)             (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_ITEM_ACCESSIBLE</NAME>
#define GTK_IS_MENU_ITEM_ACCESSIBLE(obj)                  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_ITEM_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_MENU_ITEM_ACCESSIBLE_CLASS(klass)          (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_ITEM_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_MENU_ITEM_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_MENU_ITEM_ACCESSIBLE_GET_CLASS(obj)           (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_ITEM_ACCESSIBLE, GtkMenuItemAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuItemAccessible</NAME>
struct _GtkMenuItemAccessible
{
  GtkContainerAccessible parent;

  GtkMenuItemAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuItemAccessibleClass</NAME>
struct _GtkMenuItemAccessibleClass
{
  GtkContainerAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_menu_item_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkMenuItemAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_MENU_SHELL_ACCESSIBLE</NAME>
#define GTK_TYPE_MENU_SHELL_ACCESSIBLE                    (gtk_menu_shell_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MENU_SHELL_ACCESSIBLE</NAME>
#define GTK_MENU_SHELL_ACCESSIBLE(obj)                    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_MENU_SHELL_ACCESSIBLE, GtkMenuShellAccessible))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SHELL_ACCESSIBLE_CLASS</NAME>
#define GTK_MENU_SHELL_ACCESSIBLE_CLASS(klass)            (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_MENU_SHELL_ACCESSIBLE, GtkMenuShellAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SHELL_ACCESSIBLE</NAME>
#define GTK_IS_MENU_SHELL_ACCESSIBLE(obj)                 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_MENU_SHELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_MENU_SHELL_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_MENU_SHELL_ACCESSIBLE_CLASS(klass)         (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_MENU_SHELL_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_MENU_SHELL_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_MENU_SHELL_ACCESSIBLE_GET_CLASS(obj)          (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_MENU_SHELL_ACCESSIBLE, GtkMenuShellAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkMenuShellAccessible</NAME>
struct _GtkMenuShellAccessible
{
  GtkContainerAccessible parent;

  GtkMenuShellAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkMenuShellAccessibleClass</NAME>
struct _GtkMenuShellAccessibleClass
{
  GtkContainerAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_menu_shell_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkMenuShellAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_NOTEBOOK_ACCESSIBLE</NAME>
#define GTK_TYPE_NOTEBOOK_ACCESSIBLE                   (gtk_notebook_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_ACCESSIBLE</NAME>
#define GTK_NOTEBOOK_ACCESSIBLE(obj)                   (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessible))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_ACCESSIBLE_CLASS</NAME>
#define GTK_NOTEBOOK_ACCESSIBLE_CLASS(klass)           (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_ACCESSIBLE</NAME>
#define GTK_IS_NOTEBOOK_ACCESSIBLE(obj)                (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_NOTEBOOK_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_NOTEBOOK_ACCESSIBLE_CLASS(klass)        (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_NOTEBOOK_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_NOTEBOOK_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_NOTEBOOK_ACCESSIBLE_GET_CLASS(obj)         (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_NOTEBOOK_ACCESSIBLE, GtkNotebookAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkNotebookAccessible</NAME>
struct _GtkNotebookAccessible
{
  GtkContainerAccessible parent;

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

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

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

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

  GtkRadioButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkRadioButtonAccessibleClass</NAME>
struct _GtkRadioButtonAccessibleClass
{
  GtkToggleButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_radio_button_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkRadioButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE</NAME>
#define GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE               (gtk_radio_menu_item_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_RADIO_MENU_ITEM_ACCESSIBLE</NAME>
#define GTK_RADIO_MENU_ITEM_ACCESSIBLE(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE, GtkRadioMenuItemAccessible))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_MENU_ITEM_ACCESSIBLE_CLASS</NAME>
#define GTK_RADIO_MENU_ITEM_ACCESSIBLE_CLASS(klass)       (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE, GtkRadioMenuItemAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_MENU_ITEM_ACCESSIBLE</NAME>
#define GTK_IS_RADIO_MENU_ITEM_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_RADIO_MENU_ITEM_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_RADIO_MENU_ITEM_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_RADIO_MENU_ITEM_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_RADIO_MENU_ITEM_ACCESSIBLE_GET_CLASS(obj)     (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_RADIO_MENU_ITEM_ACCESSIBLE, GtkRadioMenuItemAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkRadioMenuItemAccessible</NAME>
struct _GtkRadioMenuItemAccessible
{
  GtkCheckMenuItemAccessible parent;

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

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

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

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

  GtkScaleButtonAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkScaleButtonAccessibleClass</NAME>
struct _GtkScaleButtonAccessibleClass
{
  GtkButtonAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_scale_button_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkScaleButtonAccessiblePrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE</NAME>
#define GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE            (gtk_scrolled_window_accessible_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW_ACCESSIBLE</NAME>
#define GTK_SCROLLED_WINDOW_ACCESSIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessible))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW_ACCESSIBLE_CLASS</NAME>
#define GTK_SCROLLED_WINDOW_ACCESSIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessibleClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLED_WINDOW_ACCESSIBLE</NAME>
#define GTK_IS_SCROLLED_WINDOW_ACCESSIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_IS_SCROLLED_WINDOW_ACCESSIBLE_CLASS</NAME>
#define GTK_IS_SCROLLED_WINDOW_ACCESSIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE))
</MACRO>
<MACRO>
<NAME>GTK_SCROLLED_WINDOW_ACCESSIBLE_GET_CLASS</NAME>
#define GTK_SCROLLED_WINDOW_ACCESSIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_SCROLLED_WINDOW_ACCESSIBLE, GtkScrolledWindowAccessibleClass))
</MACRO>
<STRUCT>
<NAME>GtkScrolledWindowAccessible</NAME>
struct _GtkScrolledWindowAccessible
{
  GtkContainerAccessible parent;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  GtkWindowAccessiblePrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>GtkWindowAccessibleClass</NAME>
struct _GtkWindowAccessibleClass
{
  GtkContainerAccessibleClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_window_accessible_get_type</NAME>
<RETURNS>GType  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkWindowAccessiblePrivate</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
} GtkCssParserWarning;
</ENUM>
<MACRO>
<NAME>GTK_CSS_PARSER_ERROR</NAME>
#define GTK_CSS_PARSER_ERROR (gtk_css_parser_error_quark ())
</MACRO>
<FUNCTION>
<NAME>gtk_css_parser_error_quark</NAME>
<RETURNS>GQuark  </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>GTK_CSS_PARSER_WARNING</NAME>
#define GTK_CSS_PARSER_WARNING (gtk_css_parser_warning_quark ())
</MACRO>
<FUNCTION>
<NAME>gtk_css_parser_warning_quark</NAME>
<RETURNS>GQuark  </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GtkCssLocation</NAME>
struct _GtkCssLocation
{
  gsize                  bytes;
  gsize                  chars;
  gsize                  lines;
  gsize                  line_bytes;
  gsize                  line_chars;
};
</STRUCT>
<FUNCTION>
<NAME>gtk_css_location_init</NAME>
<RETURNS>void                     </RETURNS>
GtkCssLocation         *location
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_location_advance</NAME>
<RETURNS>void                     </RETURNS>
GtkCssLocation         *location, gsize                   bytes, gsize                   chars
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_location_advance_newline</NAME>
<RETURNS>void                     </RETURNS>
GtkCssLocation         *location, gboolean                is_windows
</FUNCTION>
<MACRO>
<NAME>GTK_TYPE_CSS_SECTION</NAME>
#define GTK_TYPE_CSS_SECTION         (gtk_css_section_get_type ())
</MACRO>
<FUNCTION>
<NAME>gtk_css_section_get_type</NAME>
<RETURNS>GType               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_new</NAME>
<RETURNS>GtkCssSection  *    </RETURNS>
GFile                *file, const GtkCssLocation *start, const GtkCssLocation *end
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_ref</NAME>
<RETURNS>GtkCssSection  *    </RETURNS>
GtkCssSection        *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_unref</NAME>
<RETURNS>void                </RETURNS>
GtkCssSection        *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_print</NAME>
<RETURNS>void                </RETURNS>
const GtkCssSection  *section, GString              *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_to_string</NAME>
<RETURNS>char  *             </RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_parent</NAME>
<RETURNS>GtkCssSection  *    </RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_file</NAME>
<RETURNS>GFile  *            </RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_start_location</NAME>
<RETURNS>const GtkCssLocation  *</RETURNS>
const GtkCssSection  *section
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_section_get_end_location</NAME>
<RETURNS>const GtkCssLocation  *</RETURNS>
const GtkCssSection  *section
</FUNCTION>
<STRUCT>
<NAME>GtkCssSection</NAME>
</STRUCT>
<ENUM>
<NAME>GtkCssTokenType</NAME>
typedef enum {
  /* no content */
  GTK_CSS_TOKEN_EOF,
  GTK_CSS_TOKEN_WHITESPACE,
  GTK_CSS_TOKEN_OPEN_PARENS,
  GTK_CSS_TOKEN_CLOSE_PARENS,
  GTK_CSS_TOKEN_OPEN_SQUARE,
  GTK_CSS_TOKEN_CLOSE_SQUARE,
  GTK_CSS_TOKEN_OPEN_CURLY,
  GTK_CSS_TOKEN_CLOSE_CURLY,
  GTK_CSS_TOKEN_COMMA,
  GTK_CSS_TOKEN_COLON,
  GTK_CSS_TOKEN_SEMICOLON,
  GTK_CSS_TOKEN_CDO,
  GTK_CSS_TOKEN_CDC,
  GTK_CSS_TOKEN_INCLUDE_MATCH,
  GTK_CSS_TOKEN_DASH_MATCH,
  GTK_CSS_TOKEN_PREFIX_MATCH,
  GTK_CSS_TOKEN_SUFFIX_MATCH,
  GTK_CSS_TOKEN_SUBSTRING_MATCH,
  GTK_CSS_TOKEN_COLUMN,
  GTK_CSS_TOKEN_BAD_STRING,
  GTK_CSS_TOKEN_BAD_URL,
  GTK_CSS_TOKEN_COMMENT,
  /* delim */
  GTK_CSS_TOKEN_DELIM,
  /* string */
  GTK_CSS_TOKEN_STRING,
  GTK_CSS_TOKEN_IDENT,
  GTK_CSS_TOKEN_FUNCTION,
  GTK_CSS_TOKEN_AT_KEYWORD,
  GTK_CSS_TOKEN_HASH_UNRESTRICTED,
  GTK_CSS_TOKEN_HASH_ID,
  GTK_CSS_TOKEN_URL,
  /* number */
  GTK_CSS_TOKEN_SIGNED_INTEGER,
  GTK_CSS_TOKEN_SIGNLESS_INTEGER,
  GTK_CSS_TOKEN_SIGNED_NUMBER,
  GTK_CSS_TOKEN_SIGNLESS_NUMBER,
  GTK_CSS_TOKEN_PERCENTAGE,
  /* dimension */
  GTK_CSS_TOKEN_SIGNED_INTEGER_DIMENSION,
  GTK_CSS_TOKEN_SIGNLESS_INTEGER_DIMENSION,
  GTK_CSS_TOKEN_DIMENSION
} GtkCssTokenType;
</ENUM>
<STRUCT>
<NAME>GtkCssStringToken</NAME>
struct _GtkCssStringToken {
  GtkCssTokenType  type;
  char            *string;
};
</STRUCT>
<STRUCT>
<NAME>GtkCssDelimToken</NAME>
struct _GtkCssDelimToken {
  GtkCssTokenType  type;
  gunichar         delim;
};
</STRUCT>
<STRUCT>
<NAME>GtkCssNumberToken</NAME>
struct _GtkCssNumberToken {
  GtkCssTokenType  type;
  double           number;
};
</STRUCT>
<STRUCT>
<NAME>GtkCssDimensionToken</NAME>
struct _GtkCssDimensionToken {
  GtkCssTokenType  type;
  double           value;
  char            *dimension;
};
</STRUCT>
<UNION>
<NAME>GtkCssToken</NAME>
union _GtkCssToken {
  GtkCssTokenType type;
  GtkCssStringToken string;
  GtkCssDelimToken delim;
  GtkCssNumberToken number;
  GtkCssDimensionToken dimension;
};
</UNION>
<FUNCTION>
<NAME>gtk_css_token_clear</NAME>
<RETURNS>void                     </RETURNS>
GtkCssToken            *token
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_finite</NAME>
<RETURNS>gboolean                 </RETURNS>
const GtkCssToken      *token
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_preserved</NAME>
<RETURNS>gboolean                 </RETURNS>
const GtkCssToken      *token, GtkCssTokenType        *out_closing
</FUNCTION>
<MACRO>
<NAME>gtk_css_token_is</NAME>
#define gtk_css_token_is(token, _type) ((token)->type == (_type))
</MACRO>
<FUNCTION>
<NAME>gtk_css_token_is_ident</NAME>
<RETURNS>gboolean                 </RETURNS>
const GtkCssToken      *token, const char             *ident
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_function</NAME>
<RETURNS>gboolean                 </RETURNS>
const GtkCssToken      *token, const char             *ident
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_is_delim</NAME>
<RETURNS>gboolean                 </RETURNS>
const GtkCssToken      *token, gunichar                delim
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_print</NAME>
<RETURNS>void                     </RETURNS>
const GtkCssToken      *token, GString                *string
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_token_to_string</NAME>
<RETURNS>char  *                  </RETURNS>
const GtkCssToken      *token
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_new</NAME>
<RETURNS>GtkCssTokenizer  *       </RETURNS>
GBytes                 *bytes
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_ref</NAME>
<RETURNS>GtkCssTokenizer  *       </RETURNS>
GtkCssTokenizer        *tokenizer
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_unref</NAME>
<RETURNS>void                     </RETURNS>
GtkCssTokenizer        *tokenizer
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_get_location</NAME>
<RETURNS>const GtkCssLocation  *  </RETURNS>
GtkCssTokenizer        *tokenizer
</FUNCTION>
<FUNCTION>
<NAME>gtk_css_tokenizer_read_token</NAME>
<RETURNS>gboolean                 </RETURNS>
GtkCssTokenizer        *tokenizer, GtkCssToken            *token, GError                **error
</FUNCTION>
<STRUCT>
<NAME>GtkCssTokenizer</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_ACTION_EDITOR</NAME>
#define GTK_TYPE_INSPECTOR_ACTION_EDITOR            (gtk_inspector_action_editor_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTION_EDITOR</NAME>
#define GTK_INSPECTOR_ACTION_EDITOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditor))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTION_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_ACTION_EDITOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditorClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTION_EDITOR</NAME>
#define GTK_INSPECTOR_IS_ACTION_EDITOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTION_EDITOR_CLASS</NAME>
#define GTK_INSPECTOR_IS_ACTION_EDITOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_ACTION_EDITOR))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTION_EDITOR_GET_CLASS</NAME>
#define GTK_INSPECTOR_ACTION_EDITOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_ACTION_EDITOR, GtkInspectorActionEditorClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_action_editor_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_action_editor_new</NAME>
<RETURNS>GtkWidget  *</RETURNS>
GActionGroup *group, const gchar  *prefix, const gchar  *name
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorActionEditorPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_INSPECTOR_ACTIONS</NAME>
#define GTK_TYPE_INSPECTOR_ACTIONS            (gtk_inspector_actions_get_type())
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTIONS</NAME>
#define GTK_INSPECTOR_ACTIONS(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActions))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTIONS_CLASS</NAME>
#define GTK_INSPECTOR_ACTIONS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActionsClass))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTIONS</NAME>
#define GTK_INSPECTOR_IS_ACTIONS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_INSPECTOR_ACTIONS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_IS_ACTIONS_CLASS</NAME>
#define GTK_INSPECTOR_IS_ACTIONS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_INSPECTOR_ACTIONS))
</MACRO>
<MACRO>
<NAME>GTK_INSPECTOR_ACTIONS_GET_CLASS</NAME>
#define GTK_INSPECTOR_ACTIONS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_INSPECTOR_ACTIONS, GtkInspectorActionsClass))
</MACRO>
<FUNCTION>
<NAME>gtk_inspector_actions_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gtk_inspector_actions_set_object</NAME>
<RETURNS>void        </RETURNS>
GtkInspectorActions *sl, GObject              *object
</FUNCTION>
<STRUCT>
<NAME>GtkInspectorActionsPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_GRAPH</NAME>
#define GTK_TYPE_CELL_RENDERER_GRAPH            (gtk_cell_renderer_graph_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_GRAPH</NAME>
#define GTK_CELL_RENDERER_GRAPH(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CELL_RENDERER_GRAPH, GtkCellRendererGraph))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_GRAPH_CLASS</NAME>
#define GTK_CELL_RENDERER_GRAPH_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CELL_RENDERER_GRAPH, GtkCellRendererGraphClass))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_GRAPH</NAME>
#define GTK_IS_CELL_RENDERER_GRAPH(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CELL_RENDERER_GRAPH))
</MACRO>
<MACRO>
<NAME>GTK_IS_CELL_RENDERER_GRAPH_CLASS</NAME>
#define GTK_IS_CELL_RENDERER_GRAPH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CELL_RENDERER_GRAPH))
</MACRO>
<MACRO>
<NAME>GTK_CELL_RENDERER_GRAPH_GET_CLASS</NAME>
#define GTK_CELL_RENDERER_GRAPH_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CELL_RENDERER_GRAPH, GtkCellRendererGraphClass))
</MACRO>
<STRUCT>
<NAME>GtkCellRendererGraph</NAME>
struct _GtkCellRendererGraph
{
  GtkCellRenderer                parent;

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

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

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

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

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

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

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

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

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

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

};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerProxy</NAME>
struct __GtkMountOperationHandlerProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  _GtkMountOperationHandlerProxyPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerProxyClass</NAME>
struct __GtkMountOperationHandlerProxyClass
{
  GDBusProxyClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerSkeleton</NAME>
struct __GtkMountOperationHandlerSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  _GtkMountOperationHandlerSkeletonPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerSkeletonClass</NAME>
struct __GtkMountOperationHandlerSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandler</NAME>
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerProxyPrivate</NAME>
</STRUCT>
<STRUCT>
<NAME>_GtkMountOperationHandlerSkeletonPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CSS_AFFECTS</NAME>
#define GTK_TYPE_CSS_AFFECTS (_gtk_css_affects_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_HANDLE_POSITION</NAME>
#define GTK_TYPE_TEXT_HANDLE_POSITION (_gtk_text_handle_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_HANDLE_MODE</NAME>
#define GTK_TYPE_TEXT_HANDLE_MODE (_gtk_text_handle_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_LICENSE</NAME>
#define GTK_TYPE_LICENSE (gtk_license_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ACCEL_FLAGS</NAME>
#define GTK_TYPE_ACCEL_FLAGS (gtk_accel_flags_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_CALENDAR_DISPLAY_OPTIONS</NAME>
#define GTK_TYPE_CALENDAR_DISPLAY_OPTIONS (gtk_calendar_display_options_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_STATE</NAME>
#define GTK_TYPE_CELL_RENDERER_STATE (gtk_cell_renderer_state_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_MODE</NAME>
#define GTK_TYPE_CELL_RENDERER_MODE (gtk_cell_renderer_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CELL_RENDERER_ACCEL_MODE</NAME>
#define GTK_TYPE_CELL_RENDERER_ACCEL_MODE (gtk_cell_renderer_accel_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DEBUG_FLAG</NAME>
#define GTK_TYPE_DEBUG_FLAG (gtk_debug_flag_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DIALOG_FLAGS</NAME>
#define GTK_TYPE_DIALOG_FLAGS (gtk_dialog_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_RESPONSE_TYPE</NAME>
#define GTK_TYPE_RESPONSE_TYPE (gtk_response_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DEST_DEFAULTS</NAME>
#define GTK_TYPE_DEST_DEFAULTS (gtk_dest_defaults_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_EDITABLE_PROPERTIES</NAME>
#define GTK_TYPE_EDITABLE_PROPERTIES (gtk_editable_properties_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ENTRY_ICON_POSITION</NAME>
#define GTK_TYPE_ENTRY_ICON_POSITION (gtk_entry_icon_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ALIGN</NAME>
#define GTK_TYPE_ALIGN (gtk_align_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ARROW_TYPE</NAME>
#define GTK_TYPE_ARROW_TYPE (gtk_arrow_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_BASELINE_POSITION</NAME>
#define GTK_TYPE_BASELINE_POSITION (gtk_baseline_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DELETE_TYPE</NAME>
#define GTK_TYPE_DELETE_TYPE (gtk_delete_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DIRECTION_TYPE</NAME>
#define GTK_TYPE_DIRECTION_TYPE (gtk_direction_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_SIZE</NAME>
#define GTK_TYPE_ICON_SIZE (gtk_icon_size_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SENSITIVITY_TYPE</NAME>
#define GTK_TYPE_SENSITIVITY_TYPE (gtk_sensitivity_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_DIRECTION</NAME>
#define GTK_TYPE_TEXT_DIRECTION (gtk_text_direction_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_JUSTIFICATION</NAME>
#define GTK_TYPE_JUSTIFICATION (gtk_justification_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MENU_DIRECTION_TYPE</NAME>
#define GTK_TYPE_MENU_DIRECTION_TYPE (gtk_menu_direction_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MESSAGE_TYPE</NAME>
#define GTK_TYPE_MESSAGE_TYPE (gtk_message_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_MOVEMENT_STEP</NAME>
#define GTK_TYPE_MOVEMENT_STEP (gtk_movement_step_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SCROLL_STEP</NAME>
#define GTK_TYPE_SCROLL_STEP (gtk_scroll_step_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ORIENTATION</NAME>
#define GTK_TYPE_ORIENTATION (gtk_orientation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_OVERFLOW</NAME>
#define GTK_TYPE_OVERFLOW (gtk_overflow_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PACK_TYPE</NAME>
#define GTK_TYPE_PACK_TYPE (gtk_pack_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_POSITION_TYPE</NAME>
#define GTK_TYPE_POSITION_TYPE (gtk_position_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_RELIEF_STYLE</NAME>
#define GTK_TYPE_RELIEF_STYLE (gtk_relief_style_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_SHADOW_TYPE</NAME>
#define GTK_TYPE_SHADOW_TYPE (gtk_shadow_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TOOLBAR_STYLE</NAME>
#define GTK_TYPE_TOOLBAR_STYLE (gtk_toolbar_style_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_WRAP_MODE</NAME>
#define GTK_TYPE_WRAP_MODE (gtk_wrap_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SORT_TYPE</NAME>
#define GTK_TYPE_SORT_TYPE (gtk_sort_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_PAGES</NAME>
#define GTK_TYPE_PRINT_PAGES (gtk_print_pages_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PAGE_SET</NAME>
#define GTK_TYPE_PAGE_SET (gtk_page_set_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_NUMBER_UP_LAYOUT</NAME>
#define GTK_TYPE_NUMBER_UP_LAYOUT (gtk_number_up_layout_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PAGE_ORIENTATION</NAME>
#define GTK_TYPE_PAGE_ORIENTATION (gtk_page_orientation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_QUALITY</NAME>
#define GTK_TYPE_PRINT_QUALITY (gtk_print_quality_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PRINT_DUPLEX</NAME>
#define GTK_TYPE_PRINT_DUPLEX (gtk_print_duplex_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_UNIT</NAME>
#define GTK_TYPE_UNIT (gtk_unit_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_GRID_LINES</NAME>
#define GTK_TYPE_TREE_VIEW_GRID_LINES (gtk_tree_view_grid_lines_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_DRAG_RESULT</NAME>
#define GTK_TYPE_DRAG_RESULT (gtk_drag_result_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_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_POPOVER_CONSTRAINT</NAME>
#define GTK_TYPE_POPOVER_CONSTRAINT (gtk_popover_constraint_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PLACES_OPEN_FLAGS</NAME>
#define GTK_TYPE_PLACES_OPEN_FLAGS (gtk_places_open_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_PICK_FLAGS</NAME>
#define GTK_TYPE_PICK_FLAGS (gtk_pick_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_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_CONFIRMATION</NAME>
#define GTK_TYPE_FILE_CHOOSER_CONFIRMATION (gtk_file_chooser_confirmation_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FILE_CHOOSER_ERROR</NAME>
#define GTK_TYPE_FILE_CHOOSER_ERROR (gtk_file_chooser_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FILE_FILTER_FLAGS</NAME>
#define GTK_TYPE_FILE_FILTER_FLAGS (gtk_file_filter_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_FONT_CHOOSER_LEVEL</NAME>
#define GTK_TYPE_FONT_CHOOSER_LEVEL (gtk_font_chooser_level_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_LOOKUP_FLAGS</NAME>
#define GTK_TYPE_ICON_LOOKUP_FLAGS (gtk_icon_lookup_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_THEME_ERROR</NAME>
#define GTK_TYPE_ICON_THEME_ERROR (gtk_icon_theme_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ICON_VIEW_DROP_POSITION</NAME>
#define GTK_TYPE_ICON_VIEW_DROP_POSITION (gtk_icon_view_drop_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_IMAGE_TYPE</NAME>
#define GTK_TYPE_IMAGE_TYPE (gtk_image_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_ARROW_PLACEMENT</NAME>
#define GTK_TYPE_ARROW_PLACEMENT (gtk_arrow_placement_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_BUTTON_ROLE</NAME>
#define GTK_TYPE_BUTTON_ROLE (gtk_button_role_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_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_TYPE</NAME>
#define GTK_TYPE_SHORTCUT_TYPE (gtk_shortcut_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY</NAME>
#define GTK_TYPE_SPIN_BUTTON_UPDATE_POLICY (gtk_spin_button_update_policy_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_SPIN_TYPE</NAME>
#define GTK_TYPE_SPIN_TYPE (gtk_spin_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_STACK_TRANSITION_TYPE</NAME>
#define GTK_TYPE_STACK_TRANSITION_TYPE (gtk_stack_transition_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_STYLE_CONTEXT_PRINT_FLAGS</NAME>
#define GTK_TYPE_STYLE_CONTEXT_PRINT_FLAGS (gtk_style_context_print_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_BUFFER_TARGET_INFO</NAME>
#define GTK_TYPE_TEXT_BUFFER_TARGET_INFO (gtk_text_buffer_target_info_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_SEARCH_FLAGS</NAME>
#define GTK_TYPE_TEXT_SEARCH_FLAGS (gtk_text_search_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_WINDOW_TYPE</NAME>
#define GTK_TYPE_TEXT_WINDOW_TYPE (gtk_text_window_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_VIEW_LAYER</NAME>
#define GTK_TYPE_TEXT_VIEW_LAYER (gtk_text_view_layer_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TEXT_EXTEND_SELECTION</NAME>
#define GTK_TYPE_TEXT_EXTEND_SELECTION (gtk_text_extend_selection_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_MODEL_FLAGS</NAME>
#define GTK_TYPE_TREE_MODEL_FLAGS (gtk_tree_model_flags_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_DROP_POSITION</NAME>
#define GTK_TYPE_TREE_VIEW_DROP_POSITION (gtk_tree_view_drop_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_TREE_VIEW_COLUMN_SIZING</NAME>
#define GTK_TYPE_TREE_VIEW_COLUMN_SIZING (gtk_tree_view_column_sizing_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_WINDOW_TYPE</NAME>
#define GTK_TYPE_WINDOW_TYPE (gtk_window_type_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_WINDOW_POSITION</NAME>
#define GTK_TYPE_WINDOW_POSITION (gtk_window_position_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_MAJOR_VERSION</NAME>
#define GTK_MAJOR_VERSION (3)
</MACRO>
<MACRO>
<NAME>GTK_MINOR_VERSION</NAME>
#define GTK_MINOR_VERSION (96)
</MACRO>
<MACRO>
<NAME>GTK_MICRO_VERSION</NAME>
#define GTK_MICRO_VERSION (0)
</MACRO>
<MACRO>
<NAME>GTK_BINARY_AGE</NAME>
#define GTK_BINARY_AGE    (9600)
</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>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_ENUM</NAME>
#define ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_text_input_v3_change_cause</NAME>
enum zwp_text_input_v3_change_cause {
	/**
	 * input method caused the change
	 */
	ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_INPUT_METHOD = 0,
	/**
	 * something else than the input method caused the change
	 */
	ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_OTHER = 1,
};
</ENUM>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_CONTENT_HINT_ENUM</NAME>
#define ZWP_TEXT_INPUT_V3_CONTENT_HINT_ENUM
</MACRO>
<ENUM>
<NAME>zwp_text_input_v3_content_hint</NAME>
enum zwp_text_input_v3_content_hint {
	/**
	 * no special behavior
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE = 0x0,
	/**
	 * suggest word completions
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_COMPLETION = 0x1,
	/**
	 * suggest word corrections
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_SPELLCHECK = 0x2,
	/**
	 * switch to uppercase letters at the start of a sentence
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_AUTO_CAPITALIZATION = 0x4,
	/**
	 * prefer lowercase letters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_LOWERCASE = 0x8,
	/**
	 * prefer uppercase letters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_UPPERCASE = 0x10,
	/**
	 * prefer casing for titles and headings (can be language dependent)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_TITLECASE = 0x20,
	/**
	 * characters should be hidden
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_HIDDEN_TEXT = 0x40,
	/**
	 * typed text should not be stored
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA = 0x80,
	/**
	 * just Latin characters should be entered
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_LATIN = 0x100,
	/**
	 * the text input is multiline
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_HINT_MULTILINE = 0x200,
};
</ENUM>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ENUM</NAME>
#define ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ENUM
</MACRO>
<ENUM>
<NAME>zwp_text_input_v3_content_purpose</NAME>
enum zwp_text_input_v3_content_purpose {
	/**
	 * default input, allowing all characters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL = 0,
	/**
	 * allow only alphabetic characters
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ALPHA = 1,
	/**
	 * allow only digits
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DIGITS = 2,
	/**
	 * input a number (including decimal separator and sign)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NUMBER = 3,
	/**
	 * input a phone number
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PHONE = 4,
	/**
	 * input an URL
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_URL = 5,
	/**
	 * input an email address
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_EMAIL = 6,
	/**
	 * input a name of a person
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NAME = 7,
	/**
	 * input a password (combine with sensitive_data hint)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PASSWORD = 8,
	/**
	 * input is a numeric password (combine with sensitive_data hint)
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PIN = 9,
	/**
	 * input a date
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATE = 10,
	/**
	 * input a time
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TIME = 11,
	/**
	 * input a date and time
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATETIME = 12,
	/**
	 * input for a terminal
	 */
	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TERMINAL = 13,
};
</ENUM>
<STRUCT>
<NAME>zwp_text_input_v3_listener</NAME>
struct zwp_text_input_v3_listener {
	/**
	 * enter event
	 *
	 * Notification that this seat's text-input focus is on a certain
	 * surface.
	 *
	 * When the seat has the keyboard capability the text-input focus
	 * follows the keyboard focus. This event sets the current surface
	 * for the text-input object.
	 */
	void (*enter)(void *data,
		      struct zwp_text_input_v3 *zwp_text_input_v3,
		      struct wl_surface *surface);
	/**
	 * leave event
	 *
	 * Notification that this seat's text-input focus is no longer on
	 * a certain surface. The client should reset any preedit string
	 * previously set.
	 *
	 * The leave notification clears the current surface. It is sent
	 * before the enter notification for the new focus.
	 *
	 * When the seat has the keyboard capability the text-input focus
	 * follows the keyboard focus.
	 */
	void (*leave)(void *data,
		      struct zwp_text_input_v3 *zwp_text_input_v3,
		      struct wl_surface *surface);
	/**
	 * pre-edit
	 *
	 * Notify when a new composing text (pre-edit) should be set at
	 * the current cursor position. Any previously set composing text
	 * must be removed. Any previously existing selected text must be
	 * removed.
	 *
	 * The argument text contains the pre-edit string buffer.
	 *
	 * The parameters cursor_begin and cursor_end are counted in bytes
	 * relative to the beginning of the submitted text buffer. Cursor
	 * should be hidden when both are equal to -1.
	 *
	 * They could be represented by the client as a line if both values
	 * are the same, or as a text highlight otherwise.
	 *
	 * Values set with this event are double-buffered. They must be
	 * applied and reset to initial on the next zwp_text_input_v3.done
	 * event.
	 *
	 * The initial value of text is an empty string, and cursor_begin,
	 * cursor_end and cursor_hidden are all 0.
	 */
	void (*preedit_string)(void *data,
			       struct zwp_text_input_v3 *zwp_text_input_v3,
			       const char *text,
			       int32_t cursor_begin,
			       int32_t cursor_end);
	/**
	 * text commit
	 *
	 * Notify when text should be inserted into the editor widget.
	 * The text to commit could be either just a single character after
	 * a key press or the result of some composing (pre-edit).
	 *
	 * Values set with this event are double-buffered. They must be
	 * applied and reset to initial on the next zwp_text_input_v3.done
	 * event.
	 *
	 * The initial value of text is an empty string.
	 */
	void (*commit_string)(void *data,
			      struct zwp_text_input_v3 *zwp_text_input_v3,
			      const char *text);
	/**
	 * delete surrounding text
	 *
	 * Notify when the text around the current cursor position should
	 * be deleted.
	 *
	 * Before_length and after_length are the number of bytes before
	 * and after the current cursor index (excluding the selection) to
	 * delete.
	 *
	 * If a preedit text is present, in effect before_length is counted
	 * from the beginning of it, and after_length from its end (see
	 * done event sequence).
	 *
	 * Values set with this event are double-buffered. They must be
	 * applied and reset to initial on the next zwp_text_input_v3.done
	 * event.
	 *
	 * The initial values of both before_length and after_length are 0.
	 * @param before_length length of text before current cursor position
	 * @param after_length length of text after current cursor position
	 */
	void (*delete_surrounding_text)(void *data,
					struct zwp_text_input_v3 *zwp_text_input_v3,
					uint32_t before_length,
					uint32_t after_length);
	/**
	 * apply changes
	 *
	 * Instruct the application to apply changes to state requested
	 * by the preedit_string, commit_string and delete_surrounding_text
	 * events. The state relating to these events is double-buffered,
	 * and each one modifies the pending state. This event replaces the
	 * current state with the pending state.
	 *
	 * The application must proceed by evaluating the changes in the
	 * following order:
	 *
	 * 1. Replace existing preedit string with the cursor. 2. Delete
	 * requested surrounding text. 3. Insert commit string with the
	 * cursor at its end. 4. Calculate surrounding text to send. 5.
	 * Insert new preedit text in cursor position. 6. Place cursor
	 * inside preedit text.
	 *
	 * The serial number reflects the last state of the
	 * zwp_text_input_v3 object known to the compositor. The value of
	 * the serial argument must be equal to the number of commit
	 * requests already issued on that object. When the client receives
	 * a done event with a serial different than the number of past
	 * commit requests, it must proceed as normal, except it should not
	 * change the current state of the zwp_text_input_v3 object.
	 */
	void (*done)(void *data,
		     struct zwp_text_input_v3 *zwp_text_input_v3,
		     uint32_t serial);
};
</STRUCT>
<FUNCTION>
<NAME>zwp_text_input_v3_add_listener</NAME>
<RETURNS>int</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, const struct zwp_text_input_v3_listener *listener, void *data
</FUNCTION>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DESTROY</NAME>
#define ZWP_TEXT_INPUT_V3_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_ENABLE</NAME>
#define ZWP_TEXT_INPUT_V3_ENABLE 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DISABLE</NAME>
#define ZWP_TEXT_INPUT_V3_DISABLE 2
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT</NAME>
#define ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT 3
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE</NAME>
#define ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE 4
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE 5
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE 6
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_COMMIT</NAME>
#define ZWP_TEXT_INPUT_V3_COMMIT 7
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_ENTER_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_ENTER_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_LEAVE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_LEAVE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_PREEDIT_STRING_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_PREEDIT_STRING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_COMMIT_STRING_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_COMMIT_STRING_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DELETE_SURROUNDING_TEXT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DELETE_SURROUNDING_TEXT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DONE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DONE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_ENABLE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_ENABLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_DISABLE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_DISABLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_V3_COMMIT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_V3_COMMIT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_text_input_v3_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_enable</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_disable</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_surrounding_text</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, const char *text, int32_t cursor, int32_t anchor
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_text_change_cause</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, uint32_t cause
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_content_type</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, uint32_t hint, uint32_t purpose
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_set_cursor_rectangle</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3, int32_t x, int32_t y, int32_t width, int32_t height
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_v3_commit</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_v3 *zwp_text_input_v3
</FUNCTION>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_DESTROY</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_DESTROY 0
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_DESTROY_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_DESTROY_SINCE_VERSION 1
</MACRO>
<MACRO>
<NAME>ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT_SINCE_VERSION</NAME>
#define ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT_SINCE_VERSION 1
</MACRO>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_set_user_data</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3, void *user_data
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_get_user_data</NAME>
<RETURNS>void  *</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_get_version</NAME>
<RETURNS>uint32_t</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_destroy</NAME>
<RETURNS>void</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3
</FUNCTION>
<FUNCTION>
<NAME>zwp_text_input_manager_v3_get_text_input</NAME>
<RETURNS>struct zwp_text_input_v3  *</RETURNS>
struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3, struct wl_seat *seat
</FUNCTION>
<STRUCT>
<NAME>wl_seat</NAME>
struct wl_seat;
</STRUCT>
<STRUCT>
<NAME>wl_surface</NAME>
struct wl_surface;
</STRUCT>
<STRUCT>
<NAME>zwp_text_input_manager_v3</NAME>
struct zwp_text_input_manager_v3;
</STRUCT>
<STRUCT>
<NAME>zwp_text_input_v3</NAME>
struct zwp_text_input_v3;
</STRUCT>
<MACRO>
<NAME>GTK_TYPE_CSS_PARSER_ERROR</NAME>
#define GTK_TYPE_CSS_PARSER_ERROR (gtk_css_parser_error_get_type ())
</MACRO>
<MACRO>
<NAME>GTK_TYPE_CSS_PARSER_WARNING</NAME>
#define GTK_TYPE_CSS_PARSER_WARNING (gtk_css_parser_warning_get_type ())
</MACRO>
