gchar* gtk_set_locale (void);
void gtk_disable_setlocale (void);
PangoLanguage* gtk_get_default_language (void);
gboolean gtk_parse_args (int *argc,char ***argv);
void gtk_init (int *argc,char ***argv);
gboolean gtk_init_check (int *argc,char ***argv);
gboolean gtk_init_with_args (int *argc,char ***argv,char *parameter_string,GOptionEntry *entries,char *translation_domain,GError **error);
GOptionGroup* gtk_get_option_group (gboolean open_default_display);
void gtk_exit (gint error_code);
gboolean gtk_events_pending (void);
void gtk_main (void);
guint gtk_main_level (void);
void gtk_main_quit (void);
gboolean gtk_main_iteration (void);
gboolean gtk_main_iteration_do (gboolean blocking);
void gtk_main_do_event ( GdkEvent *event);
gboolean gtk_true (void);
gboolean gtk_false (void);
void gtk_grab_add ( GtkWidget *widget);
GtkWidget* gtk_grab_get_current (void);
void gtk_grab_remove ( GtkWidget *widget);
void gtk_init_add ( GtkFunction function,gpointer data);
void gtk_quit_add_destroy (guint main_level, GtkObject *object);
guint gtk_quit_add (guint main_level, GtkFunction function,gpointer data);
guint gtk_quit_add_full (guint main_level, GtkFunction function, GtkCallbackMarshal marshal,gpointer data, GtkDestroyNotify destroy);
void gtk_quit_remove (guint quit_handler_id);
void gtk_quit_remove_by_data (gpointer data);
guint gtk_timeout_add_full (guint32 interval, GtkFunction function, GtkCallbackMarshal marshal,gpointer data, GtkDestroyNotify destroy);
guint gtk_timeout_add (guint32 interval, GtkFunction function,gpointer data);
void gtk_timeout_remove (guint timeout_handler_id);
guint gtk_idle_add ( GtkFunction function,gpointer data);
guint gtk_idle_add_priority (gint priority, GtkFunction function,gpointer data);
guint gtk_idle_add_full (gint priority, GtkFunction function, GtkCallbackMarshal marshal,gpointer data, GtkDestroyNotify destroy);
void gtk_idle_remove (guint idle_handler_id);
void gtk_idle_remove_by_data (gpointer data);
guint gtk_input_add_full (gint source, GdkInputCondition condition, GdkInputFunction function, GtkCallbackMarshal marshal,gpointer data, GtkDestroyNotify destroy);
void gtk_input_remove (guint input_handler_id);
guint gtk_key_snooper_install ( GtkKeySnoopFunc snooper,gpointer func_data);
void gtk_key_snooper_remove (guint snooper_handler_id);
GdkEvent* gtk_get_current_event (void);
GdkEvent* gtk_get_current_event (void);
guint32 gtk_get_current_event_time (void);
gboolean gtk_get_current_event_state ( GdkModifierType *state);
GtkWidget* gtk_get_event_widget ( GdkEvent *event);
void gtk_propagate_event ( GtkWidget *widget, GdkEvent *event);
GtkAccelGroup* gtk_accel_group_new (void);
void gtk_accel_group_connect ( GtkAccelGroup *accel_group,guint accel_key, GdkModifierType accel_mods, GtkAccelFlags accel_flags,GClosure *closure);
void gtk_accel_group_connect_by_path ( GtkAccelGroup *accel_group,const gchar *accel_path,GClosure *closure);
gboolean gtk_accel_group_disconnect ( GtkAccelGroup *accel_group,GClosure *closure);
gboolean gtk_accel_group_disconnect_key ( GtkAccelGroup *accel_group,guint accel_key, GdkModifierType accel_mods);
GtkAccelGroupEntry* gtk_accel_group_query ( GtkAccelGroup *accel_group,guint accel_key, GdkModifierType accel_mods,guint *n_entries);
gboolean gtk_accel_group_activate ( GtkAccelGroup *accel_group,GQuark accel_quark,GObject *acceleratable,guint accel_key, GdkModifierType accel_mods);
void gtk_accel_group_lock ( GtkAccelGroup *accel_group);
void gtk_accel_group_unlock ( GtkAccelGroup *accel_group);
GtkAccelGroup* gtk_accel_group_from_accel_closure (GClosure *closure);
gboolean gtk_accel_groups_activate (GObject *object,guint accel_key, GdkModifierType accel_mods);
GSList* gtk_accel_groups_from_object (GObject *object);
GtkAccelKey* gtk_accel_group_find ( GtkAccelGroup *accel_group, GtkAccelGroupFindFunc find_func,gpointer data); GtkAccelKey ;
gboolean gtk_accelerator_valid (guint keyval, GdkModifierType modifiers);
void gtk_accelerator_parse (const gchar *accelerator,guint *accelerator_key, GdkModifierType *accelerator_mods);
gchar* gtk_accelerator_name (guint accelerator_key, GdkModifierType accelerator_mods);
gchar* gtk_accelerator_get_label (guint accelerator_key, GdkModifierType accelerator_mods);
void gtk_accelerator_set_default_mod_mask ( GdkModifierType default_mod_mask);
guint gtk_accelerator_get_default_mod_mask (void);
void gtk_accel_map_add_entry (const gchar *accel_path,guint accel_key, GdkModifierType accel_mods);
gboolean gtk_accel_map_lookup_entry (const gchar *accel_path, GtkAccelKey *key);
gboolean gtk_accel_map_change_entry (const gchar *accel_path,guint accel_key, GdkModifierType accel_mods,gboolean replace);
void gtk_accel_map_load (const gchar *file_name);
void gtk_accel_map_save (const gchar *file_name);
void gtk_accel_map_foreach (gpointer data, GtkAccelMapForeach foreach_func);
void gtk_accel_map_load_fd (gint fd);
void gtk_accel_map_save_fd (gint fd);
void gtk_accel_map_load_scanner (GScanner *scanner);
void gtk_accel_map_add_filter (const gchar *filter_pattern);
void gtk_accel_map_foreach_unfiltered (gpointer data, GtkAccelMapForeach foreach_func);
GtkAccelMap* gtk_accel_map_get (void);
void gtk_accel_map_lock_path (const gchar *accel_path);
void gtk_accel_map_unlock_path (const gchar *accel_path);
GtkClipboard* gtk_clipboard_get ( GdkAtom selection);
GtkClipboard* gtk_clipboard_get_for_display ( GdkDisplay *display, GdkAtom selection);
GdkDisplay* gtk_clipboard_get_display ( GtkClipboard *clipboard);
GdkDisplay* gtk_clipboard_get_display ( GtkClipboard *clipboard);
gboolean gtk_clipboard_set_with_data ( GtkClipboard *clipboard,const GtkTargetEntry *targets,guint n_targets, GtkClipboardGetFunc get_func, GtkClipboardClearFunc clear_func,gpointer user_data);
gboolean gtk_clipboard_set_with_owner ( GtkClipboard *clipboard,const GtkTargetEntry *targets,guint n_targets, GtkClipboardGetFunc get_func, GtkClipboardClearFunc clear_func,GObject *owner);
GObject* gtk_clipboard_get_owner ( GtkClipboard *clipboard);
void gtk_clipboard_clear ( GtkClipboard *clipboard);
void gtk_clipboard_set_text ( GtkClipboard *clipboard,const gchar *text,gint len);
void gtk_clipboard_set_image ( GtkClipboard *clipboard, GdkPixbuf *pixbuf);
void gtk_clipboard_request_contents ( GtkClipboard *clipboard, GdkAtom target, GtkClipboardReceivedFunc callback,gpointer user_data);
void gtk_clipboard_request_text ( GtkClipboard *clipboard, GtkClipboardTextReceivedFunc callback,gpointer user_data);
void gtk_clipboard_request_image ( GtkClipboard *clipboard, GtkClipboardImageReceivedFunc callback,gpointer user_data);
void gtk_clipboard_request_targets ( GtkClipboard *clipboard, GtkClipboardTargetsReceivedFunc callback,gpointer user_data);
void gtk_clipboard_request_rich_text ( GtkClipboard *clipboard, GtkTextBuffer *buffer, GtkClipboardRichTextReceivedFunc callback,gpointer user_data);
GtkSelectionData* gtk_clipboard_wait_for_contents ( GtkClipboard *clipboard, GdkAtom target);
gchar* gtk_clipboard_wait_for_text ( GtkClipboard *clipboard);
GdkPixbuf* gtk_clipboard_wait_for_image ( GtkClipboard *clipboard);
GdkPixbuf* gtk_clipboard_wait_for_image ( GtkClipboard *clipboard);
guint8* gtk_clipboard_wait_for_rich_text ( GtkClipboard *clipboard, GtkTextBuffer *buffer, GdkAtom *format,gsize *length);
gboolean gtk_clipboard_wait_is_text_available ( GtkClipboard *clipboard);
gboolean gtk_clipboard_wait_is_image_available ( GtkClipboard *clipboard);
gboolean gtk_clipboard_wait_is_rich_text_available ( GtkClipboard *clipboard, GtkTextBuffer *buffer);
gboolean gtk_clipboard_wait_for_targets ( GtkClipboard *clipboard, GdkAtom **targets,gint *n_targets);
gboolean gtk_clipboard_wait_is_target_available ( GtkClipboard *clipboard, GdkAtom target);
void gtk_clipboard_set_can_store ( GtkClipboard *clipboard,const GtkTargetEntry *targets,gint n_targets);
void gtk_clipboard_store ( GtkClipboard *clipboard);
void gtk_drag_dest_set ( GtkWidget *widget, GtkDestDefaults flags,const GtkTargetEntry *targets,gint n_targets, GdkDragAction actions);
void gtk_drag_dest_set_proxy ( GtkWidget *widget, GdkWindow *proxy_window, GdkDragProtocol protocol,gboolean use_coordinates);
void gtk_drag_dest_unset ( GtkWidget *widget);
GdkAtom gtk_drag_dest_find_target ( GtkWidget *widget, GdkDragContext *context, GtkTargetList *target_list);
GdkAtom gtk_drag_dest_find_target ( GtkWidget *widget, GdkDragContext *context, GtkTargetList *target_list);
GtkTargetList* gtk_drag_dest_get_target_list ( GtkWidget *widget);
void gtk_drag_dest_set_target_list ( GtkWidget *widget, GtkTargetList *target_list);
void gtk_drag_dest_add_text_targets ( GtkWidget *widget);
void gtk_drag_dest_add_image_targets ( GtkWidget *widget);
void gtk_drag_dest_add_uri_targets ( GtkWidget *widget);
void gtk_drag_dest_set_track_motion ( GtkWidget *widget,gboolean track_motion);
gboolean gtk_drag_dest_get_track_motion ( GtkWidget *widget);
void gtk_drag_finish ( GdkDragContext *context,gboolean success,gboolean del,guint32 time_);
void gtk_drag_get_data ( GtkWidget *widget, GdkDragContext *context, GdkAtom target,guint32 time_);
GtkWidget* gtk_drag_get_source_widget ( GdkDragContext *context);
void gtk_drag_highlight ( GtkWidget *widget);
void gtk_drag_unhighlight ( GtkWidget *widget);
GdkDragContext* gtk_drag_begin ( GtkWidget *widget, GtkTargetList *targets, GdkDragAction actions,gint button, GdkEvent *event);
GdkDragContext* gtk_drag_begin ( GtkWidget *widget, GtkTargetList *targets, GdkDragAction actions,gint button, GdkEvent *event);
void gtk_drag_set_icon_widget ( GdkDragContext *context, GtkWidget *widget,gint hot_x,gint hot_y);
void gtk_drag_set_icon_pixmap ( GdkDragContext *context, GdkColormap *colormap, GdkPixmap *pixmap, GdkBitmap *mask,gint hot_x,gint hot_y);
void gtk_drag_set_icon_pixbuf ( GdkDragContext *context, GdkPixbuf *pixbuf,gint hot_x,gint hot_y);
void gtk_drag_set_icon_stock ( GdkDragContext *context,const gchar *stock_id,gint hot_x,gint hot_y);
void gtk_drag_set_icon_name ( GdkDragContext *context,const gchar *icon_name,gint hot_x,gint hot_y);
void gtk_drag_set_icon_default ( GdkDragContext *context);
void gtk_drag_set_default_icon ( GdkColormap *colormap, GdkPixmap *pixmap, GdkBitmap *mask,gint hot_x,gint hot_y);
gboolean gtk_drag_check_threshold ( GtkWidget *widget,gint start_x,gint start_y,gint current_x,gint current_y);
void gtk_drag_source_set ( GtkWidget *widget, GdkModifierType start_button_mask,const GtkTargetEntry *targets,gint n_targets, GdkDragAction actions);
void gtk_drag_source_set_icon ( GtkWidget *widget, GdkColormap *colormap, GdkPixmap *pixmap, GdkBitmap *mask);
void gtk_drag_source_set_icon_pixbuf ( GtkWidget *widget, GdkPixbuf *pixbuf);
void gtk_drag_source_set_icon_stock ( GtkWidget *widget,const gchar *stock_id);
void gtk_drag_source_set_icon_name ( GtkWidget *widget,const gchar *icon_name);
void gtk_drag_source_unset ( GtkWidget *widget);
void gtk_drag_source_set_target_list ( GtkWidget *widget, GtkTargetList *target_list);
GtkTargetList* gtk_drag_source_get_target_list ( GtkWidget *widget);
void gtk_drag_source_add_text_targets ( GtkWidget *widget);
void gtk_drag_source_add_image_targets ( GtkWidget *widget);
void gtk_drag_source_add_uri_targets ( GtkWidget *widget);
GtkIconTheme* gtk_icon_theme_new (void);
GtkIconTheme* gtk_icon_theme_get_default (void);
GtkIconTheme* gtk_icon_theme_get_for_screen ( GdkScreen *screen);
void gtk_icon_theme_set_screen ( GtkIconTheme *icon_theme, GdkScreen *screen);
void gtk_icon_theme_set_search_path ( GtkIconTheme *icon_theme,const gchar *path[],gint n_elements);
void gtk_icon_theme_get_search_path ( GtkIconTheme *icon_theme,gchar **path[],gint *n_elements);
void gtk_icon_theme_append_search_path ( GtkIconTheme *icon_theme,const gchar *path);
void gtk_icon_theme_prepend_search_path ( GtkIconTheme *icon_theme,const gchar *path);
void gtk_icon_theme_set_custom_theme ( GtkIconTheme *icon_theme,const gchar *theme_name);
gboolean gtk_icon_theme_has_icon ( GtkIconTheme *icon_theme,const gchar *icon_name);
GtkIconInfo* gtk_icon_theme_lookup_icon ( GtkIconTheme *icon_theme,const gchar *icon_name,gint size, GtkIconLookupFlags flags);
GdkPixbuf* gtk_icon_theme_load_icon ( GtkIconTheme *icon_theme,const gchar *icon_name,gint size, GtkIconLookupFlags flags,GError **error);
GdkPixbuf* gtk_icon_theme_load_icon ( GtkIconTheme *icon_theme,const gchar *icon_name,gint size, GtkIconLookupFlags flags,GError **error);
GList* gtk_icon_theme_list_icons ( GtkIconTheme *icon_theme,const gchar *context);
gint* gtk_icon_theme_get_icon_sizes ( GtkIconTheme *icon_theme,const gchar *icon_name);
char* gtk_icon_theme_get_example_icon_name ( GtkIconTheme *icon_theme);
gboolean gtk_icon_theme_rescan_if_needed ( GtkIconTheme *icon_theme);
void gtk_icon_theme_add_builtin_icon (const gchar *icon_name,gint size, GdkPixbuf *pixbuf);
GtkIconInfo* gtk_icon_info_copy ( GtkIconInfo *icon_info);
void gtk_icon_info_free ( GtkIconInfo *icon_info);
gint gtk_icon_info_get_base_size ( GtkIconInfo *icon_info);
const gchar* gtk_icon_info_get_filename ( GtkIconInfo *icon_info);
GdkPixbuf* gtk_icon_info_get_builtin_pixbuf ( GtkIconInfo *icon_info);
GdkPixbuf* gtk_icon_info_get_builtin_pixbuf ( GtkIconInfo *icon_info);
GdkPixbuf* gtk_icon_info_load_icon ( GtkIconInfo *icon_info,GError **error);
GdkPixbuf* gtk_icon_info_load_icon ( GtkIconInfo *icon_info,GError **error);
void gtk_icon_info_set_raw_coordinates ( GtkIconInfo *icon_info,gboolean raw_coordinates);
gboolean gtk_icon_info_get_embedded_rect ( GtkIconInfo *icon_info, GdkRectangle *rectangle);
gboolean gtk_icon_info_get_attach_points ( GtkIconInfo *icon_info, GdkPoint **points,gint *n_points);
const gchar* gtk_icon_info_get_display_name ( GtkIconInfo *icon_info);
GtkIconSource* gtk_icon_source_copy (const GtkIconSource *source);
void gtk_icon_source_free ( GtkIconSource *source);
void gtk_icon_factory_add ( GtkIconFactory *factory,const gchar *stock_id, GtkIconSet *icon_set);
void gtk_icon_factory_add_default ( GtkIconFactory *factory);
GtkIconSet* gtk_icon_factory_lookup ( GtkIconFactory *factory,const gchar *stock_id);
GtkIconSet* gtk_icon_factory_lookup_default (const gchar *stock_id);
GtkIconFactory* gtk_icon_factory_new (void);
void gtk_icon_factory_remove_default ( GtkIconFactory *factory);
void gtk_icon_set_add_source ( GtkIconSet *icon_set,const GtkIconSource *source);
GtkIconSet* gtk_icon_set_copy ( GtkIconSet *icon_set);
GtkIconSet* gtk_icon_set_new (void);
GtkIconSet* gtk_icon_set_new_from_pixbuf ( GdkPixbuf *pixbuf);
GtkIconSet* gtk_icon_set_ref ( GtkIconSet *icon_set);
GdkPixbuf* gtk_icon_set_render_icon ( GtkIconSet *icon_set, GtkStyle *style, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget *widget,const char *detail);
GdkPixbuf* gtk_icon_set_render_icon ( GtkIconSet *icon_set, GtkStyle *style, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget *widget,const char *detail);
void gtk_icon_set_unref ( GtkIconSet *icon_set);
gboolean gtk_icon_size_lookup ( GtkIconSize size,gint *width,gint *height);
gboolean gtk_icon_size_lookup_for_settings ( GtkSettings *settings, GtkIconSize size,gint *width,gint *height);
GtkIconSize gtk_icon_size_register (const gchar *name,gint width,gint height);
void gtk_icon_size_register_alias (const gchar *alias, GtkIconSize target);
GtkIconSize gtk_icon_size_from_name (const gchar *name);
const gchar* gtk_icon_size_get_name ( GtkIconSize size);
void gtk_icon_set_get_sizes ( GtkIconSet *icon_set, GtkIconSize **sizes,gint *n_sizes);
GtkTextDirection gtk_icon_source_get_direction (const GtkIconSource *source);
gboolean gtk_icon_source_get_direction_wildcarded (const GtkIconSource *source);
const gchar* gtk_icon_source_get_filename (const GtkIconSource *source);
GdkPixbuf* gtk_icon_source_get_pixbuf (const GtkIconSource *source);
GdkPixbuf* gtk_icon_source_get_pixbuf (const GtkIconSource *source);
const gchar* gtk_icon_source_get_icon_name (const GtkIconSource *source);
GtkIconSize gtk_icon_source_get_size (const GtkIconSource *source);
gboolean gtk_icon_source_get_size_wildcarded (const GtkIconSource *source);
GtkStateType gtk_icon_source_get_state (const GtkIconSource *source);
gboolean gtk_icon_source_get_state_wildcarded (const GtkIconSource *source);
GtkIconSource* gtk_icon_source_new (void);
void gtk_icon_source_set_direction ( GtkIconSource *source, GtkTextDirection direction);
void gtk_icon_source_set_direction_wildcarded ( GtkIconSource *source,gboolean setting);
void gtk_icon_source_set_filename ( GtkIconSource *source,const gchar *filename);
void gtk_icon_source_set_pixbuf ( GtkIconSource *source, GdkPixbuf *pixbuf);
void gtk_icon_source_set_icon_name ( GtkIconSource *source,const gchar *icon_name);
void gtk_icon_source_set_size ( GtkIconSource *source, GtkIconSize size);
void gtk_icon_source_set_size_wildcarded ( GtkIconSource *source,gboolean setting);
void gtk_icon_source_set_state ( GtkIconSource *source, GtkStateType state);
void gtk_icon_source_set_state_wildcarded ( GtkIconSource *source,gboolean setting);
GScanner* gtk_rc_scanner_new (void);
GtkStyle* gtk_rc_get_style ( GtkWidget *widget);
GtkStyle* gtk_rc_get_style_by_paths ( GtkSettings *settings,const char *widget_path,const char *class_path,GType type);
void gtk_rc_add_widget_name_style ( GtkRcStyle *rc_style,const gchar *pattern);
void gtk_rc_add_widget_class_style ( GtkRcStyle *rc_style,const gchar *pattern);
void gtk_rc_add_class_style ( GtkRcStyle *rc_style,const gchar *pattern);
void gtk_rc_parse (const gchar *filename);
void gtk_rc_parse_string (const gchar *rc_string);
gboolean gtk_rc_reparse_all (void);
gboolean gtk_rc_reparse_all_for_settings ( GtkSettings *settings,gboolean force_load);
void gtk_rc_reset_styles ( GtkSettings *settings);
void gtk_rc_add_default_file (const gchar *filename);
gchar** gtk_rc_get_default_files (void);
void gtk_rc_set_default_files (gchar **filenames);
guint gtk_rc_parse_color (GScanner *scanner, GdkColor *color);
guint gtk_rc_parse_state (GScanner *scanner, GtkStateType *state);
guint gtk_rc_parse_priority (GScanner *scanner, GtkPathPriorityType *priority);
gchar* gtk_rc_find_module_in_path (const gchar *module_file);
gchar* gtk_rc_find_pixmap_in_path ( GtkSettings *settings,GScanner *scanner,const gchar *pixmap_file);
gchar* gtk_rc_get_module_dir (void);
gchar* gtk_rc_get_im_module_path (void);
gchar* gtk_rc_get_im_module_file (void);
gchar* gtk_rc_get_theme_dir (void);
GtkRcStyle* gtk_rc_style_new (void);
GtkRcStyle* gtk_rc_style_copy ( GtkRcStyle *orig);
void gtk_rc_style_ref ( GtkRcStyle *rc_style);
void gtk_rc_style_unref ( GtkRcStyle *rc_style);
GtkSettings* gtk_settings_get_default (void);
GtkSettings* gtk_settings_get_for_screen ( GdkScreen *screen);
void gtk_settings_install_property (GParamSpec *pspec);
void gtk_settings_install_property_parser (GParamSpec *pspec, GtkRcPropertyParser parser);
gboolean gtk_rc_property_parse_color (const GParamSpec *pspec,const GString *gstring,GValue *property_value);
gboolean gtk_rc_property_parse_enum (const GParamSpec *pspec,const GString *gstring,GValue *property_value);
gboolean gtk_rc_property_parse_flags (const GParamSpec *pspec,const GString *gstring,GValue *property_value);
gboolean gtk_rc_property_parse_requisition (const GParamSpec *pspec,const GString *gstring,GValue *property_value);
gboolean gtk_rc_property_parse_border (const GParamSpec *pspec,const GString *gstring,GValue *property_value);
void gtk_settings_set_property_value ( GtkSettings *settings,const gchar *name,const GtkSettingsValue *svalue);
void gtk_settings_set_string_property ( GtkSettings *settings,const gchar *name,const gchar *v_string,const gchar *origin);
void gtk_settings_set_long_property ( GtkSettings *settings,const gchar *name,glong v_long,const gchar *origin);
void gtk_settings_set_double_property ( GtkSettings *settings,const gchar *name,gdouble v_double,const gchar *origin);
GtkBindingSet* gtk_binding_set_new (const gchar *set_name);
GtkBindingSet* gtk_binding_set_by_class (gpointer object_class);
GtkBindingSet* gtk_binding_set_find (const gchar *set_name);
gboolean gtk_bindings_activate ( GtkObject *object,guint keyval, GdkModifierType modifiers);
gboolean gtk_bindings_activate_event ( GtkObject *object, GdkEventKey *event);
gboolean gtk_binding_set_activate ( GtkBindingSet *binding_set,guint keyval, GdkModifierType modifiers, GtkObject *object);
void gtk_binding_entry_clear ( GtkBindingSet *binding_set,guint keyval, GdkModifierType modifiers);
void gtk_binding_entry_add_signal ( GtkBindingSet *binding_set,guint keyval, GdkModifierType modifiers,const gchar *signal_name,guint n_args,...);
void gtk_binding_set_add_path ( GtkBindingSet *binding_set, GtkPathType path_type,const gchar *path_pattern, GtkPathPriorityType priority);
void gtk_binding_entry_remove ( GtkBindingSet *binding_set,guint keyval, GdkModifierType modifiers);
void gtk_binding_entry_add_signall ( GtkBindingSet *binding_set,guint keyval, GdkModifierType modifiers,const gchar *signal_name,GSList *binding_args);
guint gtk_binding_parse_binding (GScanner *scanner);
GdkGC* gtk_gc_get (gint depth, GdkColormap *colormap, GdkGCValues *values, GdkGCValuesMask values_mask);
GdkGC* gtk_gc_get (gint depth, GdkColormap *colormap, GdkGCValues *values, GdkGCValuesMask values_mask);
void gtk_gc_release ( GdkGC *gc);
GtkStyle* gtk_style_new (void);
GtkStyle* gtk_style_copy ( GtkStyle *style);
GtkStyle* gtk_style_attach ( GtkStyle *style, GdkWindow *window);
void gtk_style_detach ( GtkStyle *style);
GtkStyle* gtk_style_ref ( GtkStyle *style);
void gtk_style_unref ( GtkStyle *style);
void gtk_style_set_background ( GtkStyle *style, GdkWindow *window, GtkStateType state_type);
void gtk_style_apply_default_background ( GtkStyle *style, GdkWindow *window,gboolean set_bg, GtkStateType state_type, GdkRectangle *area,gint x,gint y,gint width,gint height);
gboolean gtk_style_lookup_color ( GtkStyle *style,const gchar *color_name, GdkColor *color);
GtkIconSet* gtk_style_lookup_icon_set ( GtkStyle *style,const gchar *stock_id);
GdkPixbuf* gtk_style_render_icon ( GtkStyle *style,const GtkIconSource *source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget *widget,const gchar *detail);
GdkPixbuf* gtk_style_render_icon ( GtkStyle *style,const GtkIconSource *source, GtkTextDirection direction, GtkStateType state, GtkIconSize size, GtkWidget *widget,const gchar *detail);
GdkFont* gtk_style_get_font ( GtkStyle *style);
GdkFont* gtk_style_get_font ( GtkStyle *style);
void gtk_style_set_font ( GtkStyle *style, GdkFont *font);
void gtk_draw_hline ( GtkStyle *style, GdkWindow *window, GtkStateType state_type,gint x1,gint x2,gint y);
void gtk_draw_vline ( GtkStyle *style, GdkWindow *window, GtkStateType state_type,gint y1_,gint y2_,gint x);
void gtk_draw_shadow ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height);
void gtk_draw_polygon ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkPoint *points,gint npoints,gboolean fill);
void gtk_draw_arrow ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GtkArrowType arrow_type,gboolean fill,gint x,gint y,gint width,gint height);
void gtk_draw_diamond ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height);
void gtk_draw_string ( GtkStyle *style, GdkWindow *window, GtkStateType state_type,gint x,gint y,const gchar *string);
void gtk_draw_box ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height);
void gtk_draw_box_gap ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height, GtkPositionType gap_side,gint gap_x,gint gap_width);
void gtk_draw_check ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height);
void gtk_draw_extension ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height, GtkPositionType gap_side);
void gtk_draw_flat_box ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height);
void gtk_draw_focus ( GtkStyle *style, GdkWindow *window,gint x,gint y,gint width,gint height);
void gtk_draw_handle ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height, GtkOrientation orientation);
void gtk_draw_option ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height);
void gtk_draw_shadow_gap ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height, GtkPositionType gap_side,gint gap_x,gint gap_width);
void gtk_draw_slider ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height, GtkOrientation orientation);
void gtk_draw_tab ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type,gint x,gint y,gint width,gint height);
void gtk_draw_expander ( GtkStyle *style, GdkWindow *window, GtkStateType state_type,gint x,gint y, GtkExpanderStyle expander_style);
void gtk_draw_layout ( GtkStyle *style, GdkWindow *window, GtkStateType state_type,gboolean use_text,gint x,gint y,PangoLayout *layout);
void gtk_draw_resize_grip ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkWindowEdge edge,gint x,gint y,gint width,gint height);
void gtk_paint_arrow ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail, GtkArrowType arrow_type,gboolean fill,gint x,gint y,gint width,gint height);
void gtk_paint_box ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_box_gap ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,gchar *detail,gint x,gint y,gint width,gint height, GtkPositionType gap_side,gint gap_x,gint gap_width);
void gtk_paint_check ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_diamond ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_extension ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,gchar *detail,gint x,gint y,gint width,gint height, GtkPositionType gap_side);
void gtk_paint_flat_box ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_focus ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_handle ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height, GtkOrientation orientation);
void gtk_paint_hline ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x1,gint x2,gint y);
void gtk_paint_option ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_polygon ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail, GdkPoint *points,gint npoints,gboolean fill);
void gtk_paint_shadow ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_shadow_gap ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,gchar *detail,gint x,gint y,gint width,gint height, GtkPositionType gap_side,gint gap_x,gint gap_width);
void gtk_paint_slider ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height, GtkOrientation orientation);
void gtk_paint_string ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,const gchar *string);
void gtk_paint_tab ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GtkShadowType shadow_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,gint width,gint height);
void gtk_paint_vline ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint y1_,gint y2_,gint x);
void gtk_paint_expander ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y, GtkExpanderStyle expander_style);
void gtk_paint_layout ( GtkStyle *style, GdkWindow *window, GtkStateType state_type,gboolean use_text, GdkRectangle *area, GtkWidget *widget,const gchar *detail,gint x,gint y,PangoLayout *layout);
void gtk_paint_resize_grip ( GtkStyle *style, GdkWindow *window, GtkStateType state_type, GdkRectangle *area, GtkWidget *widget,const gchar *detail, GdkWindowEdge edge,gint x,gint y,gint width,gint height);
void gtk_draw_insertion_cursor ( GtkWidget *widget, GdkDrawable *drawable, GdkRectangle *area, GdkRectangle *location,gboolean is_primary, GtkTextDirection direction,gboolean draw_arrow);
GtkBorder* gtk_border_copy (const GtkBorder *border_);
void gtk_border_free ( GtkBorder *border_);
GtkTargetList* gtk_target_list_new (const GtkTargetEntry *targets,guint ntargets);
GtkTargetList* gtk_target_list_ref ( GtkTargetList *list);
void gtk_target_list_unref ( GtkTargetList *list);
void gtk_target_list_add ( GtkTargetList *list, GdkAtom target,guint flags,guint info);
void gtk_target_list_add_table ( GtkTargetList *list,const GtkTargetEntry *targets,guint ntargets);
void gtk_target_list_add_text_targets ( GtkTargetList *list,guint info);
void gtk_target_list_add_image_targets ( GtkTargetList *list,guint info,gboolean writable);
void gtk_target_list_add_uri_targets ( GtkTargetList *list,guint info);
void gtk_target_list_add_rich_text_targets ( GtkTargetList *list,guint info,gboolean deserializable, GtkTextBuffer *buffer);
void gtk_target_list_remove ( GtkTargetList *list, GdkAtom target);
gboolean gtk_target_list_find ( GtkTargetList *list, GdkAtom target,guint *info);
void gtk_target_table_free ( GtkTargetEntry *targets,gint n_targets);
GtkTargetEntry* gtk_target_table_new_from_list ( GtkTargetList *list,gint *n_targets);
gboolean gtk_selection_owner_set ( GtkWidget *widget, GdkAtom selection,guint32 time_);
gboolean gtk_selection_owner_set_for_display ( GdkDisplay *display, GtkWidget *widget, GdkAtom selection,guint32 time_);
void gtk_selection_add_target ( GtkWidget *widget, GdkAtom selection, GdkAtom target,guint info);
void gtk_selection_add_targets ( GtkWidget *widget, GdkAtom selection,const GtkTargetEntry *targets,guint ntargets);
void gtk_selection_clear_targets ( GtkWidget *widget, GdkAtom selection);
gboolean gtk_selection_convert ( GtkWidget *widget, GdkAtom selection, GdkAtom target,guint32 time_);
void gtk_selection_data_set ( GtkSelectionData *selection_data, GdkAtom type,gint format,const guchar *data,gint length);
gboolean gtk_selection_data_set_text ( GtkSelectionData *selection_data,const gchar *str,gint len);
guchar* gtk_selection_data_get_text ( GtkSelectionData *selection_data);
gboolean gtk_selection_data_set_pixbuf ( GtkSelectionData *selection_data, GdkPixbuf *pixbuf);
GdkPixbuf* gtk_selection_data_get_pixbuf ( GtkSelectionData *selection_data);
GdkPixbuf* gtk_selection_data_get_pixbuf ( GtkSelectionData *selection_data);
gboolean gtk_selection_data_set_uris ( GtkSelectionData *selection_data,gchar **uris);
gchar** gtk_selection_data_get_uris ( GtkSelectionData *selection_data);
gboolean gtk_selection_data_get_targets ( GtkSelectionData *selection_data, GdkAtom **targets,gint *n_atoms);
gboolean gtk_selection_data_targets_include_image ( GtkSelectionData *selection_data,gboolean writable);
gboolean gtk_selection_data_targets_include_text ( GtkSelectionData *selection_data);
gboolean gtk_selection_data_targets_include_uri ( GtkSelectionData *selection_data);
gboolean gtk_selection_data_targets_include_rich_text ( GtkSelectionData *selection_data, GtkTextBuffer *buffer);
gboolean gtk_targets_include_image ( GdkAtom *targets,gint n_targets,gboolean writable);
gboolean gtk_targets_include_text ( GdkAtom *targets,gint n_targets);
gboolean gtk_targets_include_uri ( GdkAtom *targets,gint n_targets);
gboolean gtk_targets_include_rich_text ( GdkAtom *targets,gint n_targets, GtkTextBuffer *buffer);
void gtk_selection_remove_all ( GtkWidget *widget);
gboolean gtk_selection_clear ( GtkWidget *widget, GdkEventSelection *event);
GtkSelectionData* gtk_selection_data_copy ( GtkSelectionData *data);
void gtk_selection_data_free ( GtkSelectionData *data);
gchar* gtk_check_version (guint required_major,guint required_minor,guint required_micro);
guint gtk_signal_new (const gchar *name, GtkSignalRunType signal_flags, GtkType object_type,guint function_offset, GtkSignalMarshaller marshaller, GtkType return_val,guint n_args,...);
guint gtk_signal_newv (const gchar *name, GtkSignalRunType signal_flags, GtkType object_type,guint function_offset, GtkSignalMarshaller marshaller, GtkType return_val,guint n_args, GtkType *args);
void gtk_signal_emit ( GtkObject *object,guint signal_id,...);
void gtk_signal_emit_by_name ( GtkObject *object,const gchar *name,...);
void gtk_signal_emitv ( GtkObject *object,guint signal_id, GtkArg *args);
void gtk_signal_emitv_by_name ( GtkObject *object,const gchar *name, GtkArg *args);
void gtk_signal_emit_stop_by_name ( GtkObject *object,const gchar *name);
gulong gtk_signal_connect_full ( GtkObject *object,const gchar *name, GtkSignalFunc func, GtkCallbackMarshal unsupported,gpointer data, GtkDestroyNotify destroy_func,gint object_signal,gint after);
void gtk_signal_connect_while_alive ( GtkObject *object,const gchar *name, GtkSignalFunc func,gpointer func_data, GtkObject *alive_object);
void gtk_signal_connect_object_while_alive ( GtkObject *object,const gchar *name, GtkSignalFunc func, GtkObject *alive_object);
GtkWidget* gtk_dialog_new (void);
GtkWidget* gtk_dialog_new_with_buttons (const gchar *title, GtkWindow *parent, GtkDialogFlags flags,const gchar *first_button_text,...);
gint gtk_dialog_run ( GtkDialog *dialog);
void gtk_dialog_response ( GtkDialog *dialog,gint response_id);
GtkWidget* gtk_dialog_add_button ( GtkDialog *dialog,const gchar *button_text,gint response_id);
void gtk_dialog_add_buttons ( GtkDialog *dialog,const gchar *first_button_text,...);
void gtk_dialog_add_action_widget ( GtkDialog *dialog, GtkWidget *child,gint response_id);
gboolean gtk_dialog_get_has_separator ( GtkDialog *dialog);
void gtk_dialog_set_default_response ( GtkDialog *dialog,gint response_id);
void gtk_dialog_set_has_separator ( GtkDialog *dialog,gboolean setting);
void gtk_dialog_set_response_sensitive ( GtkDialog *dialog,gint response_id,gboolean setting);
gint gtk_dialog_get_response_for_widget ( GtkDialog *dialog, GtkWidget *widget);
gboolean gtk_alternative_dialog_button_order ( GdkScreen *screen);
void gtk_dialog_set_alternative_button_order ( GtkDialog *dialog,gint first_response_id,...);
void gtk_dialog_set_alternative_button_order_from_array ( GtkDialog *dialog,gint n_params,gint *new_order);
GtkWidget* gtk_invisible_new (void);
GtkWidget* gtk_invisible_new_for_screen ( GdkScreen *screen);
void gtk_invisible_set_screen ( GtkInvisible *invisible, GdkScreen *screen);
GdkScreen* gtk_invisible_get_screen ( GtkInvisible *invisible);
GdkScreen* gtk_invisible_get_screen ( GtkInvisible *invisible);
GtkWidget* gtk_message_dialog_new ( GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons,const gchar *message_format,...);
GtkWidget* gtk_message_dialog_new_with_markup ( GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons,const gchar *message_format,...);
void gtk_message_dialog_set_markup ( GtkMessageDialog *message_dialog,const gchar *str);
void gtk_message_dialog_set_image ( GtkMessageDialog *dialog, GtkWidget *image);
void gtk_message_dialog_format_secondary_text ( GtkMessageDialog *message_dialog,const gchar *message_format,...);
void gtk_message_dialog_format_secondary_markup ( GtkMessageDialog *message_dialog,const gchar *message_format,...);
GtkWidget* gtk_window_new ( GtkWindowType type);
void gtk_window_set_title ( GtkWindow *window,const gchar *title);
void gtk_window_set_wmclass ( GtkWindow *window,const gchar *wmclass_name,const gchar *wmclass_class);
void gtk_window_set_policy ( GtkWindow *window,gint allow_shrink,gint allow_grow,gint auto_shrink);
void gtk_window_set_resizable ( GtkWindow *window,gboolean resizable);
gboolean gtk_window_get_resizable ( GtkWindow *window);
void gtk_window_add_accel_group ( GtkWindow *window, GtkAccelGroup *accel_group);
void gtk_window_remove_accel_group ( GtkWindow *window, GtkAccelGroup *accel_group);
gboolean gtk_window_activate_focus ( GtkWindow *window);
gboolean gtk_window_activate_default ( GtkWindow *window);
void gtk_window_set_modal ( GtkWindow *window,gboolean modal);
void gtk_window_set_default_size ( GtkWindow *window,gint width,gint height);
void gtk_window_set_geometry_hints ( GtkWindow *window, GtkWidget *geometry_widget, GdkGeometry *geometry, GdkWindowHints geom_mask);
void gtk_window_set_gravity ( GtkWindow *window, GdkGravity gravity);
GdkGravity gtk_window_get_gravity ( GtkWindow *window);
GdkGravity gtk_window_get_gravity ( GtkWindow *window);
void gtk_window_set_position ( GtkWindow *window, GtkWindowPosition position);
void gtk_window_set_transient_for ( GtkWindow *window, GtkWindow *parent);
void gtk_window_set_destroy_with_parent ( GtkWindow *window,gboolean setting);
void gtk_window_set_screen ( GtkWindow *window, GdkScreen *screen);
GdkScreen* gtk_window_get_screen ( GtkWindow *window);
GdkScreen* gtk_window_get_screen ( GtkWindow *window);
gboolean gtk_window_is_active ( GtkWindow *window);
gboolean gtk_window_has_toplevel_focus ( GtkWindow *window);
GList* gtk_window_list_toplevels (void);
void gtk_window_add_mnemonic ( GtkWindow *window,guint keyval, GtkWidget *target);
void gtk_window_remove_mnemonic ( GtkWindow *window,guint keyval, GtkWidget *target);
gboolean gtk_window_mnemonic_activate ( GtkWindow *window,guint keyval, GdkModifierType modifier);
gboolean gtk_window_activate_key ( GtkWindow *window, GdkEventKey *event);
gboolean gtk_window_propagate_key_event ( GtkWindow *window, GdkEventKey *event);
GtkWidget* gtk_window_get_focus ( GtkWindow *window);
void gtk_window_set_focus ( GtkWindow *window, GtkWidget *focus);
void gtk_window_set_default ( GtkWindow *window, GtkWidget *default_widget);
void gtk_window_present ( GtkWindow *window);
void gtk_window_present_with_time ( GtkWindow *window,guint32 timestamp);
void gtk_window_iconify ( GtkWindow *window);
void gtk_window_deiconify ( GtkWindow *window);
void gtk_window_stick ( GtkWindow *window);
void gtk_window_unstick ( GtkWindow *window);
void gtk_window_maximize ( GtkWindow *window);
void gtk_window_unmaximize ( GtkWindow *window);
void gtk_window_fullscreen ( GtkWindow *window);
void gtk_window_unfullscreen ( GtkWindow *window);
void gtk_window_set_keep_above ( GtkWindow *window,gboolean setting);
void gtk_window_set_keep_below ( GtkWindow *window,gboolean setting);
void gtk_window_begin_resize_drag ( GtkWindow *window, GdkWindowEdge edge,gint button,gint root_x,gint root_y,guint32 timestamp);
void gtk_window_begin_move_drag ( GtkWindow *window,gint button,gint root_x,gint root_y,guint32 timestamp);
void gtk_window_set_decorated ( GtkWindow *window,gboolean setting);
void gtk_window_set_deletable ( GtkWindow *window,gboolean setting);
void gtk_window_set_frame_dimensions ( GtkWindow *window,gint left,gint top,gint right,gint bottom);
void gtk_window_set_has_frame ( GtkWindow *window,gboolean setting);
void gtk_window_set_mnemonic_modifier ( GtkWindow *window, GdkModifierType modifier);
void gtk_window_set_role ( GtkWindow *window,const gchar *role);
void gtk_window_set_type_hint ( GtkWindow *window, GdkWindowTypeHint hint);
void gtk_window_set_skip_taskbar_hint ( GtkWindow *window,gboolean setting);
void gtk_window_set_skip_pager_hint ( GtkWindow *window,gboolean setting);
void gtk_window_set_urgency_hint ( GtkWindow *window,gboolean setting);
void gtk_window_set_accept_focus ( GtkWindow *window,gboolean setting);
void gtk_window_set_focus_on_map ( GtkWindow *window,gboolean setting);
gboolean gtk_window_get_decorated ( GtkWindow *window);
gboolean gtk_window_get_deletable ( GtkWindow *window);
GList* gtk_window_get_default_icon_list (void);
void gtk_window_get_default_size ( GtkWindow *window,gint *width,gint *height);
gboolean gtk_window_get_destroy_with_parent ( GtkWindow *window);
void gtk_window_get_frame_dimensions ( GtkWindow *window,gint *left,gint *top,gint *right,gint *bottom);
gboolean gtk_window_get_has_frame ( GtkWindow *window);
GdkPixbuf* gtk_window_get_icon ( GtkWindow *window);
GdkPixbuf* gtk_window_get_icon ( GtkWindow *window);
GList* gtk_window_get_icon_list ( GtkWindow *window);
gchar* gtk_window_get_icon_name ( GtkWindow *window);
GdkModifierType gtk_window_get_mnemonic_modifier ( GtkWindow *window);
GdkModifierType gtk_window_get_mnemonic_modifier ( GtkWindow *window);
gboolean gtk_window_get_modal ( GtkWindow *window);
void gtk_window_get_position ( GtkWindow *window,gint *root_x,gint *root_y);
const gchar* gtk_window_get_role ( GtkWindow *window);
void gtk_window_get_size ( GtkWindow *window,gint *width,gint *height);
const gchar* gtk_window_get_title ( GtkWindow *window);
GtkWindow* gtk_window_get_transient_for ( GtkWindow *window);
GdkWindowTypeHint gtk_window_get_type_hint ( GtkWindow *window);
GdkWindowTypeHint gtk_window_get_type_hint ( GtkWindow *window);
gboolean gtk_window_get_skip_taskbar_hint ( GtkWindow *window);
gboolean gtk_window_get_skip_pager_hint ( GtkWindow *window);
gboolean gtk_window_get_urgency_hint ( GtkWindow *window);
gboolean gtk_window_get_accept_focus ( GtkWindow *window);
gboolean gtk_window_get_focus_on_map ( GtkWindow *window);
GtkWindowGroup* gtk_window_get_group ( GtkWindow *window);
void gtk_window_move ( GtkWindow *window,gint x,gint y);
gboolean gtk_window_parse_geometry ( GtkWindow *window,const gchar *geometry);
void gtk_window_reshow_with_initial_size ( GtkWindow *window);
void gtk_window_resize ( GtkWindow *window,gint width,gint height);
void gtk_window_set_default_icon_list (GList *list);
void gtk_window_set_default_icon ( GdkPixbuf *icon);
gboolean gtk_window_set_default_icon_from_file (const gchar *filename,GError **err);
void gtk_window_set_default_icon_name (const gchar *name);
void gtk_window_set_icon ( GtkWindow *window, GdkPixbuf *icon);
void gtk_window_set_icon_list ( GtkWindow *window,GList *list);
gboolean gtk_window_set_icon_from_file ( GtkWindow *window,const gchar *filename,GError **err);
void gtk_window_set_icon_name ( GtkWindow *window,const gchar *name);
void gtk_window_set_auto_startup_notification (gboolean setting);
void gtk_decorated_window_init ( GtkWindow *window);
void gtk_decorated_window_calculate_frame_size ( GtkWindow *window);
void gtk_decorated_window_set_title ( GtkWindow *window,const gchar *title);
void gtk_decorated_window_move_resize_window ( GtkWindow *window,gint x,gint y,gint width,gint height);
GtkWindowGroup* gtk_window_group_new (void);
void gtk_window_group_add_window ( GtkWindowGroup *window_group, GtkWindow *window);
void gtk_window_group_remove_window ( GtkWindowGroup *window_group, GtkWindow *window);
GtkWidget* gtk_about_dialog_new (void);
const gchar* gtk_about_dialog_get_name ( GtkAboutDialog *about);
void gtk_about_dialog_set_name ( GtkAboutDialog *about,const gchar *name);
const gchar* gtk_about_dialog_get_version ( GtkAboutDialog *about);
void gtk_about_dialog_set_version ( GtkAboutDialog *about,const gchar *version);
const gchar* gtk_about_dialog_get_copyright ( GtkAboutDialog *about);
void gtk_about_dialog_set_copyright ( GtkAboutDialog *about,const gchar *copyright);
const gchar* gtk_about_dialog_get_comments ( GtkAboutDialog *about);
void gtk_about_dialog_set_comments ( GtkAboutDialog *about,const gchar *comments);
const gchar* gtk_about_dialog_get_license ( GtkAboutDialog *about);
void gtk_about_dialog_set_license ( GtkAboutDialog *about,const gchar *license);
gboolean gtk_about_dialog_get_wrap_license ( GtkAboutDialog *about);
void gtk_about_dialog_set_wrap_license ( GtkAboutDialog *about,gboolean wrap_license);
const gchar* gtk_about_dialog_get_website ( GtkAboutDialog *about);
void gtk_about_dialog_set_website ( GtkAboutDialog *about,const gchar *website);
const gchar* gtk_about_dialog_get_website_label ( GtkAboutDialog *about);
void gtk_about_dialog_set_website_label ( GtkAboutDialog *about,const gchar *website_label);
const gchar* const* gtk_about_dialog_get_authors ( GtkAboutDialog *about);
void gtk_about_dialog_set_authors ( GtkAboutDialog *about,const gchar **authors);
const gchar* const* gtk_about_dialog_get_artists ( GtkAboutDialog *about);
void gtk_about_dialog_set_artists ( GtkAboutDialog *about,const gchar **artists);
const gchar* const* gtk_about_dialog_get_documenters ( GtkAboutDialog *about);
void gtk_about_dialog_set_documenters ( GtkAboutDialog *about,const gchar **documenters);
const gchar* gtk_about_dialog_get_translator_credits ( GtkAboutDialog *about);
void gtk_about_dialog_set_translator_credits ( GtkAboutDialog *about,const gchar *translator_credits);
GdkPixbuf* gtk_about_dialog_get_logo ( GtkAboutDialog *about);
GdkPixbuf* gtk_about_dialog_get_logo ( GtkAboutDialog *about);
void gtk_about_dialog_set_logo ( GtkAboutDialog *about, GdkPixbuf *logo);
const gchar* gtk_about_dialog_get_logo_icon_name ( GtkAboutDialog *about);
void gtk_about_dialog_set_logo_icon_name ( GtkAboutDialog *about,const gchar *icon_name);
GtkAboutDialogActivateLinkFunc gtk_about_dialog_set_email_hook ( GtkAboutDialogActivateLinkFunc func,gpointer data,GDestroyNotify destroy);
GtkAboutDialogActivateLinkFunc gtk_about_dialog_set_url_hook ( GtkAboutDialogActivateLinkFunc func,gpointer data,GDestroyNotify destroy);
void gtk_show_about_dialog ( GtkWindow *parent,const gchar *first_property_name,...);
GtkWidget* gtk_assistant_new (void);
gint gtk_assistant_get_current_page ( GtkAssistant *assistant);
void gtk_assistant_set_current_page ( GtkAssistant *assistant,gint page_num);
gint gtk_assistant_get_n_pages ( GtkAssistant *assistant);
GtkWidget* gtk_assistant_get_nth_page ( GtkAssistant *assistant,gint page_num);
gint gtk_assistant_prepend_page ( GtkAssistant *assistant, GtkWidget *page);
gint gtk_assistant_append_page ( GtkAssistant *assistant, GtkWidget *page);
gint gtk_assistant_insert_page ( GtkAssistant *assistant, GtkWidget *page,gint position);
void gtk_assistant_set_forward_page_func ( GtkAssistant *assistant, GtkAssistantPageFunc page_func,gpointer data,GDestroyNotify destroy);
void gtk_assistant_set_page_type ( GtkAssistant *assistant, GtkWidget *page, GtkAssistantPageType type);
GtkAssistantPageType gtk_assistant_get_page_type ( GtkAssistant *assistant, GtkWidget *page);
void gtk_assistant_set_page_title ( GtkAssistant *assistant, GtkWidget *page,const gchar *title);
const gchar* gtk_assistant_get_page_title ( GtkAssistant *assistant, GtkWidget *page);
void gtk_assistant_set_page_header_image ( GtkAssistant *assistant, GtkWidget *page, GdkPixbuf *pixbuf);
GdkPixbuf* gtk_assistant_get_page_header_image ( GtkAssistant *assistant, GtkWidget *page);
GdkPixbuf* gtk_assistant_get_page_header_image ( GtkAssistant *assistant, GtkWidget *page);
void gtk_assistant_set_page_side_image ( GtkAssistant *assistant, GtkWidget *page, GdkPixbuf *pixbuf);
GdkPixbuf* gtk_assistant_get_page_side_image ( GtkAssistant *assistant, GtkWidget *page);
GdkPixbuf* gtk_assistant_get_page_side_image ( GtkAssistant *assistant, GtkWidget *page);
void gtk_assistant_set_page_complete ( GtkAssistant *assistant, GtkWidget *page,gboolean complete);
gboolean gtk_assistant_get_page_complete ( GtkAssistant *assistant, GtkWidget *page);
void gtk_assistant_add_action_widget ( GtkAssistant *assistant, GtkWidget *child);
void gtk_assistant_remove_action_widget ( GtkAssistant *assistant, GtkWidget *child);
void gtk_assistant_update_buttons_state ( GtkAssistant *assistant);
GtkWidget* gtk_accel_label_new (const gchar *string);
void gtk_accel_label_set_accel_closure ( GtkAccelLabel *accel_label,GClosure *accel_closure);
GtkWidget* gtk_accel_label_get_accel_widget ( GtkAccelLabel *accel_label);
void gtk_accel_label_set_accel_widget ( GtkAccelLabel *accel_label, GtkWidget *accel_widget);
guint gtk_accel_label_get_accel_width ( GtkAccelLabel *accel_label);
gboolean gtk_accel_label_refetch ( GtkAccelLabel *accel_label);
void gtk_image_get_icon_set ( GtkImage *image, GtkIconSet **icon_set, GtkIconSize *size);
void gtk_image_get_image ( GtkImage *image, GdkImage **gdk_image, GdkBitmap **mask);
GdkPixbuf* gtk_image_get_pixbuf ( GtkImage *image);
GdkPixbuf* gtk_image_get_pixbuf ( GtkImage *image);
void gtk_image_get_pixmap ( GtkImage *image, GdkPixmap **pixmap, GdkBitmap **mask);
void gtk_image_get_stock ( GtkImage *image,gchar **stock_id, GtkIconSize *size);
GdkPixbufAnimation* gtk_image_get_animation ( GtkImage *image);
GdkPixbufAnimation* gtk_image_get_animation ( GtkImage *image);
void gtk_image_get_icon_name ( GtkImage *image,G_CONST_RETURN gchar **icon_name, GtkIconSize *size);
GtkImageType gtk_image_get_storage_type ( GtkImage *image);
GtkWidget* gtk_image_new_from_file (const gchar *filename);
GtkWidget* gtk_image_new_from_icon_set ( GtkIconSet *icon_set, GtkIconSize size);
GtkWidget* gtk_image_new_from_image ( GdkImage *image, GdkBitmap *mask);
GtkWidget* gtk_image_new_from_pixbuf ( GdkPixbuf *pixbuf);
GtkWidget* gtk_image_new_from_pixmap ( GdkPixmap *pixmap, GdkBitmap *mask);
GtkWidget* gtk_image_new_from_stock (const gchar *stock_id, GtkIconSize size);
GtkWidget* gtk_image_new_from_animation ( GdkPixbufAnimation *animation);
GtkWidget* gtk_image_new_from_icon_name (const gchar *icon_name, GtkIconSize size);
void gtk_image_set_from_file ( GtkImage *image,const gchar *filename);
void gtk_image_set_from_icon_set ( GtkImage *image, GtkIconSet *icon_set, GtkIconSize size);
void gtk_image_set_from_image ( GtkImage *image, GdkImage *gdk_image, GdkBitmap *mask);
void gtk_image_set_from_pixbuf ( GtkImage *image, GdkPixbuf *pixbuf);
void gtk_image_set_from_pixmap ( GtkImage *image, GdkPixmap *pixmap, GdkBitmap *mask);
void gtk_image_set_from_stock ( GtkImage *image,const gchar *stock_id, GtkIconSize size);
void gtk_image_set_from_animation ( GtkImage *image, GdkPixbufAnimation *animation);
void gtk_image_set_from_icon_name ( GtkImage *image,const gchar *icon_name, GtkIconSize size);
void gtk_image_clear ( GtkImage *image);
GtkWidget* gtk_image_new (void);
void gtk_image_set ( GtkImage *image, GdkImage *val, GdkBitmap *mask);
void gtk_image_get ( GtkImage *image, GdkImage **val, GdkBitmap **mask);
void gtk_image_set_pixel_size ( GtkImage *image,gint pixel_size);
gint gtk_image_get_pixel_size ( GtkImage *image);
GtkWidget* gtk_label_new (const gchar *str);
void gtk_label_set_text ( GtkLabel *label,const gchar *str);
void gtk_label_set_attributes ( GtkLabel *label,PangoAttrList *attrs);
void gtk_label_set_markup ( GtkLabel *label,const gchar *str);
void gtk_label_set_markup_with_mnemonic ( GtkLabel *label,const gchar *str);
void gtk_label_set_pattern ( GtkLabel *label,const gchar *pattern);
void gtk_label_set_justify ( GtkLabel *label, GtkJustification jtype);
void gtk_label_set_ellipsize ( GtkLabel *label,PangoEllipsizeMode mode);
void gtk_label_set_width_chars ( GtkLabel *label,gint n_chars);
void gtk_label_set_max_width_chars ( GtkLabel *label,gint n_chars);
void gtk_label_get ( GtkLabel *label,gchar **str);
guint gtk_label_parse_uline ( GtkLabel *label,const gchar *string);
void gtk_label_set_line_wrap ( GtkLabel *label,gboolean wrap);
void gtk_label_set_line_wrap_mode ( GtkLabel *label,PangoWrapMode wrap_mode);
void gtk_label_get_layout_offsets ( GtkLabel *label,gint *x,gint *y);
guint gtk_label_get_mnemonic_keyval ( GtkLabel *label);
gboolean gtk_label_get_selectable ( GtkLabel *label);
const gchar* gtk_label_get_text ( GtkLabel *label);
GtkWidget* gtk_label_new_with_mnemonic (const gchar *str);
void gtk_label_select_region ( GtkLabel *label,gint start_offset,gint end_offset);
void gtk_label_set_mnemonic_widget ( GtkLabel *label, GtkWidget *widget);
void gtk_label_set_selectable ( GtkLabel *label,gboolean setting);
void gtk_label_set_text_with_mnemonic ( GtkLabel *label,const gchar *str);
PangoAttrList* gtk_label_get_attributes ( GtkLabel *label);
GtkJustification gtk_label_get_justify ( GtkLabel *label);
PangoEllipsizeMode gtk_label_get_ellipsize ( GtkLabel *label);
gint gtk_label_get_width_chars ( GtkLabel *label);
gint gtk_label_get_max_width_chars ( GtkLabel *label);
const gchar* gtk_label_get_label ( GtkLabel *label);
PangoLayout* gtk_label_get_layout ( GtkLabel *label);
gboolean gtk_label_get_line_wrap ( GtkLabel *label);
PangoWrapMode gtk_label_get_line_wrap_mode ( GtkLabel *label);
GtkWidget* gtk_label_get_mnemonic_widget ( GtkLabel *label);
gboolean gtk_label_get_selection_bounds ( GtkLabel *label,gint *start,gint *end);
gboolean gtk_label_get_use_markup ( GtkLabel *label);
gboolean gtk_label_get_use_underline ( GtkLabel *label);
gboolean gtk_label_get_single_line_mode ( GtkLabel *label);
gdouble gtk_label_get_angle ( GtkLabel *label);
void gtk_label_set_label ( GtkLabel *label,const gchar *str);
void gtk_label_set_use_markup ( GtkLabel *label,gboolean setting);
void gtk_label_set_use_underline ( GtkLabel *label,gboolean setting);
void gtk_label_set_single_line_mode ( GtkLabel *label,gboolean single_line_mode);
void gtk_label_set_angle ( GtkLabel *label,gdouble angle);
GtkWidget* gtk_progress_bar_new (void);
void gtk_progress_bar_pulse ( GtkProgressBar *pbar);
void gtk_progress_bar_set_text ( GtkProgressBar *pbar,const gchar *text);
void gtk_progress_bar_set_fraction ( GtkProgressBar *pbar,gdouble fraction);
void gtk_progress_bar_set_pulse_step ( GtkProgressBar *pbar,gdouble fraction);
void gtk_progress_bar_set_orientation ( GtkProgressBar *pbar, GtkProgressBarOrientation orientation);
void gtk_progress_bar_set_ellipsize ( GtkProgressBar *pbar,PangoEllipsizeMode mode);
const gchar* gtk_progress_bar_get_text ( GtkProgressBar *pbar);
gdouble gtk_progress_bar_get_fraction ( GtkProgressBar *pbar);
gdouble gtk_progress_bar_get_pulse_step ( GtkProgressBar *pbar);
GtkProgressBarOrientation gtk_progress_bar_get_orientation ( GtkProgressBar *pbar);
PangoEllipsizeMode gtk_progress_bar_get_ellipsize ( GtkProgressBar *pbar);
GtkWidget* gtk_progress_bar_new_with_adjustment ( GtkAdjustment *adjustment);
void gtk_progress_bar_set_bar_style ( GtkProgressBar *pbar, GtkProgressBarStyle style);
void gtk_progress_bar_set_discrete_blocks ( GtkProgressBar *pbar,guint blocks);
void gtk_progress_bar_set_activity_step ( GtkProgressBar *pbar,guint step);
void gtk_progress_bar_set_activity_blocks ( GtkProgressBar *pbar,guint blocks);
void gtk_progress_bar_update ( GtkProgressBar *pbar,gdouble percentage);
GtkWidget* gtk_statusbar_new (void);
guint gtk_statusbar_get_context_id ( GtkStatusbar *statusbar,const gchar *context_description);
guint gtk_statusbar_push ( GtkStatusbar *statusbar,guint context_id,const gchar *text);
void gtk_statusbar_pop ( GtkStatusbar *statusbar,guint context_id);
void gtk_statusbar_remove ( GtkStatusbar *statusbar,guint context_id,guint message_id);
void gtk_statusbar_set_has_resize_grip ( GtkStatusbar *statusbar,gboolean setting);
gboolean gtk_statusbar_get_has_resize_grip ( GtkStatusbar *statusbar);
GtkStatusIcon* gtk_status_icon_new (void);
GtkStatusIcon* gtk_status_icon_new_from_pixbuf ( GdkPixbuf *pixbuf);
GtkStatusIcon* gtk_status_icon_new_from_file (const gchar *filename);
GtkStatusIcon* gtk_status_icon_new_from_stock (const gchar *stock_id);
GtkStatusIcon* gtk_status_icon_new_from_icon_name (const gchar *icon_name);
void gtk_status_icon_set_from_pixbuf ( GtkStatusIcon *status_icon, GdkPixbuf *pixbuf);
void gtk_status_icon_set_from_file ( GtkStatusIcon *status_icon,const gchar *filename);
void gtk_status_icon_set_from_stock ( GtkStatusIcon *status_icon,const gchar *stock_id);
void gtk_status_icon_set_from_icon_name ( GtkStatusIcon *status_icon,const gchar *icon_name);
GtkImageType gtk_status_icon_get_storage_type ( GtkStatusIcon *status_icon);
GdkPixbuf* gtk_status_icon_get_pixbuf ( GtkStatusIcon *status_icon);
GdkPixbuf* gtk_status_icon_get_pixbuf ( GtkStatusIcon *status_icon);
const gchar* gtk_status_icon_get_stock ( GtkStatusIcon *status_icon);
const gchar* gtk_status_icon_get_icon_name ( GtkStatusIcon *status_icon);
gint gtk_status_icon_get_size ( GtkStatusIcon *status_icon);
void gtk_status_icon_set_tooltip ( GtkStatusIcon *status_icon,const gchar *tooltip_text);
void gtk_status_icon_set_visible ( GtkStatusIcon *status_icon,gboolean visible);
gboolean gtk_status_icon_get_visible ( GtkStatusIcon *status_icon);
void gtk_status_icon_set_blinking ( GtkStatusIcon *status_icon,gboolean blinking);
gboolean gtk_status_icon_get_blinking ( GtkStatusIcon *status_icon);
gboolean gtk_status_icon_is_embedded ( GtkStatusIcon *status_icon);
void gtk_status_icon_position_menu ( GtkMenu *menu,gint *x,gint *y,gboolean *push_in,gpointer user_data);
gboolean gtk_status_icon_get_geometry ( GtkStatusIcon *status_icon, GdkScreen **screen, GdkRectangle *area, GtkOrientation *orientation);
GtkWidget* gtk_button_new (void);
GtkWidget* gtk_button_new_with_label (const gchar *label);
GtkWidget* gtk_button_new_with_mnemonic (const gchar *label);
GtkWidget* gtk_button_new_from_stock (const gchar *stock_id);
void gtk_button_pressed ( GtkButton *button);
void gtk_button_released ( GtkButton *button);
void gtk_button_clicked ( GtkButton *button);
void gtk_button_enter ( GtkButton *button);
void gtk_button_leave ( GtkButton *button);
void gtk_button_set_relief ( GtkButton *button, GtkReliefStyle newstyle);
GtkReliefStyle gtk_button_get_relief ( GtkButton *button);
const gchar* gtk_button_get_label ( GtkButton *button);
void gtk_button_set_label ( GtkButton *button,const gchar *label);
gboolean gtk_button_get_use_stock ( GtkButton *button);
void gtk_button_set_use_stock ( GtkButton *button,gboolean use_stock);
gboolean gtk_button_get_use_underline ( GtkButton *button);
void gtk_button_set_use_underline ( GtkButton *button,gboolean use_underline);
void gtk_button_set_focus_on_click ( GtkButton *button,gboolean focus_on_click);
gboolean gtk_button_get_focus_on_click ( GtkButton *button);
void gtk_button_set_alignment ( GtkButton *button,gfloat xalign,gfloat yalign);
void gtk_button_get_alignment ( GtkButton *button,gfloat *xalign,gfloat *yalign);
void gtk_button_set_image ( GtkButton *button, GtkWidget *image);
GtkWidget* gtk_button_get_image ( GtkButton *button);
void gtk_button_set_image_position ( GtkButton *button, GtkPositionType position);
GtkPositionType gtk_button_get_image_position ( GtkButton *button);
GtkWidget* gtk_check_button_new (void);
GtkWidget* gtk_check_button_new_with_label (const gchar *label);
GtkWidget* gtk_check_button_new_with_mnemonic (const gchar *label);
GtkWidget* gtk_radio_button_new (GSList *group);
GtkWidget* gtk_radio_button_new_from_widget ( GtkRadioButton *group);
GtkWidget* gtk_radio_button_new_with_label (GSList *group,const gchar *label);
GtkWidget* gtk_radio_button_new_with_label_from_widget ( GtkRadioButton *group,const gchar *label);
GtkWidget* gtk_radio_button_new_with_mnemonic (GSList *group,const gchar *label);
GtkWidget* gtk_radio_button_new_with_mnemonic_from_widget ( GtkRadioButton *group,const gchar *label);
void gtk_radio_button_set_group ( GtkRadioButton *radio_button,GSList *group);
GSList* gtk_radio_button_get_group ( GtkRadioButton *radio_button);
GtkWidget* gtk_toggle_button_new (void);
GtkWidget* gtk_toggle_button_new_with_label (const gchar *label);
GtkWidget* gtk_toggle_button_new_with_mnemonic (const gchar *label);
void gtk_toggle_button_set_mode ( GtkToggleButton *toggle_button,gboolean draw_indicator);
gboolean gtk_toggle_button_get_mode ( GtkToggleButton *toggle_button);
void gtk_toggle_button_toggled ( GtkToggleButton *toggle_button);
gboolean gtk_toggle_button_get_active ( GtkToggleButton *toggle_button);
void gtk_toggle_button_set_active ( GtkToggleButton *toggle_button,gboolean is_active);
gboolean gtk_toggle_button_get_inconsistent ( GtkToggleButton *toggle_button);
void gtk_toggle_button_set_inconsistent ( GtkToggleButton *toggle_button,gboolean setting);
GtkWidget* gtk_link_button_new (const gchar *uri);
GtkWidget* gtk_link_button_new_with_label (const gchar *uri,const gchar *label);
const gchar* gtk_link_button_get_uri ( GtkLinkButton *link_button);
void gtk_link_button_set_uri ( GtkLinkButton *link_button,const gchar *uri);
GtkWidget* gtk_entry_new (void);
GtkWidget* gtk_entry_new_with_max_length (gint max);
void gtk_entry_set_text ( GtkEntry *entry,const gchar *text);
void gtk_entry_append_text ( GtkEntry *entry,const gchar *text);
void gtk_entry_prepend_text ( GtkEntry *entry,const gchar *text);
void gtk_entry_set_position ( GtkEntry *entry,gint position);
const gchar* gtk_entry_get_text ( GtkEntry *entry);
void gtk_entry_select_region ( GtkEntry *entry,gint start,gint end);
void gtk_entry_set_visibility ( GtkEntry *entry,gboolean visible);
void gtk_entry_set_invisible_char ( GtkEntry *entry,gunichar ch);
void gtk_entry_set_editable ( GtkEntry *entry,gboolean editable);
void gtk_entry_set_max_length ( GtkEntry *entry,gint max);
gboolean gtk_entry_get_activates_default ( GtkEntry *entry);
gboolean gtk_entry_get_has_frame ( GtkEntry *entry);
const GtkBorder* gtk_entry_get_inner_border ( GtkEntry *entry);
gint gtk_entry_get_width_chars ( GtkEntry *entry);
void gtk_entry_set_activates_default ( GtkEntry *entry,gboolean setting);
void gtk_entry_set_has_frame ( GtkEntry *entry,gboolean setting);
void gtk_entry_set_inner_border ( GtkEntry *entry,const GtkBorder *border);
void gtk_entry_set_width_chars ( GtkEntry *entry,gint n_chars);
gunichar gtk_entry_get_invisible_char ( GtkEntry *entry);
void gtk_entry_set_alignment ( GtkEntry *entry,gfloat xalign);
gfloat gtk_entry_get_alignment ( GtkEntry *entry);
PangoLayout* gtk_entry_get_layout ( GtkEntry *entry);
void gtk_entry_get_layout_offsets ( GtkEntry *entry,gint *x,gint *y);
gint gtk_entry_layout_index_to_text_index ( GtkEntry *entry,gint layout_index);
gint gtk_entry_text_index_to_layout_index ( GtkEntry *entry,gint text_index);
gint gtk_entry_get_max_length ( GtkEntry *entry);
gboolean gtk_entry_get_visibility ( GtkEntry *entry);
void gtk_entry_set_completion ( GtkEntry *entry, GtkEntryCompletion *completion);
GtkEntryCompletion* gtk_entry_get_completion ( GtkEntry *entry);
GtkEntryCompletion* gtk_entry_completion_new (void);
GtkWidget* gtk_entry_completion_get_entry ( GtkEntryCompletion *completion);
void gtk_entry_completion_set_model ( GtkEntryCompletion *completion, GtkTreeModel *model);
GtkTreeModel* gtk_entry_completion_get_model ( GtkEntryCompletion *completion);
void gtk_entry_completion_set_match_func ( GtkEntryCompletion *completion, GtkEntryCompletionMatchFunc func,gpointer func_data,GDestroyNotify func_notify);
void gtk_entry_completion_set_minimum_key_length ( GtkEntryCompletion *completion,gint length);
gint gtk_entry_completion_get_minimum_key_length ( GtkEntryCompletion *completion);
void gtk_entry_completion_complete ( GtkEntryCompletion *completion);
void gtk_entry_completion_insert_prefix ( GtkEntryCompletion *completion);
void gtk_entry_completion_insert_action_text ( GtkEntryCompletion *completion,gint index_,const gchar *text);
void gtk_entry_completion_insert_action_markup ( GtkEntryCompletion *completion,gint index_,const gchar *markup);
void gtk_entry_completion_delete_action ( GtkEntryCompletion *completion,gint index_);
void gtk_entry_completion_set_text_column ( GtkEntryCompletion *completion,gint column);
gint gtk_entry_completion_get_text_column ( GtkEntryCompletion *completion);
void gtk_entry_completion_set_inline_completion ( GtkEntryCompletion *completion,gboolean inline_completion);
gboolean gtk_entry_completion_get_inline_completion ( GtkEntryCompletion *completion);
void gtk_entry_completion_set_popup_completion ( GtkEntryCompletion *completion,gboolean popup_completion);
gboolean gtk_entry_completion_get_popup_completion ( GtkEntryCompletion *completion);
void gtk_entry_completion_set_popup_set_width ( GtkEntryCompletion *completion,gboolean popup_set_width);
gboolean gtk_entry_completion_get_popup_set_width ( GtkEntryCompletion *completion);
void gtk_entry_completion_set_popup_single_match ( GtkEntryCompletion *completion,gboolean popup_single_match);
gboolean gtk_entry_completion_get_popup_single_match ( GtkEntryCompletion *completion);
GtkWidget* gtk_hscale_new ( GtkAdjustment *adjustment);
GtkWidget* gtk_hscale_new_with_range (gdouble min,gdouble max,gdouble step);
GtkWidget* gtk_vscale_new ( GtkAdjustment *adjustment);
GtkWidget* gtk_vscale_new_with_range (gdouble min,gdouble max,gdouble step);
void gtk_spin_button_configure ( GtkSpinButton *spin_button, GtkAdjustment *adjustment,gdouble climb_rate,guint digits);
GtkWidget* gtk_spin_button_new ( GtkAdjustment *adjustment,gdouble climb_rate,guint digits);
GtkWidget* gtk_spin_button_new_with_range (gdouble min,gdouble max,gdouble step);
void gtk_spin_button_set_adjustment ( GtkSpinButton *spin_button, GtkAdjustment *adjustment);
GtkAdjustment* gtk_spin_button_get_adjustment ( GtkSpinButton *spin_button);
void gtk_spin_button_set_digits ( GtkSpinButton *spin_button,guint digits);
void gtk_spin_button_set_increments ( GtkSpinButton *spin_button,gdouble step,gdouble page);
void gtk_spin_button_set_range ( GtkSpinButton *spin_button,gdouble min,gdouble max);
gint gtk_spin_button_get_value_as_int ( GtkSpinButton *spin_button);
void gtk_spin_button_set_value ( GtkSpinButton *spin_button,gdouble value);
void gtk_spin_button_set_update_policy ( GtkSpinButton *spin_button, GtkSpinButtonUpdatePolicy policy);
void gtk_spin_button_set_numeric ( GtkSpinButton *spin_button,gboolean numeric);
void gtk_spin_button_spin ( GtkSpinButton *spin_button, GtkSpinType direction,gdouble increment);
void gtk_spin_button_set_wrap ( GtkSpinButton *spin_button,gboolean wrap);
void gtk_spin_button_set_snap_to_ticks ( GtkSpinButton *spin_button,gboolean snap_to_ticks);
void gtk_spin_button_update ( GtkSpinButton *spin_button);
guint gtk_spin_button_get_digits ( GtkSpinButton *spin_button);
void gtk_spin_button_get_increments ( GtkSpinButton *spin_button,gdouble *step,gdouble *page);
gboolean gtk_spin_button_get_numeric ( GtkSpinButton *spin_button);
void gtk_spin_button_get_range ( GtkSpinButton *spin_button,gdouble *min,gdouble *max);
gboolean gtk_spin_button_get_snap_to_ticks ( GtkSpinButton *spin_button);
GtkSpinButtonUpdatePolicy gtk_spin_button_get_update_policy ( GtkSpinButton *spin_button);
gdouble gtk_spin_button_get_value ( GtkSpinButton *spin_button);
gboolean gtk_spin_button_get_wrap ( GtkSpinButton *spin_button);
void gtk_editable_select_region ( GtkEditable *editable,gint start,gint end);
gboolean gtk_editable_get_selection_bounds ( GtkEditable *editable,gint *start,gint *end);
void gtk_editable_insert_text ( GtkEditable *editable,const gchar *new_text,gint new_text_length,gint *position);
void gtk_editable_delete_text ( GtkEditable *editable,gint start_pos,gint end_pos);
gchar* gtk_editable_get_chars ( GtkEditable *editable,gint start_pos,gint end_pos);
void gtk_editable_cut_clipboard ( GtkEditable *editable);
void gtk_editable_copy_clipboard ( GtkEditable *editable);
void gtk_editable_paste_clipboard ( GtkEditable *editable);
void gtk_editable_delete_selection ( GtkEditable *editable);
void gtk_editable_set_position ( GtkEditable *editable,gint position);
gint gtk_editable_get_position ( GtkEditable *editable);
void gtk_editable_set_editable ( GtkEditable *editable,gboolean is_editable);
gboolean gtk_editable_get_editable ( GtkEditable *editable);
GtkTextBuffer* gtk_text_iter_get_buffer (const GtkTextIter *iter);
GtkTextIter* gtk_text_iter_copy (const GtkTextIter *iter);
void gtk_text_iter_free ( GtkTextIter *iter);
gint gtk_text_iter_get_offset (const GtkTextIter *iter);
gint gtk_text_iter_get_line (const GtkTextIter *iter);
gint gtk_text_iter_get_line_offset (const GtkTextIter *iter);
gint gtk_text_iter_get_line_index (const GtkTextIter *iter);
gint gtk_text_iter_get_visible_line_index (const GtkTextIter *iter);
gint gtk_text_iter_get_visible_line_offset (const GtkTextIter *iter);
gunichar gtk_text_iter_get_char (const GtkTextIter *iter);
gchar* gtk_text_iter_get_slice (const GtkTextIter *start,const GtkTextIter *end);
gchar* gtk_text_iter_get_text (const GtkTextIter *start,const GtkTextIter *end);
gchar* gtk_text_iter_get_visible_slice (const GtkTextIter *start,const GtkTextIter *end);
gchar* gtk_text_iter_get_visible_text (const GtkTextIter *start,const GtkTextIter *end);
GdkPixbuf* gtk_text_iter_get_pixbuf (const GtkTextIter *iter);
GdkPixbuf* gtk_text_iter_get_pixbuf (const GtkTextIter *iter);
GSList* gtk_text_iter_get_marks (const GtkTextIter *iter);
GSList* gtk_text_iter_get_toggled_tags (const GtkTextIter *iter,gboolean toggled_on);
GtkTextChildAnchor* gtk_text_iter_get_child_anchor (const GtkTextIter *iter);
gboolean gtk_text_iter_begins_tag (const GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_ends_tag (const GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_toggles_tag (const GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_has_tag (const GtkTextIter *iter, GtkTextTag *tag);
GSList* gtk_text_iter_get_tags (const GtkTextIter *iter);
gboolean gtk_text_iter_editable (const GtkTextIter *iter,gboolean default_setting);
gboolean gtk_text_iter_can_insert (const GtkTextIter *iter,gboolean default_editability);
gboolean gtk_text_iter_starts_word (const GtkTextIter *iter);
gboolean gtk_text_iter_ends_word (const GtkTextIter *iter);
gboolean gtk_text_iter_inside_word (const GtkTextIter *iter);
gboolean gtk_text_iter_starts_line (const GtkTextIter *iter);
gboolean gtk_text_iter_ends_line (const GtkTextIter *iter);
gboolean gtk_text_iter_starts_sentence (const GtkTextIter *iter);
gboolean gtk_text_iter_ends_sentence (const GtkTextIter *iter);
gboolean gtk_text_iter_inside_sentence (const GtkTextIter *iter);
gboolean gtk_text_iter_is_cursor_position (const GtkTextIter *iter);
gint gtk_text_iter_get_chars_in_line (const GtkTextIter *iter);
gint gtk_text_iter_get_bytes_in_line (const GtkTextIter *iter);
gboolean gtk_text_iter_get_attributes (const GtkTextIter *iter, GtkTextAttributes *values);
PangoLanguage* gtk_text_iter_get_language (const GtkTextIter *iter);
gboolean gtk_text_iter_is_end (const GtkTextIter *iter);
gboolean gtk_text_iter_is_start (const GtkTextIter *iter);
gboolean gtk_text_iter_forward_char ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_char ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_chars ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_chars ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_forward_line ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_line ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_lines ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_lines ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_forward_word_ends ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_word_starts ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_forward_word_end ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_word_start ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_cursor_position ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_cursor_position ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_cursor_positions ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_cursor_positions ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_sentence_start ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_sentence_starts ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_forward_sentence_end ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_sentence_ends ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_forward_visible_word_ends ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_visible_word_starts ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_forward_visible_word_end ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_visible_word_start ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_visible_cursor_position ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_visible_cursor_position ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_visible_cursor_positions ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_visible_cursor_positions ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_forward_visible_line ( GtkTextIter *iter);
gboolean gtk_text_iter_backward_visible_line ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_visible_lines ( GtkTextIter *iter,gint count);
gboolean gtk_text_iter_backward_visible_lines ( GtkTextIter *iter,gint count);
void gtk_text_iter_set_offset ( GtkTextIter *iter,gint char_offset);
void gtk_text_iter_set_line ( GtkTextIter *iter,gint line_number);
void gtk_text_iter_set_line_offset ( GtkTextIter *iter,gint char_on_line);
void gtk_text_iter_set_line_index ( GtkTextIter *iter,gint byte_on_line);
void gtk_text_iter_set_visible_line_index ( GtkTextIter *iter,gint byte_on_line);
void gtk_text_iter_set_visible_line_offset ( GtkTextIter *iter,gint char_on_line);
void gtk_text_iter_forward_to_end ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_to_line_end ( GtkTextIter *iter);
gboolean gtk_text_iter_forward_to_tag_toggle ( GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_backward_to_tag_toggle ( GtkTextIter *iter, GtkTextTag *tag);
gboolean gtk_text_iter_forward_find_char ( GtkTextIter *iter, GtkTextCharPredicate pred,gpointer user_data,const GtkTextIter *limit);
gboolean gtk_text_iter_backward_find_char ( GtkTextIter *iter, GtkTextCharPredicate pred,gpointer user_data,const GtkTextIter *limit);
gboolean gtk_text_iter_forward_search (const GtkTextIter *iter,const gchar *str, GtkTextSearchFlags flags, GtkTextIter *match_start, GtkTextIter *match_end,const GtkTextIter *limit);
gboolean gtk_text_iter_backward_search (const GtkTextIter *iter,const gchar *str, GtkTextSearchFlags flags, GtkTextIter *match_start, GtkTextIter *match_end,const GtkTextIter *limit);
gboolean gtk_text_iter_equal (const GtkTextIter *lhs,const GtkTextIter *rhs);
gint gtk_text_iter_compare (const GtkTextIter *lhs,const GtkTextIter *rhs);
gboolean gtk_text_iter_in_range (const GtkTextIter *iter,const GtkTextIter *start,const GtkTextIter *end);
void gtk_text_iter_order ( GtkTextIter *first, GtkTextIter *second);
void gtk_text_mark_set_visible ( GtkTextMark *mark,gboolean setting);
gboolean gtk_text_mark_get_visible ( GtkTextMark *mark);
gboolean gtk_text_mark_get_deleted ( GtkTextMark *mark);
const gchar* gtk_text_mark_get_name ( GtkTextMark *mark);
GtkTextBuffer* gtk_text_mark_get_buffer ( GtkTextMark *mark);
gboolean gtk_text_mark_get_left_gravity ( GtkTextMark *mark);
GtkTextBuffer* gtk_text_buffer_new ( GtkTextTagTable *table);
gint gtk_text_buffer_get_line_count ( GtkTextBuffer *buffer);
gint gtk_text_buffer_get_char_count ( GtkTextBuffer *buffer);
GtkTextTagTable* gtk_text_buffer_get_tag_table ( GtkTextBuffer *buffer);
void gtk_text_buffer_insert ( GtkTextBuffer *buffer, GtkTextIter *iter,const gchar *text,gint len);
void gtk_text_buffer_insert_at_cursor ( GtkTextBuffer *buffer,const gchar *text,gint len);
gboolean gtk_text_buffer_insert_interactive ( GtkTextBuffer *buffer, GtkTextIter *iter,const gchar *text,gint len,gboolean default_editable);
gboolean gtk_text_buffer_insert_interactive_at_cursor ( GtkTextBuffer *buffer,const gchar *text,gint len,gboolean default_editable);
void gtk_text_buffer_insert_range ( GtkTextBuffer *buffer, GtkTextIter *iter,const GtkTextIter *start,const GtkTextIter *end);
gboolean gtk_text_buffer_insert_range_interactive ( GtkTextBuffer *buffer, GtkTextIter *iter,const GtkTextIter *start,const GtkTextIter *end,gboolean default_editable);
void gtk_text_buffer_insert_with_tags ( GtkTextBuffer *buffer, GtkTextIter *iter,const gchar *text,gint len, GtkTextTag *first_tag,...);
void gtk_text_buffer_insert_with_tags_by_name ( GtkTextBuffer *buffer, GtkTextIter *iter,const gchar *text,gint len,const gchar *first_tag_name,...);
void gtk_text_buffer_delete ( GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end);
gboolean gtk_text_buffer_delete_interactive ( GtkTextBuffer *buffer, GtkTextIter *start_iter, GtkTextIter *end_iter,gboolean default_editable);
gboolean gtk_text_buffer_backspace ( GtkTextBuffer *buffer, GtkTextIter *iter,gboolean interactive,gboolean default_editable);
void gtk_text_buffer_set_text ( GtkTextBuffer *buffer,const gchar *text,gint len);
gchar* gtk_text_buffer_get_text ( GtkTextBuffer *buffer,const GtkTextIter *start,const GtkTextIter *end,gboolean include_hidden_chars);
gchar* gtk_text_buffer_get_slice ( GtkTextBuffer *buffer,const GtkTextIter *start,const GtkTextIter *end,gboolean include_hidden_chars);
void gtk_text_buffer_insert_pixbuf ( GtkTextBuffer *buffer, GtkTextIter *iter, GdkPixbuf *pixbuf);
void gtk_text_buffer_insert_child_anchor ( GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextChildAnchor *anchor);
GtkTextChildAnchor* gtk_text_buffer_create_child_anchor ( GtkTextBuffer *buffer, GtkTextIter *iter);
GtkTextMark* gtk_text_buffer_create_mark ( GtkTextBuffer *buffer,const gchar *mark_name,const GtkTextIter *where,gboolean left_gravity);
void gtk_text_buffer_move_mark ( GtkTextBuffer *buffer, GtkTextMark *mark,const GtkTextIter *where);
void gtk_text_buffer_move_mark_by_name ( GtkTextBuffer *buffer,const gchar *name,const GtkTextIter *where);
void gtk_text_buffer_delete_mark ( GtkTextBuffer *buffer, GtkTextMark *mark);
void gtk_text_buffer_delete_mark_by_name ( GtkTextBuffer *buffer,const gchar *name);
GtkTextMark* gtk_text_buffer_get_mark ( GtkTextBuffer *buffer,const gchar *name);
GtkTextMark* gtk_text_buffer_get_insert ( GtkTextBuffer *buffer);
GtkTextMark* gtk_text_buffer_get_selection_bound ( GtkTextBuffer *buffer);
gboolean gtk_text_buffer_get_has_selection ( GtkTextBuffer *buffer);
void gtk_text_buffer_place_cursor ( GtkTextBuffer *buffer,const GtkTextIter *where);
void gtk_text_buffer_select_range ( GtkTextBuffer *buffer,const GtkTextIter *ins,const GtkTextIter *bound);
void gtk_text_buffer_apply_tag ( GtkTextBuffer *buffer, GtkTextTag *tag,const GtkTextIter *start,const GtkTextIter *end);
void gtk_text_buffer_remove_tag ( GtkTextBuffer *buffer, GtkTextTag *tag,const GtkTextIter *start,const GtkTextIter *end);
void gtk_text_buffer_apply_tag_by_name ( GtkTextBuffer *buffer,const gchar *name,const GtkTextIter *start,const GtkTextIter *end);
void gtk_text_buffer_remove_tag_by_name ( GtkTextBuffer *buffer,const gchar *name,const GtkTextIter *start,const GtkTextIter *end);
void gtk_text_buffer_remove_all_tags ( GtkTextBuffer *buffer,const GtkTextIter *start,const GtkTextIter *end);
GtkTextTag* gtk_text_buffer_create_tag ( GtkTextBuffer *buffer,const gchar *tag_name,const gchar *first_property_name,...);
void gtk_text_buffer_get_iter_at_line_offset ( GtkTextBuffer *buffer, GtkTextIter *iter,gint line_number,gint char_offset);
void gtk_text_buffer_get_iter_at_offset ( GtkTextBuffer *buffer, GtkTextIter *iter,gint char_offset);
void gtk_text_buffer_get_iter_at_line ( GtkTextBuffer *buffer, GtkTextIter *iter,gint line_number);
void gtk_text_buffer_get_iter_at_line_index ( GtkTextBuffer *buffer, GtkTextIter *iter,gint line_number,gint byte_index);
void gtk_text_buffer_get_iter_at_mark ( GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextMark *mark);
void gtk_text_buffer_get_iter_at_child_anchor ( GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextChildAnchor *anchor);
void gtk_text_buffer_get_start_iter ( GtkTextBuffer *buffer, GtkTextIter *iter);
void gtk_text_buffer_get_end_iter ( GtkTextBuffer *buffer, GtkTextIter *iter);
void gtk_text_buffer_get_bounds ( GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end);
gboolean gtk_text_buffer_get_modified ( GtkTextBuffer *buffer);
void gtk_text_buffer_set_modified ( GtkTextBuffer *buffer,gboolean setting);
gboolean gtk_text_buffer_delete_selection ( GtkTextBuffer *buffer,gboolean interactive,gboolean default_editable);
void gtk_text_buffer_paste_clipboard ( GtkTextBuffer *buffer, GtkClipboard *clipboard, GtkTextIter *override_location,gboolean default_editable);
void gtk_text_buffer_copy_clipboard ( GtkTextBuffer *buffer, GtkClipboard *clipboard);
void gtk_text_buffer_cut_clipboard ( GtkTextBuffer *buffer, GtkClipboard *clipboard,gboolean default_editable);
gboolean gtk_text_buffer_get_selection_bounds ( GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end);
void gtk_text_buffer_begin_user_action ( GtkTextBuffer *buffer);
void gtk_text_buffer_end_user_action ( GtkTextBuffer *buffer);
void gtk_text_buffer_add_selection_clipboard ( GtkTextBuffer *buffer, GtkClipboard *clipboard);
void gtk_text_buffer_remove_selection_clipboard ( GtkTextBuffer *buffer, GtkClipboard *clipboard);
gboolean gtk_text_buffer_deserialize ( GtkTextBuffer *register_buffer, GtkTextBuffer *content_buffer, GdkAtom format, GtkTextIter *iter,const guint8 *data,gsize length,GError **error);
gboolean gtk_text_buffer_deserialize_get_can_create_tags ( GtkTextBuffer *buffer, GdkAtom format);
void gtk_text_buffer_deserialize_set_can_create_tags ( GtkTextBuffer *buffer, GdkAtom format,gboolean can_create_tags);
GtkTargetList* gtk_text_buffer_get_copy_target_list ( GtkTextBuffer *buffer);
GdkAtom* gtk_text_buffer_get_deserialize_formats ( GtkTextBuffer *buffer,gint *n_formats);
GdkAtom* gtk_text_buffer_get_deserialize_formats ( GtkTextBuffer *buffer,gint *n_formats);
GtkTargetList* gtk_text_buffer_get_paste_target_list ( GtkTextBuffer *buffer);
GdkAtom* gtk_text_buffer_get_serialize_formats ( GtkTextBuffer *buffer,gint *n_formats);
GdkAtom* gtk_text_buffer_get_serialize_formats ( GtkTextBuffer *buffer,gint *n_formats);
GdkAtom gtk_text_buffer_register_deserialize_format ( GtkTextBuffer *buffer,const gchar *mime_type, GtkTextBufferDeserializeFunc function,gpointer user_data,GDestroyNotify user_data_destroy);
GdkAtom gtk_text_buffer_register_deserialize_format ( GtkTextBuffer *buffer,const gchar *mime_type, GtkTextBufferDeserializeFunc function,gpointer user_data,GDestroyNotify user_data_destroy);
GdkAtom gtk_text_buffer_register_deserialize_tagset ( GtkTextBuffer *buffer,const gchar *tagset_name);
GdkAtom gtk_text_buffer_register_deserialize_tagset ( GtkTextBuffer *buffer,const gchar *tagset_name);
GdkAtom gtk_text_buffer_register_serialize_format ( GtkTextBuffer *buffer,const gchar *mime_type, GtkTextBufferSerializeFunc function,gpointer user_data,GDestroyNotify user_data_destroy);
GdkAtom gtk_text_buffer_register_serialize_format ( GtkTextBuffer *buffer,const gchar *mime_type, GtkTextBufferSerializeFunc function,gpointer user_data,GDestroyNotify user_data_destroy);
GdkAtom gtk_text_buffer_register_serialize_tagset ( GtkTextBuffer *buffer,const gchar *tagset_name);
GdkAtom gtk_text_buffer_register_serialize_tagset ( GtkTextBuffer *buffer,const gchar *tagset_name);
guint8* gtk_text_buffer_serialize ( GtkTextBuffer *register_buffer, GtkTextBuffer *content_buffer, GdkAtom format,const GtkTextIter *start,const GtkTextIter *end,gsize *length);
void gtk_text_buffer_unregister_deserialize_format ( GtkTextBuffer *buffer, GdkAtom format);
void gtk_text_buffer_unregister_serialize_format ( GtkTextBuffer *buffer, GdkAtom format);
GtkTextTag* gtk_text_tag_new (const gchar *name);
gint gtk_text_tag_get_priority ( GtkTextTag *tag);
void gtk_text_tag_set_priority ( GtkTextTag *tag,gint priority);
gboolean gtk_text_tag_event ( GtkTextTag *tag,GObject *event_object, GdkEvent *event,const GtkTextIter *iter); GtkTextAppearance ;
GtkTextAttributes* gtk_text_attributes_new (void);
GtkTextAttributes* gtk_text_attributes_copy ( GtkTextAttributes *src);
void gtk_text_attributes_copy_values ( GtkTextAttributes *src, GtkTextAttributes *dest);
void gtk_text_attributes_unref ( GtkTextAttributes *values);
GtkTextAttributes* gtk_text_attributes_ref ( GtkTextAttributes *values);
GtkTextTagTable* gtk_text_tag_table_new (void);
void gtk_text_tag_table_add ( GtkTextTagTable *table, GtkTextTag *tag);
void gtk_text_tag_table_remove ( GtkTextTagTable *table, GtkTextTag *tag);
GtkTextTag* gtk_text_tag_table_lookup ( GtkTextTagTable *table,const gchar *name);
void gtk_text_tag_table_foreach ( GtkTextTagTable *table, GtkTextTagTableForeach func,gpointer data);
gint gtk_text_tag_table_get_size ( GtkTextTagTable *table);
GtkWidget* gtk_text_view_new (void);
GtkWidget* gtk_text_view_new_with_buffer ( GtkTextBuffer *buffer);
void gtk_text_view_set_buffer ( GtkTextView *text_view, GtkTextBuffer *buffer);
GtkTextBuffer* gtk_text_view_get_buffer ( GtkTextView *text_view);
void gtk_text_view_scroll_to_mark ( GtkTextView *text_view, GtkTextMark *mark,gdouble within_margin,gboolean use_align,gdouble xalign,gdouble yalign);
gboolean gtk_text_view_scroll_to_iter ( GtkTextView *text_view, GtkTextIter *iter,gdouble within_margin,gboolean use_align,gdouble xalign,gdouble yalign);
void gtk_text_view_scroll_mark_onscreen ( GtkTextView *text_view, GtkTextMark *mark);
gboolean gtk_text_view_move_mark_onscreen ( GtkTextView *text_view, GtkTextMark *mark);
gboolean gtk_text_view_place_cursor_onscreen ( GtkTextView *text_view);
void gtk_text_view_get_visible_rect ( GtkTextView *text_view, GdkRectangle *visible_rect);
void gtk_text_view_get_iter_location ( GtkTextView *text_view,const GtkTextIter *iter, GdkRectangle *location);
void gtk_text_view_get_line_at_y ( GtkTextView *text_view, GtkTextIter *target_iter,gint y,gint *line_top);
void gtk_text_view_get_line_yrange ( GtkTextView *text_view,const GtkTextIter *iter,gint *y,gint *height);
void gtk_text_view_get_iter_at_location ( GtkTextView *text_view, GtkTextIter *iter,gint x,gint y);
void gtk_text_view_get_iter_at_position ( GtkTextView *text_view, GtkTextIter *iter,gint *trailing,gint x,gint y);
void gtk_text_view_buffer_to_window_coords ( GtkTextView *text_view, GtkTextWindowType win,gint buffer_x,gint buffer_y,gint *window_x,gint *window_y);
void gtk_text_view_window_to_buffer_coords ( GtkTextView *text_view, GtkTextWindowType win,gint window_x,gint window_y,gint *buffer_x,gint *buffer_y);
GdkWindow* gtk_text_view_get_window ( GtkTextView *text_view, GtkTextWindowType win);
GdkWindow* gtk_text_view_get_window ( GtkTextView *text_view, GtkTextWindowType win);
GtkTextWindowType gtk_text_view_get_window_type ( GtkTextView *text_view, GdkWindow *window);
void gtk_text_view_set_border_window_size ( GtkTextView *text_view, GtkTextWindowType type,gint size);
gint gtk_text_view_get_border_window_size ( GtkTextView *text_view, GtkTextWindowType type);
gboolean gtk_text_view_forward_display_line ( GtkTextView *text_view, GtkTextIter *iter);
gboolean gtk_text_view_backward_display_line ( GtkTextView *text_view, GtkTextIter *iter);
gboolean gtk_text_view_forward_display_line_end ( GtkTextView *text_view, GtkTextIter *iter);
gboolean gtk_text_view_backward_display_line_start ( GtkTextView *text_view, GtkTextIter *iter);
gboolean gtk_text_view_starts_display_line ( GtkTextView *text_view,const GtkTextIter *iter);
gboolean gtk_text_view_move_visually ( GtkTextView *text_view, GtkTextIter *iter,gint count);
void gtk_text_view_add_child_at_anchor ( GtkTextView *text_view, GtkWidget *child, GtkTextChildAnchor *anchor); GtkTextChildAnchor ;
GtkTextChildAnchor* gtk_text_child_anchor_new (void);
GList* gtk_text_child_anchor_get_widgets ( GtkTextChildAnchor *anchor);
gboolean gtk_text_child_anchor_get_deleted ( GtkTextChildAnchor *anchor);
void gtk_text_view_add_child_in_window ( GtkTextView *text_view, GtkWidget *child, GtkTextWindowType which_window,gint xpos,gint ypos);
void gtk_text_view_move_child ( GtkTextView *text_view, GtkWidget *child,gint xpos,gint ypos);
void gtk_text_view_set_wrap_mode ( GtkTextView *text_view, GtkWrapMode wrap_mode);
GtkWrapMode gtk_text_view_get_wrap_mode ( GtkTextView *text_view);
void gtk_text_view_set_editable ( GtkTextView *text_view,gboolean setting);
gboolean gtk_text_view_get_editable ( GtkTextView *text_view);
void gtk_text_view_set_cursor_visible ( GtkTextView *text_view,gboolean setting);
gboolean gtk_text_view_get_cursor_visible ( GtkTextView *text_view);
void gtk_text_view_set_overwrite ( GtkTextView *text_view,gboolean overwrite);
gboolean gtk_text_view_get_overwrite ( GtkTextView *text_view);
void gtk_text_view_set_pixels_above_lines ( GtkTextView *text_view,gint pixels_above_lines);
gint gtk_text_view_get_pixels_above_lines ( GtkTextView *text_view);
void gtk_text_view_set_pixels_below_lines ( GtkTextView *text_view,gint pixels_below_lines);
gint gtk_text_view_get_pixels_below_lines ( GtkTextView *text_view);
void gtk_text_view_set_pixels_inside_wrap ( GtkTextView *text_view,gint pixels_inside_wrap);
gint gtk_text_view_get_pixels_inside_wrap ( GtkTextView *text_view);
void gtk_text_view_set_justification ( GtkTextView *text_view, GtkJustification justification);
GtkJustification gtk_text_view_get_justification ( GtkTextView *text_view);
void gtk_text_view_set_left_margin ( GtkTextView *text_view,gint left_margin);
gint gtk_text_view_get_left_margin ( GtkTextView *text_view);
void gtk_text_view_set_right_margin ( GtkTextView *text_view,gint right_margin);
gint gtk_text_view_get_right_margin ( GtkTextView *text_view);
void gtk_text_view_set_indent ( GtkTextView *text_view,gint indent);
gint gtk_text_view_get_indent ( GtkTextView *text_view);
void gtk_text_view_set_tabs ( GtkTextView *text_view,PangoTabArray *tabs);
PangoTabArray* gtk_text_view_get_tabs ( GtkTextView *text_view);
void gtk_text_view_set_accepts_tab ( GtkTextView *text_view,gboolean accepts_tab);
gboolean gtk_text_view_get_accepts_tab ( GtkTextView *text_view);
GtkTextAttributes* gtk_text_view_get_default_attributes ( GtkTextView *text_view);
GtkTreePath* gtk_tree_path_new (void);
GtkTreePath* gtk_tree_path_new_from_string (const gchar *path);
GtkTreePath* gtk_tree_path_new_from_indices (gint first_index,...);
gchar* gtk_tree_path_to_string ( GtkTreePath *path);
GtkTreePath* gtk_tree_path_new_first (void);
void gtk_tree_path_append_index ( GtkTreePath *path,gint index_);
void gtk_tree_path_prepend_index ( GtkTreePath *path,gint index_);
gint gtk_tree_path_get_depth ( GtkTreePath *path);
gint* gtk_tree_path_get_indices ( GtkTreePath *path);
void gtk_tree_path_free ( GtkTreePath *path);
GtkTreePath* gtk_tree_path_copy (const GtkTreePath *path);
gint gtk_tree_path_compare (const GtkTreePath *a,const GtkTreePath *b);
void gtk_tree_path_next ( GtkTreePath *path);
gboolean gtk_tree_path_prev ( GtkTreePath *path);
gboolean gtk_tree_path_up ( GtkTreePath *path);
void gtk_tree_path_down ( GtkTreePath *path);
gboolean gtk_tree_path_is_ancestor ( GtkTreePath *path, GtkTreePath *descendant);
gboolean gtk_tree_path_is_descendant ( GtkTreePath *path, GtkTreePath *ancestor);
GtkTreeRowReference* gtk_tree_row_reference_new ( GtkTreeModel *model, GtkTreePath *path);
GtkTreeRowReference* gtk_tree_row_reference_new_proxy (GObject *proxy, GtkTreeModel *model, GtkTreePath *path);
GtkTreeModel* gtk_tree_row_reference_get_model ( GtkTreeRowReference *reference);
GtkTreePath* gtk_tree_row_reference_get_path ( GtkTreeRowReference *reference);
gboolean gtk_tree_row_reference_valid ( GtkTreeRowReference *reference);
void gtk_tree_row_reference_free ( GtkTreeRowReference *reference);
GtkTreeRowReference* gtk_tree_row_reference_copy ( GtkTreeRowReference *reference);
void gtk_tree_row_reference_inserted (GObject *proxy, GtkTreePath *path);
void gtk_tree_row_reference_deleted (GObject *proxy, GtkTreePath *path);
void gtk_tree_row_reference_reordered (GObject *proxy, GtkTreePath *path, GtkTreeIter *iter,gint *new_order);
GtkTreeIter* gtk_tree_iter_copy ( GtkTreeIter *iter);
void gtk_tree_iter_free ( GtkTreeIter *iter);
GtkTreeModelFlags gtk_tree_model_get_flags ( GtkTreeModel *tree_model);
gint gtk_tree_model_get_n_columns ( GtkTreeModel *tree_model);
GType gtk_tree_model_get_column_type ( GtkTreeModel *tree_model,gint index_);
gboolean gtk_tree_model_get_iter ( GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path);
gboolean gtk_tree_model_get_iter_from_string ( GtkTreeModel *tree_model, GtkTreeIter *iter,const gchar *path_string);
gboolean gtk_tree_model_get_iter_first ( GtkTreeModel *tree_model, GtkTreeIter *iter);
GtkTreePath* gtk_tree_model_get_path ( GtkTreeModel *tree_model, GtkTreeIter *iter);
void gtk_tree_model_get_value ( GtkTreeModel *tree_model, GtkTreeIter *iter,gint column,GValue *value);
gboolean gtk_tree_model_iter_next ( GtkTreeModel *tree_model, GtkTreeIter *iter);
gboolean gtk_tree_model_iter_children ( GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent);
gboolean gtk_tree_model_iter_has_child ( GtkTreeModel *tree_model, GtkTreeIter *iter);
gint gtk_tree_model_iter_n_children ( GtkTreeModel *tree_model, GtkTreeIter *iter);
gboolean gtk_tree_model_iter_nth_child ( GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent,gint n);
gboolean gtk_tree_model_iter_parent ( GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child);
gchar* gtk_tree_model_get_string_from_iter ( GtkTreeModel *tree_model, GtkTreeIter *iter);
void gtk_tree_model_ref_node ( GtkTreeModel *tree_model, GtkTreeIter *iter);
void gtk_tree_model_unref_node ( GtkTreeModel *tree_model, GtkTreeIter *iter);
void gtk_tree_model_get ( GtkTreeModel *tree_model, GtkTreeIter *iter,...);
void gtk_tree_model_get_valist ( GtkTreeModel *tree_model, GtkTreeIter *iter,va_list var_args);
void gtk_tree_model_foreach ( GtkTreeModel *model, GtkTreeModelForeachFunc func,gpointer user_data);
void gtk_tree_model_row_changed ( GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter);
void gtk_tree_model_row_inserted ( GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter);
void gtk_tree_model_row_has_child_toggled ( GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter);
void gtk_tree_model_row_deleted ( GtkTreeModel *tree_model, GtkTreePath *path);
void gtk_tree_model_rows_reordered ( GtkTreeModel *tree_model, GtkTreePath *path, GtkTreeIter *iter,gint *new_order);
void gtk_tree_selection_set_mode ( GtkTreeSelection *selection, GtkSelectionMode type);
GtkSelectionMode gtk_tree_selection_get_mode ( GtkTreeSelection *selection);
void gtk_tree_selection_set_select_function ( GtkTreeSelection *selection, GtkTreeSelectionFunc func,gpointer data, GtkDestroyNotify destroy);
gpointer gtk_tree_selection_get_user_data ( GtkTreeSelection *selection);
GtkTreeView* gtk_tree_selection_get_tree_view ( GtkTreeSelection *selection);
gboolean gtk_tree_selection_get_selected ( GtkTreeSelection *selection, GtkTreeModel **model, GtkTreeIter *iter);
void gtk_tree_selection_selected_foreach ( GtkTreeSelection *selection, GtkTreeSelectionForeachFunc func,gpointer data);
GList* gtk_tree_selection_get_selected_rows ( GtkTreeSelection *selection, GtkTreeModel **model);
gint gtk_tree_selection_count_selected_rows ( GtkTreeSelection *selection);
void gtk_tree_selection_select_path ( GtkTreeSelection *selection, GtkTreePath *path);
void gtk_tree_selection_unselect_path ( GtkTreeSelection *selection, GtkTreePath *path);
gboolean gtk_tree_selection_path_is_selected ( GtkTreeSelection *selection, GtkTreePath *path);
void gtk_tree_selection_select_iter ( GtkTreeSelection *selection, GtkTreeIter *iter);
void gtk_tree_selection_unselect_iter ( GtkTreeSelection *selection, GtkTreeIter *iter);
gboolean gtk_tree_selection_iter_is_selected ( GtkTreeSelection *selection, GtkTreeIter *iter);
void gtk_tree_selection_select_all ( GtkTreeSelection *selection);
void gtk_tree_selection_unselect_all ( GtkTreeSelection *selection);
void gtk_tree_selection_select_range ( GtkTreeSelection *selection, GtkTreePath *start_path, GtkTreePath *end_path);
void gtk_tree_selection_unselect_range ( GtkTreeSelection *selection, GtkTreePath *start_path, GtkTreePath *end_path);
GtkTreeViewColumn* gtk_tree_view_column_new (void);
GtkTreeViewColumn* gtk_tree_view_column_new_with_attributes (const gchar *title, GtkCellRenderer *cell,...);
void gtk_tree_view_column_pack_start ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,gboolean expand);
void gtk_tree_view_column_pack_end ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell,gboolean expand);
void gtk_tree_view_column_clear ( GtkTreeViewColumn *tree_column);
GList* gtk_tree_view_column_get_cell_renderers ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_add_attribute ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer,const gchar *attribute,gint column);
void gtk_tree_view_column_set_attributes ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer,...);
void gtk_tree_view_column_set_cell_data_func ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer, GtkTreeCellDataFunc func,gpointer func_data, GtkDestroyNotify destroy);
void gtk_tree_view_column_clear_attributes ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer);
void gtk_tree_view_column_set_spacing ( GtkTreeViewColumn *tree_column,gint spacing);
gint gtk_tree_view_column_get_spacing ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_visible ( GtkTreeViewColumn *tree_column,gboolean visible);
gboolean gtk_tree_view_column_get_visible ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_resizable ( GtkTreeViewColumn *tree_column,gboolean resizable);
gboolean gtk_tree_view_column_get_resizable ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_sizing ( GtkTreeViewColumn *tree_column, GtkTreeViewColumnSizing type);
GtkTreeViewColumnSizing gtk_tree_view_column_get_sizing ( GtkTreeViewColumn *tree_column);
gint gtk_tree_view_column_get_width ( GtkTreeViewColumn *tree_column);
gint gtk_tree_view_column_get_fixed_width ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_fixed_width ( GtkTreeViewColumn *tree_column,gint fixed_width);
void gtk_tree_view_column_set_min_width ( GtkTreeViewColumn *tree_column,gint min_width);
gint gtk_tree_view_column_get_min_width ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_max_width ( GtkTreeViewColumn *tree_column,gint max_width);
gint gtk_tree_view_column_get_max_width ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_clicked ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_title ( GtkTreeViewColumn *tree_column,const gchar *title);
const gchar* gtk_tree_view_column_get_title ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_expand ( GtkTreeViewColumn *tree_column,gboolean expand);
gboolean gtk_tree_view_column_get_expand ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_clickable ( GtkTreeViewColumn *tree_column,gboolean clickable);
gboolean gtk_tree_view_column_get_clickable ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_widget ( GtkTreeViewColumn *tree_column, GtkWidget *widget);
GtkWidget* gtk_tree_view_column_get_widget ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_alignment ( GtkTreeViewColumn *tree_column,gfloat xalign);
gfloat gtk_tree_view_column_get_alignment ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_reorderable ( GtkTreeViewColumn *tree_column,gboolean reorderable);
gboolean gtk_tree_view_column_get_reorderable ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_sort_column_id ( GtkTreeViewColumn *tree_column,gint sort_column_id);
gint gtk_tree_view_column_get_sort_column_id ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_sort_indicator ( GtkTreeViewColumn *tree_column,gboolean setting);
gboolean gtk_tree_view_column_get_sort_indicator ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_set_sort_order ( GtkTreeViewColumn *tree_column, GtkSortType order);
GtkSortType gtk_tree_view_column_get_sort_order ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_cell_set_cell_data ( GtkTreeViewColumn *tree_column, GtkTreeModel *tree_model, GtkTreeIter *iter,gboolean is_expander,gboolean is_expanded);
void gtk_tree_view_column_cell_get_size ( GtkTreeViewColumn *tree_column, GdkRectangle *cell_area,gint *x_offset,gint *y_offset,gint *width,gint *height);
gboolean gtk_tree_view_column_cell_get_position ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell_renderer,gint *start_pos,gint *width);
gboolean gtk_tree_view_column_cell_is_visible ( GtkTreeViewColumn *tree_column);
void gtk_tree_view_column_focus_cell ( GtkTreeViewColumn *tree_column, GtkCellRenderer *cell);
void gtk_tree_view_column_queue_resize ( GtkTreeViewColumn *tree_column);
GtkWidget* gtk_tree_view_new (void);
GtkWidget* gtk_tree_view_new_with_model ( GtkTreeModel *model);
GtkTreeModel* gtk_tree_view_get_model ( GtkTreeView *tree_view);
void gtk_tree_view_set_model ( GtkTreeView *tree_view, GtkTreeModel *model);
GtkTreeSelection* gtk_tree_view_get_selection ( GtkTreeView *tree_view);
GtkAdjustment* gtk_tree_view_get_hadjustment ( GtkTreeView *tree_view);
void gtk_tree_view_set_hadjustment ( GtkTreeView *tree_view, GtkAdjustment *adjustment);
GtkAdjustment* gtk_tree_view_get_vadjustment ( GtkTreeView *tree_view);
void gtk_tree_view_set_vadjustment ( GtkTreeView *tree_view, GtkAdjustment *adjustment);
gboolean gtk_tree_view_get_headers_visible ( GtkTreeView *tree_view);
void gtk_tree_view_set_headers_visible ( GtkTreeView *tree_view,gboolean headers_visible);
void gtk_tree_view_columns_autosize ( GtkTreeView *tree_view);
gboolean gtk_tree_view_get_headers_clickable ( GtkTreeView *tree_view);
void gtk_tree_view_set_headers_clickable ( GtkTreeView *tree_view,gboolean setting);
void gtk_tree_view_set_rules_hint ( GtkTreeView *tree_view,gboolean setting);
gboolean gtk_tree_view_get_rules_hint ( GtkTreeView *tree_view);
gint gtk_tree_view_append_column ( GtkTreeView *tree_view, GtkTreeViewColumn *column);
gint gtk_tree_view_remove_column ( GtkTreeView *tree_view, GtkTreeViewColumn *column);
gint gtk_tree_view_insert_column ( GtkTreeView *tree_view, GtkTreeViewColumn *column,gint position);
gint gtk_tree_view_insert_column_with_attributes ( GtkTreeView *tree_view,gint position,const gchar *title, GtkCellRenderer *cell,...);
gint gtk_tree_view_insert_column_with_data_func ( GtkTreeView *tree_view,gint position,const gchar *title, GtkCellRenderer *cell, GtkTreeCellDataFunc func,gpointer data,GDestroyNotify dnotify);
GtkTreeViewColumn* gtk_tree_view_get_column ( GtkTreeView *tree_view,gint n);
GList* gtk_tree_view_get_columns ( GtkTreeView *tree_view);
void gtk_tree_view_move_column_after ( GtkTreeView *tree_view, GtkTreeViewColumn *column, GtkTreeViewColumn *base_column);
void gtk_tree_view_set_expander_column ( GtkTreeView *tree_view, GtkTreeViewColumn *column);
GtkTreeViewColumn* gtk_tree_view_get_expander_column ( GtkTreeView *tree_view);
void gtk_tree_view_set_column_drag_function ( GtkTreeView *tree_view, GtkTreeViewColumnDropFunc func,gpointer user_data, GtkDestroyNotify destroy);
void gtk_tree_view_scroll_to_point ( GtkTreeView *tree_view,gint tree_x,gint tree_y);
void gtk_tree_view_scroll_to_cell ( GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column,gboolean use_align,gfloat row_align,gfloat col_align);
void gtk_tree_view_set_cursor ( GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *focus_column,gboolean start_editing);
void gtk_tree_view_set_cursor_on_cell ( GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *focus_column, GtkCellRenderer *focus_cell,gboolean start_editing);
void gtk_tree_view_get_cursor ( GtkTreeView *tree_view, GtkTreePath **path, GtkTreeViewColumn **focus_column);
void gtk_tree_view_row_activated ( GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column);
void gtk_tree_view_expand_all ( GtkTreeView *tree_view);
void gtk_tree_view_collapse_all ( GtkTreeView *tree_view);
void gtk_tree_view_expand_to_path ( GtkTreeView *tree_view, GtkTreePath *path);
gboolean gtk_tree_view_expand_row ( GtkTreeView *tree_view, GtkTreePath *path,gboolean open_all);
gboolean gtk_tree_view_collapse_row ( GtkTreeView *tree_view, GtkTreePath *path);
void gtk_tree_view_map_expanded_rows ( GtkTreeView *tree_view, GtkTreeViewMappingFunc func,gpointer data);
gboolean gtk_tree_view_row_expanded ( GtkTreeView *tree_view, GtkTreePath *path);
void gtk_tree_view_set_reorderable ( GtkTreeView *tree_view,gboolean reorderable);
gboolean gtk_tree_view_get_reorderable ( GtkTreeView *tree_view);
gboolean gtk_tree_view_get_path_at_pos ( GtkTreeView *tree_view,gint x,gint y, GtkTreePath **path, GtkTreeViewColumn **column,gint *cell_x,gint *cell_y);
void gtk_tree_view_get_cell_area ( GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, GdkRectangle *rect);
void gtk_tree_view_get_background_area ( GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, GdkRectangle *rect);
void gtk_tree_view_get_visible_rect ( GtkTreeView *tree_view, GdkRectangle *visible_rect);
gboolean gtk_tree_view_get_visible_range ( GtkTreeView *tree_view, GtkTreePath **start_path, GtkTreePath **end_path);
GdkWindow* gtk_tree_view_get_bin_window ( GtkTreeView *tree_view);
GdkWindow* gtk_tree_view_get_bin_window ( GtkTreeView *tree_view);
void gtk_tree_view_widget_to_tree_coords ( GtkTreeView *tree_view,gint wx,gint wy,gint *tx,gint *ty);
void gtk_tree_view_tree_to_widget_coords ( GtkTreeView *tree_view,gint tx,gint ty,gint *wx,gint *wy);
void gtk_tree_view_enable_model_drag_dest ( GtkTreeView *tree_view,const GtkTargetEntry *targets,gint n_targets, GdkDragAction actions);
void gtk_tree_view_enable_model_drag_source ( GtkTreeView *tree_view, GdkModifierType start_button_mask,const GtkTargetEntry *targets,gint n_targets, GdkDragAction actions);
void gtk_tree_view_unset_rows_drag_source ( GtkTreeView *tree_view);
void gtk_tree_view_unset_rows_drag_dest ( GtkTreeView *tree_view);
void gtk_tree_view_set_drag_dest_row ( GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewDropPosition pos);
void gtk_tree_view_get_drag_dest_row ( GtkTreeView *tree_view, GtkTreePath **path, GtkTreeViewDropPosition *pos);
gboolean gtk_tree_view_get_dest_row_at_pos ( GtkTreeView *tree_view,gint drag_x,gint drag_y, GtkTreePath **path, GtkTreeViewDropPosition *pos);
GdkPixmap* gtk_tree_view_create_row_drag_icon ( GtkTreeView *tree_view, GtkTreePath *path);
GdkPixmap* gtk_tree_view_create_row_drag_icon ( GtkTreeView *tree_view, GtkTreePath *path);
void gtk_tree_view_set_enable_search ( GtkTreeView *tree_view,gboolean enable_search);
gboolean gtk_tree_view_get_enable_search ( GtkTreeView *tree_view);
gint gtk_tree_view_get_search_column ( GtkTreeView *tree_view);
void gtk_tree_view_set_search_column ( GtkTreeView *tree_view,gint column);
GtkTreeViewSearchEqualFunc gtk_tree_view_get_search_equal_func ( GtkTreeView *tree_view);
void gtk_tree_view_set_search_equal_func ( GtkTreeView *tree_view, GtkTreeViewSearchEqualFunc search_equal_func,gpointer search_user_data, GtkDestroyNotify search_destroy);
GtkEntry* gtk_tree_view_get_search_entry ( GtkTreeView *tree_view);
void gtk_tree_view_set_search_entry ( GtkTreeView *tree_view, GtkEntry *entry);
GtkTreeViewSearchPositionFunc gtk_tree_view_get_search_position_func ( GtkTreeView *tree_view);
void gtk_tree_view_set_search_position_func ( GtkTreeView *tree_view, GtkTreeViewSearchPositionFunc func,gpointer data,GDestroyNotify destroy);
gboolean gtk_tree_view_get_fixed_height_mode ( GtkTreeView *tree_view);
void gtk_tree_view_set_fixed_height_mode ( GtkTreeView *tree_view,gboolean enable);
gboolean gtk_tree_view_get_hover_selection ( GtkTreeView *tree_view);
void gtk_tree_view_set_hover_selection ( GtkTreeView *tree_view,gboolean hover);
gboolean gtk_tree_view_get_hover_expand ( GtkTreeView *tree_view);
void gtk_tree_view_set_hover_expand ( GtkTreeView *tree_view,gboolean expand);
void gtk_tree_view_set_destroy_count_func ( GtkTreeView *tree_view, GtkTreeDestroyCountFunc func,gpointer data, GtkDestroyNotify destroy);
GtkTreeViewRowSeparatorFunc gtk_tree_view_get_row_separator_func ( GtkTreeView *tree_view);
void gtk_tree_view_set_row_separator_func ( GtkTreeView *tree_view, GtkTreeViewRowSeparatorFunc func,gpointer data, GtkDestroyNotify destroy);
gboolean gtk_tree_view_get_rubber_banding ( GtkTreeView *tree_view);
void gtk_tree_view_set_rubber_banding ( GtkTreeView *tree_view,gboolean enable);
gboolean gtk_tree_view_get_enable_tree_lines ( GtkTreeView *tree_view);
void gtk_tree_view_set_enable_tree_lines ( GtkTreeView *tree_view,gboolean enabled);
GtkTreeViewGridLines gtk_tree_view_get_grid_lines ( GtkTreeView *tree_view);
void gtk_tree_view_set_grid_lines ( GtkTreeView *tree_view, GtkTreeViewGridLines grid_lines);
GtkWidget* gtk_cell_view_new (void);
GtkWidget* gtk_cell_view_new_with_text (const gchar *text);
GtkWidget* gtk_cell_view_new_with_markup (const gchar *markup);
GtkWidget* gtk_cell_view_new_with_pixbuf ( GdkPixbuf *pixbuf);
void gtk_cell_view_set_model ( GtkCellView *cell_view, GtkTreeModel *model);
void gtk_cell_view_set_displayed_row ( GtkCellView *cell_view, GtkTreePath *path);
GtkTreePath* gtk_cell_view_get_displayed_row ( GtkCellView *cell_view);
gboolean gtk_cell_view_get_size_of_row ( GtkCellView *cell_view, GtkTreePath *path, GtkRequisition *requisition);
void gtk_cell_view_set_background_color ( GtkCellView *cell_view,const GdkColor *color);
GList* gtk_cell_view_get_cell_renderers ( GtkCellView *cell_view);
GtkWidget* gtk_icon_view_new (void);
GtkWidget* gtk_icon_view_new_with_model ( GtkTreeModel *model);
void gtk_icon_view_set_model ( GtkIconView *icon_view, GtkTreeModel *model);
GtkTreeModel* gtk_icon_view_get_model ( GtkIconView *icon_view);
void gtk_icon_view_set_text_column ( GtkIconView *icon_view,gint column);
gint gtk_icon_view_get_text_column ( GtkIconView *icon_view);
void gtk_icon_view_set_markup_column ( GtkIconView *icon_view,gint column);
gint gtk_icon_view_get_markup_column ( GtkIconView *icon_view);
void gtk_icon_view_set_pixbuf_column ( GtkIconView *icon_view,gint column);
gint gtk_icon_view_get_pixbuf_column ( GtkIconView *icon_view);
GtkTreePath* gtk_icon_view_get_path_at_pos ( GtkIconView *icon_view,gint x,gint y);
gboolean gtk_icon_view_get_item_at_pos ( GtkIconView *icon_view,gint x,gint y, GtkTreePath **path, GtkCellRenderer **cell);
void gtk_icon_view_set_cursor ( GtkIconView *icon_view, GtkTreePath *path, GtkCellRenderer *cell,gboolean start_editing);
gboolean gtk_icon_view_get_cursor ( GtkIconView *icon_view, GtkTreePath **path, GtkCellRenderer **cell);
void gtk_icon_view_selected_foreach ( GtkIconView *icon_view, GtkIconViewForeachFunc func,gpointer data);
void gtk_icon_view_set_selection_mode ( GtkIconView *icon_view, GtkSelectionMode mode);
GtkSelectionMode gtk_icon_view_get_selection_mode ( GtkIconView *icon_view);
void gtk_icon_view_set_orientation ( GtkIconView *icon_view, GtkOrientation orientation);
GtkOrientation gtk_icon_view_get_orientation ( GtkIconView *icon_view);
void gtk_icon_view_set_columns ( GtkIconView *icon_view,gint columns);
gint gtk_icon_view_get_columns ( GtkIconView *icon_view);
void gtk_icon_view_set_item_width ( GtkIconView *icon_view,gint item_width);
gint gtk_icon_view_get_item_width ( GtkIconView *icon_view);
void gtk_icon_view_set_spacing ( GtkIconView *icon_view,gint spacing);
gint gtk_icon_view_get_spacing ( GtkIconView *icon_view);
void gtk_icon_view_set_row_spacing ( GtkIconView *icon_view,gint row_spacing);
gint gtk_icon_view_get_row_spacing ( GtkIconView *icon_view);
void gtk_icon_view_set_column_spacing ( GtkIconView *icon_view,gint column_spacing);
gint gtk_icon_view_get_column_spacing ( GtkIconView *icon_view);
void gtk_icon_view_set_margin ( GtkIconView *icon_view,gint margin);
gint gtk_icon_view_get_margin ( GtkIconView *icon_view);
void gtk_icon_view_select_path ( GtkIconView *icon_view, GtkTreePath *path);
void gtk_icon_view_unselect_path ( GtkIconView *icon_view, GtkTreePath *path);
gboolean gtk_icon_view_path_is_selected ( GtkIconView *icon_view, GtkTreePath *path);
GList* gtk_icon_view_get_selected_items ( GtkIconView *icon_view);
void gtk_icon_view_select_all ( GtkIconView *icon_view);
void gtk_icon_view_unselect_all ( GtkIconView *icon_view);
void gtk_icon_view_item_activated ( GtkIconView *icon_view, GtkTreePath *path);
void gtk_icon_view_scroll_to_path ( GtkIconView *icon_view, GtkTreePath *path,gboolean use_align,gfloat row_align,gfloat col_align);
gboolean gtk_icon_view_get_visible_range ( GtkIconView *icon_view, GtkTreePath **start_path, GtkTreePath **end_path);
void gtk_icon_view_enable_model_drag_source ( GtkIconView *icon_view, GdkModifierType start_button_mask,const GtkTargetEntry *targets,gint n_targets, GdkDragAction actions);
void gtk_icon_view_enable_model_drag_dest ( GtkIconView *icon_view,const GtkTargetEntry *targets,gint n_targets, GdkDragAction actions);
void gtk_icon_view_unset_model_drag_source ( GtkIconView *icon_view);
void gtk_icon_view_unset_model_drag_dest ( GtkIconView *icon_view);
void gtk_icon_view_set_reorderable ( GtkIconView *icon_view,gboolean reorderable);
gboolean gtk_icon_view_get_reorderable ( GtkIconView *icon_view);
void gtk_icon_view_set_drag_dest_item ( GtkIconView *icon_view, GtkTreePath *path, GtkIconViewDropPosition pos);
void gtk_icon_view_get_drag_dest_item ( GtkIconView *icon_view, GtkTreePath **path, GtkIconViewDropPosition *pos);
gboolean gtk_icon_view_get_dest_item_at_pos ( GtkIconView *icon_view,gint drag_x,gint drag_y, GtkTreePath **path, GtkIconViewDropPosition *pos);
GdkPixmap* gtk_icon_view_create_drag_icon ( GtkIconView *icon_view, GtkTreePath *path);
GdkPixmap* gtk_icon_view_create_drag_icon ( GtkIconView *icon_view, GtkTreePath *path);
void gtk_tree_sortable_sort_column_changed ( GtkTreeSortable *sortable);
gboolean gtk_tree_sortable_get_sort_column_id ( GtkTreeSortable *sortable,gint *sort_column_id, GtkSortType *order);
void gtk_tree_sortable_set_sort_column_id ( GtkTreeSortable *sortable,gint sort_column_id, GtkSortType order);
void gtk_tree_sortable_set_sort_func ( GtkTreeSortable *sortable,gint sort_column_id, GtkTreeIterCompareFunc sort_func,gpointer user_data, GtkDestroyNotify destroy);
void gtk_tree_sortable_set_default_sort_func ( GtkTreeSortable *sortable, GtkTreeIterCompareFunc sort_func,gpointer user_data, GtkDestroyNotify destroy);
gboolean gtk_tree_sortable_has_default_sort_func ( GtkTreeSortable *sortable);
GtkTreeModel* gtk_tree_model_sort_new_with_model ( GtkTreeModel *child_model);
GtkTreeModel* gtk_tree_model_sort_get_model ( GtkTreeModelSort *tree_model);
GtkTreePath* gtk_tree_model_sort_convert_child_path_to_path ( GtkTreeModelSort *tree_model_sort, GtkTreePath *child_path);
void gtk_tree_model_sort_convert_child_iter_to_iter ( GtkTreeModelSort *tree_model_sort, GtkTreeIter *sort_iter, GtkTreeIter *child_iter);
GtkTreePath* gtk_tree_model_sort_convert_path_to_child_path ( GtkTreeModelSort *tree_model_sort, GtkTreePath *sorted_path);
void gtk_tree_model_sort_convert_iter_to_child_iter ( GtkTreeModelSort *tree_model_sort, GtkTreeIter *child_iter, GtkTreeIter *sorted_iter);
void gtk_tree_model_sort_reset_default_sort_func ( GtkTreeModelSort *tree_model_sort);
void gtk_tree_model_sort_clear_cache ( GtkTreeModelSort *tree_model_sort);
gboolean gtk_tree_model_sort_iter_is_valid ( GtkTreeModelSort *tree_model_sort, GtkTreeIter *iter);
GtkTreeModel* gtk_tree_model_filter_new ( GtkTreeModel *child_model, GtkTreePath *root);
void gtk_tree_model_filter_set_visible_func ( GtkTreeModelFilter *filter, GtkTreeModelFilterVisibleFunc func,gpointer data, GtkDestroyNotify destroy);
void gtk_tree_model_filter_set_modify_func ( GtkTreeModelFilter *filter,gint n_columns,GType *types, GtkTreeModelFilterModifyFunc func,gpointer data, GtkDestroyNotify destroy);
void gtk_tree_model_filter_set_visible_column ( GtkTreeModelFilter *filter,gint column);
GtkTreeModel* gtk_tree_model_filter_get_model ( GtkTreeModelFilter *filter);
gboolean gtk_tree_model_filter_convert_child_iter_to_iter ( GtkTreeModelFilter *filter, GtkTreeIter *filter_iter, GtkTreeIter *child_iter);
void gtk_tree_model_filter_convert_iter_to_child_iter ( GtkTreeModelFilter *filter, GtkTreeIter *child_iter, GtkTreeIter *filter_iter);
GtkTreePath* gtk_tree_model_filter_convert_child_path_to_path ( GtkTreeModelFilter *filter, GtkTreePath *child_path);
GtkTreePath* gtk_tree_model_filter_convert_path_to_child_path ( GtkTreeModelFilter *filter, GtkTreePath *filter_path);
void gtk_tree_model_filter_refilter ( GtkTreeModelFilter *filter);
void gtk_tree_model_filter_clear_cache ( GtkTreeModelFilter *filter);
void gtk_cell_layout_pack_start ( GtkCellLayout *cell_layout, GtkCellRenderer *cell,gboolean expand);
void gtk_cell_layout_pack_end ( GtkCellLayout *cell_layout, GtkCellRenderer *cell,gboolean expand);
void gtk_cell_layout_reorder ( GtkCellLayout *cell_layout, GtkCellRenderer *cell,gint position);
void gtk_cell_layout_clear ( GtkCellLayout *cell_layout);
void gtk_cell_layout_set_attributes ( GtkCellLayout *cell_layout, GtkCellRenderer *cell,...);
void gtk_cell_layout_add_attribute ( GtkCellLayout *cell_layout, GtkCellRenderer *cell,const gchar *attribute,gint column);
void gtk_cell_layout_set_cell_data_func ( GtkCellLayout *cell_layout, GtkCellRenderer *cell, GtkCellLayoutDataFunc func,gpointer func_data,GDestroyNotify destroy);
void gtk_cell_layout_clear_attributes ( GtkCellLayout *cell_layout, GtkCellRenderer *cell);
void gtk_cell_renderer_get_size ( GtkCellRenderer *cell, GtkWidget *widget, GdkRectangle *cell_area,gint *x_offset,gint *y_offset,gint *width,gint *height);
void gtk_cell_renderer_render ( GtkCellRenderer *cell, GdkWindow *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags);
gboolean gtk_cell_renderer_activate ( GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget,const gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags);
GtkCellEditable* gtk_cell_renderer_start_editing ( GtkCellRenderer *cell, GdkEvent *event, GtkWidget *widget,const gchar *path, GdkRectangle *background_area, GdkRectangle *cell_area, GtkCellRendererState flags);
void gtk_cell_renderer_editing_canceled ( GtkCellRenderer *cell);
void gtk_cell_renderer_stop_editing ( GtkCellRenderer *cell,gboolean canceled);
void gtk_cell_renderer_get_fixed_size ( GtkCellRenderer *cell,gint *width,gint *height);
void gtk_cell_renderer_set_fixed_size ( GtkCellRenderer *cell,gint width,gint height);
void gtk_cell_editable_start_editing ( GtkCellEditable *cell_editable, GdkEvent *event);
void gtk_cell_editable_editing_done ( GtkCellEditable *cell_editable);
void gtk_cell_editable_remove_widget ( GtkCellEditable *cell_editable);
GtkCellRenderer* gtk_cell_renderer_accel_new (void);
GtkCellRenderer* gtk_cell_renderer_combo_new (void);
GtkCellRenderer* gtk_cell_renderer_pixbuf_new (void);
GtkCellRenderer* gtk_cell_renderer_progress_new (void);
GtkCellRenderer* gtk_cell_renderer_spin_new (void);
GtkCellRenderer* gtk_cell_renderer_text_new (void);
void gtk_cell_renderer_text_set_fixed_height_from_font ( GtkCellRendererText *renderer,gint number_of_rows);
GtkCellRenderer* gtk_cell_renderer_toggle_new (void);
gboolean gtk_cell_renderer_toggle_get_radio ( GtkCellRendererToggle *toggle);
void gtk_cell_renderer_toggle_set_radio ( GtkCellRendererToggle *toggle,gboolean radio);
gboolean gtk_cell_renderer_toggle_get_active ( GtkCellRendererToggle *toggle);
void gtk_cell_renderer_toggle_set_active ( GtkCellRendererToggle *toggle,gboolean setting);
GtkListStore* gtk_list_store_new (gint n_columns,...);
GtkListStore* gtk_list_store_newv (gint n_columns,GType *types);
void gtk_list_store_set_column_types ( GtkListStore *list_store,gint n_columns,GType *types);
void gtk_list_store_set ( GtkListStore *list_store, GtkTreeIter *iter,...);
void gtk_list_store_set_valist ( GtkListStore *list_store, GtkTreeIter *iter,va_list var_args);
void gtk_list_store_set_value ( GtkListStore *list_store, GtkTreeIter *iter,gint column,GValue *value);
gboolean gtk_list_store_remove ( GtkListStore *list_store, GtkTreeIter *iter);
void gtk_list_store_insert ( GtkListStore *list_store, GtkTreeIter *iter,gint position);
void gtk_list_store_insert_before ( GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling);
void gtk_list_store_insert_after ( GtkListStore *list_store, GtkTreeIter *iter, GtkTreeIter *sibling);
void gtk_list_store_insert_with_values ( GtkListStore *list_store, GtkTreeIter *iter,gint position,...);
void gtk_list_store_insert_with_valuesv ( GtkListStore *list_store, GtkTreeIter *iter,gint position,gint *columns,GValue *values,gint n_values);
void gtk_list_store_prepend ( GtkListStore *list_store, GtkTreeIter *iter);
void gtk_list_store_append ( GtkListStore *list_store, GtkTreeIter *iter);
void gtk_list_store_clear ( GtkListStore *list_store);
gboolean gtk_list_store_iter_is_valid ( GtkListStore *list_store, GtkTreeIter *iter);
void gtk_list_store_reorder ( GtkListStore *store,gint *new_order);
void gtk_list_store_swap ( GtkListStore *store, GtkTreeIter *a, GtkTreeIter *b);
void gtk_list_store_move_before ( GtkListStore *store, GtkTreeIter *iter, GtkTreeIter *position);
void gtk_list_store_move_after ( GtkListStore *store, GtkTreeIter *iter, GtkTreeIter *position);
GtkTreeStore* gtk_tree_store_new (gint n_columns,...);
GtkTreeStore* gtk_tree_store_newv (gint n_columns,GType *types);
void gtk_tree_store_set_column_types ( GtkTreeStore *tree_store,gint n_columns,GType *types);
void gtk_tree_store_set_value ( GtkTreeStore *tree_store, GtkTreeIter *iter,gint column,GValue *value);
void gtk_tree_store_set ( GtkTreeStore *tree_store, GtkTreeIter *iter,...);
void gtk_tree_store_set_valist ( GtkTreeStore *tree_store, GtkTreeIter *iter,va_list var_args);
gboolean gtk_tree_store_remove ( GtkTreeStore *tree_store, GtkTreeIter *iter);
void gtk_tree_store_insert ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent,gint position);
void gtk_tree_store_insert_before ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent, GtkTreeIter *sibling);
void gtk_tree_store_insert_after ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent, GtkTreeIter *sibling);
void gtk_tree_store_insert_with_values ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent,gint position,...);
void gtk_tree_store_insert_with_valuesv ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent,gint position,gint *columns,GValue *values,gint n_values);
void gtk_tree_store_prepend ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent);
void gtk_tree_store_append ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *parent);
gboolean gtk_tree_store_is_ancestor ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *descendant);
gint gtk_tree_store_iter_depth ( GtkTreeStore *tree_store, GtkTreeIter *iter);
void gtk_tree_store_clear ( GtkTreeStore *tree_store);
gboolean gtk_tree_store_iter_is_valid ( GtkTreeStore *tree_store, GtkTreeIter *iter);
void gtk_tree_store_reorder ( GtkTreeStore *tree_store, GtkTreeIter *parent,gint *new_order);
void gtk_tree_store_swap ( GtkTreeStore *tree_store, GtkTreeIter *a, GtkTreeIter *b);
void gtk_tree_store_move_before ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *position);
void gtk_tree_store_move_after ( GtkTreeStore *tree_store, GtkTreeIter *iter, GtkTreeIter *position);
GtkWidget* gtk_combo_box_new (void);
GtkWidget* gtk_combo_box_new_with_model ( GtkTreeModel *model);
gint gtk_combo_box_get_wrap_width ( GtkComboBox *combo_box);
void gtk_combo_box_set_wrap_width ( GtkComboBox *combo_box,gint width);
gint gtk_combo_box_get_row_span_column ( GtkComboBox *combo_box);
void gtk_combo_box_set_row_span_column ( GtkComboBox *combo_box,gint row_span);
gint gtk_combo_box_get_column_span_column ( GtkComboBox *combo_box);
void gtk_combo_box_set_column_span_column ( GtkComboBox *combo_box,gint column_span);
gint gtk_combo_box_get_active ( GtkComboBox *combo_box);
void gtk_combo_box_set_active ( GtkComboBox *combo_box,gint index_);
gboolean gtk_combo_box_get_active_iter ( GtkComboBox *combo_box, GtkTreeIter *iter);
void gtk_combo_box_set_active_iter ( GtkComboBox *combo_box, GtkTreeIter *iter);
GtkTreeModel* gtk_combo_box_get_model ( GtkComboBox *combo_box);
void gtk_combo_box_set_model ( GtkComboBox *combo_box, GtkTreeModel *model);
GtkWidget* gtk_combo_box_new_text (void);
void gtk_combo_box_append_text ( GtkComboBox *combo_box,const gchar *text);
void gtk_combo_box_insert_text ( GtkComboBox *combo_box,gint position,const gchar *text);
void gtk_combo_box_prepend_text ( GtkComboBox *combo_box,const gchar *text);
void gtk_combo_box_remove_text ( GtkComboBox *combo_box,gint position);
gchar* gtk_combo_box_get_active_text ( GtkComboBox *combo_box);
void gtk_combo_box_popup ( GtkComboBox *combo_box);
void gtk_combo_box_popdown ( GtkComboBox *combo_box);
AtkObject* gtk_combo_box_get_popup_accessible ( GtkComboBox *combo_box);
GtkTreeViewRowSeparatorFunc gtk_combo_box_get_row_separator_func ( GtkComboBox *combo_box);
void gtk_combo_box_set_row_separator_func ( GtkComboBox *combo_box, GtkTreeViewRowSeparatorFunc func,gpointer data, GtkDestroyNotify destroy);
void gtk_combo_box_set_add_tearoffs ( GtkComboBox *combo_box,gboolean add_tearoffs);
gboolean gtk_combo_box_get_add_tearoffs ( GtkComboBox *combo_box);
void gtk_combo_box_set_title ( GtkComboBox *combo_box,const gchar *title);
const gchar* gtk_combo_box_get_title ( GtkComboBox *combo_box);
void gtk_combo_box_set_focus_on_click ( GtkComboBox *combo,gboolean focus_on_click);
gboolean gtk_combo_box_get_focus_on_click ( GtkComboBox *combo);
GtkWidget* gtk_combo_box_entry_new (void);
GtkWidget* gtk_combo_box_entry_new_with_model ( GtkTreeModel *model,gint text_column);
GtkWidget* gtk_combo_box_entry_new_text (void);
void gtk_combo_box_entry_set_text_column ( GtkComboBoxEntry *entry_box,gint text_column);
gint gtk_combo_box_entry_get_text_column ( GtkComboBoxEntry *entry_box);
GtkWidget* gtk_menu_new (void);
void gtk_menu_set_screen ( GtkMenu *menu, GdkScreen *screen);
void gtk_menu_reorder_child ( GtkMenu *menu, GtkWidget *child,gint position);
void gtk_menu_attach ( GtkMenu *menu, GtkWidget *child,guint left_attach,guint right_attach,guint top_attach,guint bottom_attach);
void gtk_menu_popup ( GtkMenu *menu, GtkWidget *parent_menu_shell, GtkWidget *parent_menu_item, GtkMenuPositionFunc func,gpointer data,guint button,guint32 activate_time);
void gtk_menu_set_accel_group ( GtkMenu *menu, GtkAccelGroup *accel_group);
GtkAccelGroup* gtk_menu_get_accel_group ( GtkMenu *menu);
void gtk_menu_set_accel_path ( GtkMenu *menu,const gchar *accel_path);
void gtk_menu_set_title ( GtkMenu *menu,const gchar *title);
gboolean gtk_menu_get_tearoff_state ( GtkMenu *menu);
const gchar* gtk_menu_get_title ( GtkMenu *menu);
void gtk_menu_popdown ( GtkMenu *menu);
void gtk_menu_reposition ( GtkMenu *menu);
GtkWidget* gtk_menu_get_active ( GtkMenu *menu);
void gtk_menu_set_active ( GtkMenu *menu,guint index_);
void gtk_menu_set_tearoff_state ( GtkMenu *menu,gboolean torn_off);
void gtk_menu_attach_to_widget ( GtkMenu *menu, GtkWidget *attach_widget, GtkMenuDetachFunc detacher);
void gtk_menu_detach ( GtkMenu *menu);
GtkWidget* gtk_menu_get_attach_widget ( GtkMenu *menu);
GList* gtk_menu_get_for_attach_widget ( GtkWidget *widget);
void gtk_menu_set_monitor ( GtkMenu *menu,gint monitor_num);
GtkWidget* gtk_menu_bar_new (void);
void gtk_menu_bar_set_pack_direction ( GtkMenuBar *menubar, GtkPackDirection pack_dir);
GtkPackDirection gtk_menu_bar_get_pack_direction ( GtkMenuBar *menubar);
void gtk_menu_bar_set_child_pack_direction ( GtkMenuBar *menubar, GtkPackDirection child_pack_dir);
GtkPackDirection gtk_menu_bar_get_child_pack_direction ( GtkMenuBar *menubar);
GtkWidget* gtk_menu_item_new (void);
GtkWidget* gtk_menu_item_new_with_label (const gchar *label);
GtkWidget* gtk_menu_item_new_with_mnemonic (const gchar *label);
void gtk_menu_item_set_right_justified ( GtkMenuItem *menu_item,gboolean right_justified);
void gtk_menu_item_set_submenu ( GtkMenuItem *menu_item, GtkWidget *submenu);
void gtk_menu_item_set_accel_path ( GtkMenuItem *menu_item,const gchar *accel_path);
void gtk_menu_item_remove_submenu ( GtkMenuItem *menu_item);
void gtk_menu_item_select ( GtkMenuItem *menu_item);
void gtk_menu_item_deselect ( GtkMenuItem *menu_item);
void gtk_menu_item_activate ( GtkMenuItem *menu_item);
void gtk_menu_item_toggle_size_request ( GtkMenuItem *menu_item,gint *requisition);
void gtk_menu_item_toggle_size_allocate ( GtkMenuItem *menu_item,gint allocation);
gboolean gtk_menu_item_get_right_justified ( GtkMenuItem *menu_item);
GtkWidget* gtk_menu_item_get_submenu ( GtkMenuItem *menu_item);
void gtk_menu_shell_append ( GtkMenuShell *menu_shell, GtkWidget *child);
void gtk_menu_shell_prepend ( GtkMenuShell *menu_shell, GtkWidget *child);
void gtk_menu_shell_insert ( GtkMenuShell *menu_shell, GtkWidget *child,gint position);
void gtk_menu_shell_deactivate ( GtkMenuShell *menu_shell);
void gtk_menu_shell_select_item ( GtkMenuShell *menu_shell, GtkWidget *menu_item);
void gtk_menu_shell_select_first ( GtkMenuShell *menu_shell,gboolean search_sensitive);
void gtk_menu_shell_deselect ( GtkMenuShell *menu_shell);
void gtk_menu_shell_activate_item ( GtkMenuShell *menu_shell, GtkWidget *menu_item,gboolean force_deactivate);
void gtk_menu_shell_cancel ( GtkMenuShell *menu_shell);
void gtk_menu_shell_set_take_focus ( GtkMenuShell *menu_shell,gboolean take_focus);
gboolean gtk_menu_shell_get_take_focus ( GtkMenuShell *menu_shell);
void gtk_image_menu_item_set_image ( GtkImageMenuItem *image_menu_item, GtkWidget *image);
GtkWidget* gtk_image_menu_item_get_image ( GtkImageMenuItem *image_menu_item);
GtkWidget* gtk_image_menu_item_new (void);
GtkWidget* gtk_image_menu_item_new_from_stock (const gchar *stock_id, GtkAccelGroup *accel_group);
GtkWidget* gtk_image_menu_item_new_with_label (const gchar *label);
GtkWidget* gtk_image_menu_item_new_with_mnemonic (const gchar *label);
GtkWidget* gtk_radio_menu_item_new (GSList *group);
GtkWidget* gtk_radio_menu_item_new_with_label (GSList *group,const gchar *label);
GtkWidget* gtk_radio_menu_item_new_with_mnemonic (GSList *group,const gchar *label);
GtkWidget* gtk_radio_menu_item_new_from_widget ( GtkRadioMenuItem *group);
GtkWidget* gtk_radio_menu_item_new_with_label_from_widget ( GtkRadioMenuItem *group,const gchar *label);
GtkWidget* gtk_radio_menu_item_new_with_mnemonic_from_widget ( GtkRadioMenuItem *group,const gchar *label);
void gtk_radio_menu_item_set_group ( GtkRadioMenuItem *radio_menu_item,GSList *group);
GSList* gtk_radio_menu_item_get_group ( GtkRadioMenuItem *radio_menu_item);
GtkWidget* gtk_check_menu_item_new (void);
GtkWidget* gtk_check_menu_item_new_with_label (const gchar *label);
GtkWidget* gtk_check_menu_item_new_with_mnemonic (const gchar *label);
gboolean gtk_check_menu_item_get_active ( GtkCheckMenuItem *check_menu_item);
void gtk_check_menu_item_set_active ( GtkCheckMenuItem *check_menu_item,gboolean is_active);
void gtk_check_menu_item_set_show_toggle ( GtkCheckMenuItem *menu_item,gboolean always);
void gtk_check_menu_item_toggled ( GtkCheckMenuItem *check_menu_item);
gboolean gtk_check_menu_item_get_inconsistent ( GtkCheckMenuItem *check_menu_item);
void gtk_check_menu_item_set_inconsistent ( GtkCheckMenuItem *check_menu_item,gboolean setting);
void gtk_check_menu_item_set_draw_as_radio ( GtkCheckMenuItem *check_menu_item,gboolean draw_as_radio);
gboolean gtk_check_menu_item_get_draw_as_radio ( GtkCheckMenuItem *check_menu_item);
GtkWidget* gtk_separator_menu_item_new (void);
GtkWidget* gtk_tearoff_menu_item_new (void);
GtkWidget* gtk_toolbar_new (void);
void gtk_toolbar_insert ( GtkToolbar *toolbar, GtkToolItem *item,gint pos);
gint gtk_toolbar_get_item_index ( GtkToolbar *toolbar, GtkToolItem *item);
gint gtk_toolbar_get_n_items ( GtkToolbar *toolbar);
GtkToolItem* gtk_toolbar_get_nth_item ( GtkToolbar *toolbar,gint n);
gint gtk_toolbar_get_drop_index ( GtkToolbar *toolbar,gint x,gint y);
void gtk_toolbar_set_drop_highlight_item ( GtkToolbar *toolbar, GtkToolItem *tool_item,gint index_);
void gtk_toolbar_set_show_arrow ( GtkToolbar *toolbar,gboolean show_arrow);
void gtk_toolbar_set_orientation ( GtkToolbar *toolbar, GtkOrientation orientation);
void gtk_toolbar_set_tooltips ( GtkToolbar *toolbar,gboolean enable);
void gtk_toolbar_unset_icon_size ( GtkToolbar *toolbar);
gboolean gtk_toolbar_get_show_arrow ( GtkToolbar *toolbar);
GtkOrientation gtk_toolbar_get_orientation ( GtkToolbar *toolbar);
GtkToolbarStyle gtk_toolbar_get_style ( GtkToolbar *toolbar);
GtkIconSize gtk_toolbar_get_icon_size ( GtkToolbar *toolbar);
gboolean gtk_toolbar_get_tooltips ( GtkToolbar *toolbar);
GtkReliefStyle gtk_toolbar_get_relief_style ( GtkToolbar *toolbar);
GtkWidget* gtk_toolbar_append_item ( GtkToolbar *toolbar,const char *text,const char *tooltip_text,const char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback,gpointer user_data);
GtkWidget* gtk_toolbar_prepend_item ( GtkToolbar *toolbar,const char *text,const char *tooltip_text,const char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback,gpointer user_data);
GtkWidget* gtk_toolbar_insert_item ( GtkToolbar *toolbar,const char *text,const char *tooltip_text,const char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback,gpointer user_data,gint position);
void gtk_toolbar_append_space ( GtkToolbar *toolbar);
void gtk_toolbar_prepend_space ( GtkToolbar *toolbar);
void gtk_toolbar_insert_space ( GtkToolbar *toolbar,gint position);
GtkWidget* gtk_toolbar_append_element ( GtkToolbar *toolbar, GtkToolbarChildType type, GtkWidget *widget,const char *text,const char *tooltip_text,const char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback,gpointer user_data);
GtkWidget* gtk_toolbar_prepend_element ( GtkToolbar *toolbar, GtkToolbarChildType type, GtkWidget *widget,const char *text,const char *tooltip_text,const char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback,gpointer user_data);
GtkWidget* gtk_toolbar_insert_element ( GtkToolbar *toolbar, GtkToolbarChildType type, GtkWidget *widget,const char *text,const char *tooltip_text,const char *tooltip_private_text, GtkWidget *icon, GtkSignalFunc callback,gpointer user_data,gint position);
void gtk_toolbar_append_widget ( GtkToolbar *toolbar, GtkWidget *widget,const char *tooltip_text,const char *tooltip_private_text);
void gtk_toolbar_prepend_widget ( GtkToolbar *toolbar, GtkWidget *widget,const char *tooltip_text,const char *tooltip_private_text);
void gtk_toolbar_insert_widget ( GtkToolbar *toolbar, GtkWidget *widget,const char *tooltip_text,const char *tooltip_private_text,gint position);
void gtk_toolbar_set_style ( GtkToolbar *toolbar, GtkToolbarStyle style);
GtkWidget* gtk_toolbar_insert_stock ( GtkToolbar *toolbar,const gchar *stock_id,const char *tooltip_text,const char *tooltip_private_text, GtkSignalFunc callback,gpointer user_data,gint position);
void gtk_toolbar_set_icon_size ( GtkToolbar *toolbar, GtkIconSize icon_size);
void gtk_toolbar_remove_space ( GtkToolbar *toolbar,gint position);
void gtk_toolbar_unset_style ( GtkToolbar *toolbar);
GtkToolItem* gtk_tool_item_new (void);
void gtk_tool_item_set_homogeneous ( GtkToolItem *tool_item,gboolean homogeneous);
gboolean gtk_tool_item_get_homogeneous ( GtkToolItem *tool_item);
void gtk_tool_item_set_expand ( GtkToolItem *tool_item,gboolean expand);
gboolean gtk_tool_item_get_expand ( GtkToolItem *tool_item);
void gtk_tool_item_set_tooltip ( GtkToolItem *tool_item, GtkTooltips *tooltips,const gchar *tip_text,const gchar *tip_private);
void gtk_tool_item_set_use_drag_window ( GtkToolItem *toolitem,gboolean use_drag_window);
gboolean gtk_tool_item_get_use_drag_window ( GtkToolItem *toolitem);
void gtk_tool_item_set_visible_horizontal ( GtkToolItem *toolitem,gboolean visible_horizontal);
gboolean gtk_tool_item_get_visible_horizontal ( GtkToolItem *toolitem);
void gtk_tool_item_set_visible_vertical ( GtkToolItem *toolitem,gboolean visible_vertical);
gboolean gtk_tool_item_get_visible_vertical ( GtkToolItem *toolitem);
void gtk_tool_item_set_is_important ( GtkToolItem *tool_item,gboolean is_important);
gboolean gtk_tool_item_get_is_important ( GtkToolItem *tool_item);
GtkIconSize gtk_tool_item_get_icon_size ( GtkToolItem *tool_item);
GtkOrientation gtk_tool_item_get_orientation ( GtkToolItem *tool_item);
GtkToolbarStyle gtk_tool_item_get_toolbar_style ( GtkToolItem *tool_item);
GtkReliefStyle gtk_tool_item_get_relief_style ( GtkToolItem *tool_item);
GtkWidget* gtk_tool_item_retrieve_proxy_menu_item ( GtkToolItem *tool_item);
GtkWidget* gtk_tool_item_get_proxy_menu_item ( GtkToolItem *tool_item,const gchar *menu_item_id);
void gtk_tool_item_set_proxy_menu_item ( GtkToolItem *tool_item,const gchar *menu_item_id, GtkWidget *menu_item);
void gtk_tool_item_rebuild_menu ( GtkToolItem *tool_item);
GtkToolItem* gtk_separator_tool_item_new (void);
void gtk_separator_tool_item_set_draw ( GtkSeparatorToolItem *item,gboolean draw);
gboolean gtk_separator_tool_item_get_draw ( GtkSeparatorToolItem *item);
GtkToolItem* gtk_tool_button_new ( GtkWidget *icon_widget,const gchar *label);
GtkToolItem* gtk_tool_button_new_from_stock (const gchar *stock_id);
void gtk_tool_button_set_label ( GtkToolButton *button,const gchar *label);
const gchar* gtk_tool_button_get_label ( GtkToolButton *button);
void gtk_tool_button_set_use_underline ( GtkToolButton *button,gboolean use_underline);
gboolean gtk_tool_button_get_use_underline ( GtkToolButton *button);
void gtk_tool_button_set_stock_id ( GtkToolButton *button,const gchar *stock_id);
const gchar* gtk_tool_button_get_stock_id ( GtkToolButton *button);
void gtk_tool_button_set_icon_name ( GtkToolButton *button,const gchar *icon_name);
const gchar* gtk_tool_button_get_icon_name ( GtkToolButton *button);
void gtk_tool_button_set_icon_widget ( GtkToolButton *button, GtkWidget *icon_widget);
GtkWidget* gtk_tool_button_get_icon_widget ( GtkToolButton *button);
void gtk_tool_button_set_label_widget ( GtkToolButton *button, GtkWidget *label_widget);
GtkWidget* gtk_tool_button_get_label_widget ( GtkToolButton *button);
GtkToolItem* gtk_menu_tool_button_new ( GtkWidget *icon_widget,const gchar *label);
GtkToolItem* gtk_menu_tool_button_new_from_stock (const gchar *stock_id);
void gtk_menu_tool_button_set_menu ( GtkMenuToolButton *button, GtkWidget *menu);
GtkWidget* gtk_menu_tool_button_get_menu ( GtkMenuToolButton *button);
void gtk_menu_tool_button_set_arrow_tooltip ( GtkMenuToolButton *button, GtkTooltips *tooltips,const gchar *tip_text,const gchar *tip_private);
GtkToolItem* gtk_toggle_tool_button_new (void);
GtkToolItem* gtk_toggle_tool_button_new_from_stock (const gchar *stock_id);
void gtk_toggle_tool_button_set_active ( GtkToggleToolButton *button,gboolean is_active);
gboolean gtk_toggle_tool_button_get_active ( GtkToggleToolButton *button);
GtkToolItem* gtk_radio_tool_button_new (GSList *group);
GtkToolItem* gtk_radio_tool_button_new_from_stock (GSList *group,const gchar *stock_id);
GtkToolItem* gtk_radio_tool_button_new_from_widget ( GtkRadioToolButton *group);
GtkToolItem* gtk_radio_tool_button_new_with_stock_from_widget ( GtkRadioToolButton *group,const gchar *stock_id);
GSList* gtk_radio_tool_button_get_group ( GtkRadioToolButton *button);
void gtk_radio_tool_button_set_group ( GtkRadioToolButton *button,GSList *group);
GtkUIManager* gtk_ui_manager_new (void);
void gtk_ui_manager_set_add_tearoffs ( GtkUIManager *self,gboolean add_tearoffs);
gboolean gtk_ui_manager_get_add_tearoffs ( GtkUIManager *self);
void gtk_ui_manager_insert_action_group ( GtkUIManager *self, GtkActionGroup *action_group,gint pos);
void gtk_ui_manager_remove_action_group ( GtkUIManager *self, GtkActionGroup *action_group);
GList* gtk_ui_manager_get_action_groups ( GtkUIManager *self);
GtkAccelGroup* gtk_ui_manager_get_accel_group ( GtkUIManager *self);
GtkWidget* gtk_ui_manager_get_widget ( GtkUIManager *self,const gchar *path);
GSList* gtk_ui_manager_get_toplevels ( GtkUIManager *self, GtkUIManagerItemType types);
GtkAction* gtk_ui_manager_get_action ( GtkUIManager *self,const gchar *path);
guint gtk_ui_manager_add_ui_from_string ( GtkUIManager *self,const gchar *buffer,gssize length,GError **error);
guint gtk_ui_manager_add_ui_from_file ( GtkUIManager *self,const gchar *filename,GError **error);
guint gtk_ui_manager_new_merge_id ( GtkUIManager *self);
void gtk_ui_manager_add_ui ( GtkUIManager *self,guint merge_id,const gchar *path,const gchar *name,const gchar *action, GtkUIManagerItemType type,gboolean top);
void gtk_ui_manager_remove_ui ( GtkUIManager *self,guint merge_id);
gchar* gtk_ui_manager_get_ui ( GtkUIManager *self);
void gtk_ui_manager_ensure_update ( GtkUIManager *self);
GtkActionGroup* gtk_action_group_new (const gchar *name);
const gchar* gtk_action_group_get_name ( GtkActionGroup *action_group);
gboolean gtk_action_group_get_sensitive ( GtkActionGroup *action_group);
void gtk_action_group_set_sensitive ( GtkActionGroup *action_group,gboolean sensitive);
gboolean gtk_action_group_get_visible ( GtkActionGroup *action_group);
void gtk_action_group_set_visible ( GtkActionGroup *action_group,gboolean visible);
GtkAction* gtk_action_group_get_action ( GtkActionGroup *action_group,const gchar *action_name);
GList* gtk_action_group_list_actions ( GtkActionGroup *action_group);
void gtk_action_group_add_action ( GtkActionGroup *action_group, GtkAction *action);
void gtk_action_group_add_action_with_accel ( GtkActionGroup *action_group, GtkAction *action,const gchar *accelerator);
void gtk_action_group_remove_action ( GtkActionGroup *action_group, GtkAction *action); GtkActionEntry ;
void gtk_action_group_add_actions ( GtkActionGroup *action_group,const GtkActionEntry *entries,guint n_entries,gpointer user_data);
void gtk_action_group_add_actions_full ( GtkActionGroup *action_group,const GtkActionEntry *entries,guint n_entries,gpointer user_data,GDestroyNotify destroy); GtkToggleActionEntry ;
void gtk_action_group_add_toggle_actions ( GtkActionGroup *action_group,const GtkToggleActionEntry *entries,guint n_entries,gpointer user_data);
void gtk_action_group_add_toggle_actions_full ( GtkActionGroup *action_group,const GtkToggleActionEntry *entries,guint n_entries,gpointer user_data,GDestroyNotify destroy); GtkRadioActionEntry ;
void gtk_action_group_add_radio_actions ( GtkActionGroup *action_group,const GtkRadioActionEntry *entries,guint n_entries,gint value,GCallback on_change,gpointer user_data);
void gtk_action_group_add_radio_actions_full ( GtkActionGroup *action_group,const GtkRadioActionEntry *entries,guint n_entries,gint value,GCallback on_change,gpointer user_data,GDestroyNotify destroy);
void gtk_action_group_set_translate_func ( GtkActionGroup *action_group, GtkTranslateFunc func,gpointer data, GtkDestroyNotify notify);
void gtk_action_group_set_translation_domain ( GtkActionGroup *action_group,const gchar *domain);
const gchar* gtk_action_group_translate_string ( GtkActionGroup *action_group,const gchar *string);
GtkAction* gtk_action_new (const gchar *name,const gchar *label,const gchar *tooltip,const gchar *stock_id);
const gchar* gtk_action_get_name ( GtkAction *action);
gboolean gtk_action_is_sensitive ( GtkAction *action);
gboolean gtk_action_get_sensitive ( GtkAction *action);
void gtk_action_set_sensitive ( GtkAction *action,gboolean sensitive);
gboolean gtk_action_is_visible ( GtkAction *action);
gboolean gtk_action_get_visible ( GtkAction *action);
void gtk_action_set_visible ( GtkAction *action,gboolean visible);
void gtk_action_activate ( GtkAction *action);
GtkWidget* gtk_action_create_icon ( GtkAction *action, GtkIconSize icon_size);
GtkWidget* gtk_action_create_menu_item ( GtkAction *action);
GtkWidget* gtk_action_create_tool_item ( GtkAction *action);
void gtk_action_connect_proxy ( GtkAction *action, GtkWidget *proxy);
void gtk_action_disconnect_proxy ( GtkAction *action, GtkWidget *proxy);
GSList* gtk_action_get_proxies ( GtkAction *action);
void gtk_action_connect_accelerator ( GtkAction *action);
void gtk_action_disconnect_accelerator ( GtkAction *action);
void gtk_action_block_activate_from ( GtkAction *action, GtkWidget *proxy);
void gtk_action_unblock_activate_from ( GtkAction *action, GtkWidget *proxy);
const gchar* gtk_action_get_accel_path ( GtkAction *action);
void gtk_action_set_accel_path ( GtkAction *action,const gchar *accel_path);
GClosure* gtk_action_get_accel_closure ( GtkAction *action);
void gtk_action_set_accel_group ( GtkAction *action, GtkAccelGroup *accel_group);
GtkToggleAction* gtk_toggle_action_new (const gchar *name,const gchar *label,const gchar *tooltip,const gchar *stock_id);
void gtk_toggle_action_toggled ( GtkToggleAction *action);
void gtk_toggle_action_set_active ( GtkToggleAction *action,gboolean is_active);
gboolean gtk_toggle_action_get_active ( GtkToggleAction *action);
void gtk_toggle_action_set_draw_as_radio ( GtkToggleAction *action,gboolean draw_as_radio);
gboolean gtk_toggle_action_get_draw_as_radio ( GtkToggleAction *action);
GtkRadioAction* gtk_radio_action_new (const gchar *name,const gchar *label,const gchar *tooltip,const gchar *stock_id,gint value);
GSList* gtk_radio_action_get_group ( GtkRadioAction *action);
void gtk_radio_action_set_group ( GtkRadioAction *action,GSList *group);
gint gtk_radio_action_get_current_value ( GtkRadioAction *action);
void gtk_radio_action_set_current_value ( GtkRadioAction *action,gint current_value);
GtkWidget* gtk_color_button_new (void);
GtkWidget* gtk_color_button_new_with_color (const GdkColor *color);
void gtk_color_button_set_color ( GtkColorButton *color_button,const GdkColor *color);
void gtk_color_button_get_color ( GtkColorButton *color_button, GdkColor *color);
void gtk_color_button_set_alpha ( GtkColorButton *color_button,guint16 alpha);
guint16 gtk_color_button_get_alpha ( GtkColorButton *color_button);
void gtk_color_button_set_use_alpha ( GtkColorButton *color_button,gboolean use_alpha);
gboolean gtk_color_button_get_use_alpha ( GtkColorButton *color_button);
void gtk_color_button_set_title ( GtkColorButton *color_button,const gchar *title);
const gchar* gtk_color_button_get_title ( GtkColorButton *color_button);
GtkWidget* gtk_color_selection_new (void);
void gtk_color_selection_set_update_policy ( GtkColorSelection *colorsel, GtkUpdateType policy);
void gtk_color_selection_set_has_opacity_control ( GtkColorSelection *colorsel,gboolean has_opacity);
gboolean gtk_color_selection_get_has_opacity_control ( GtkColorSelection *colorsel);
void gtk_color_selection_set_has_palette ( GtkColorSelection *colorsel,gboolean has_palette);
gboolean gtk_color_selection_get_has_palette ( GtkColorSelection *colorsel);
guint16 gtk_color_selection_get_current_alpha ( GtkColorSelection *colorsel);
void gtk_color_selection_set_current_alpha ( GtkColorSelection *colorsel,guint16 alpha);
void gtk_color_selection_get_current_color ( GtkColorSelection *colorsel, GdkColor *color);
void gtk_color_selection_set_current_color ( GtkColorSelection *colorsel,const GdkColor *color);
guint16 gtk_color_selection_get_previous_alpha ( GtkColorSelection *colorsel);
void gtk_color_selection_set_previous_alpha ( GtkColorSelection *colorsel,guint16 alpha);
void gtk_color_selection_get_previous_color ( GtkColorSelection *colorsel, GdkColor *color);
void gtk_color_selection_set_previous_color ( GtkColorSelection *colorsel,const GdkColor *color);
gboolean gtk_color_selection_is_adjusting ( GtkColorSelection *colorsel);
gboolean gtk_color_selection_palette_from_string (const gchar *str, GdkColor **colors,gint *n_colors);
gchar* gtk_color_selection_palette_to_string (const GdkColor *colors,gint n_colors);
GtkColorSelectionChangePaletteFunc gtk_color_selection_set_change_palette_hook ( GtkColorSelectionChangePaletteFunc func);
GtkColorSelectionChangePaletteWithScreenFunc gtk_color_selection_set_change_palette_with_screen_hook ( GtkColorSelectionChangePaletteWithScreenFunc func);
void gtk_color_selection_set_color ( GtkColorSelection *colorsel,gdouble *color);
void gtk_color_selection_get_color ( GtkColorSelection *colorsel,gdouble *color);
GtkWidget* gtk_color_selection_dialog_new (const gchar *title);
GtkWidget* gtk_file_selection_new (const gchar *title);
void gtk_file_selection_set_filename ( GtkFileSelection *filesel,const gchar *filename);
const gchar* gtk_file_selection_get_filename ( GtkFileSelection *filesel);
void gtk_file_selection_complete ( GtkFileSelection *filesel,const gchar *pattern);
void gtk_file_selection_show_fileop_buttons ( GtkFileSelection *filesel);
void gtk_file_selection_hide_fileop_buttons ( GtkFileSelection *filesel);
gchar** gtk_file_selection_get_selections ( GtkFileSelection *filesel);
void gtk_file_selection_set_select_multiple ( GtkFileSelection *filesel,gboolean select_multiple);
gboolean gtk_file_selection_get_select_multiple ( GtkFileSelection *filesel);
void gtk_file_chooser_set_action ( GtkFileChooser *chooser, GtkFileChooserAction action);
GtkFileChooserAction gtk_file_chooser_get_action ( GtkFileChooser *chooser);
void gtk_file_chooser_set_local_only ( GtkFileChooser *chooser,gboolean local_only);
gboolean gtk_file_chooser_get_local_only ( GtkFileChooser *chooser);
void gtk_file_chooser_set_select_multiple ( GtkFileChooser *chooser,gboolean select_multiple);
gboolean gtk_file_chooser_get_select_multiple ( GtkFileChooser *chooser);
void gtk_file_chooser_set_show_hidden ( GtkFileChooser *chooser,gboolean show_hidden);
gboolean gtk_file_chooser_get_show_hidden ( GtkFileChooser *chooser);
void gtk_file_chooser_set_do_overwrite_confirmation ( GtkFileChooser *chooser,gboolean do_overwrite_confirmation);
gboolean gtk_file_chooser_get_do_overwrite_confirmation ( GtkFileChooser *chooser);
void gtk_file_chooser_set_current_name ( GtkFileChooser *chooser,const gchar *name);
gchar* gtk_file_chooser_get_filename ( GtkFileChooser *chooser);
gboolean gtk_file_chooser_set_filename ( GtkFileChooser *chooser,const char *filename);
gboolean gtk_file_chooser_select_filename ( GtkFileChooser *chooser,const char *filename);
void gtk_file_chooser_unselect_filename ( GtkFileChooser *chooser,const char *filename);
void gtk_file_chooser_select_all ( GtkFileChooser *chooser);
void gtk_file_chooser_unselect_all ( GtkFileChooser *chooser);
GSList* gtk_file_chooser_get_filenames ( GtkFileChooser *chooser);
gboolean gtk_file_chooser_set_current_folder ( GtkFileChooser *chooser,const gchar *filename);
gchar* gtk_file_chooser_get_current_folder ( GtkFileChooser *chooser);
gchar* gtk_file_chooser_get_uri ( GtkFileChooser *chooser);
gboolean gtk_file_chooser_set_uri ( GtkFileChooser *chooser,const char *uri);
gboolean gtk_file_chooser_select_uri ( GtkFileChooser *chooser,const char *uri);
void gtk_file_chooser_unselect_uri ( GtkFileChooser *chooser,const char *uri);
GSList* gtk_file_chooser_get_uris ( GtkFileChooser *chooser);
gboolean gtk_file_chooser_set_current_folder_uri ( GtkFileChooser *chooser,const gchar *uri);
gchar* gtk_file_chooser_get_current_folder_uri ( GtkFileChooser *chooser);
void gtk_file_chooser_set_preview_widget ( GtkFileChooser *chooser, GtkWidget *preview_widget);
GtkWidget* gtk_file_chooser_get_preview_widget ( GtkFileChooser *chooser);
void gtk_file_chooser_set_preview_widget_active ( GtkFileChooser *chooser,gboolean active);
gboolean gtk_file_chooser_get_preview_widget_active ( GtkFileChooser *chooser);
void gtk_file_chooser_set_use_preview_label ( GtkFileChooser *chooser,gboolean use_label);
gboolean gtk_file_chooser_get_use_preview_label ( GtkFileChooser *chooser);
char* gtk_file_chooser_get_preview_filename ( GtkFileChooser *chooser);
char* gtk_file_chooser_get_preview_uri ( GtkFileChooser *chooser);
void gtk_file_chooser_set_extra_widget ( GtkFileChooser *chooser, GtkWidget *extra_widget);
GtkWidget* gtk_file_chooser_get_extra_widget ( GtkFileChooser *chooser);
void gtk_file_chooser_add_filter ( GtkFileChooser *chooser, GtkFileFilter *filter);
void gtk_file_chooser_remove_filter ( GtkFileChooser *chooser, GtkFileFilter *filter);
GSList* gtk_file_chooser_list_filters ( GtkFileChooser *chooser);
void gtk_file_chooser_set_filter ( GtkFileChooser *chooser, GtkFileFilter *filter);
GtkFileFilter* gtk_file_chooser_get_filter ( GtkFileChooser *chooser);
gboolean gtk_file_chooser_add_shortcut_folder ( GtkFileChooser *chooser,const char *folder,GError **error);
gboolean gtk_file_chooser_remove_shortcut_folder ( GtkFileChooser *chooser,const char *folder,GError **error);
GSList* gtk_file_chooser_list_shortcut_folders ( GtkFileChooser *chooser);
gboolean gtk_file_chooser_add_shortcut_folder_uri ( GtkFileChooser *chooser,const char *uri,GError **error);
gboolean gtk_file_chooser_remove_shortcut_folder_uri ( GtkFileChooser *chooser,const char *uri,GError **error);
GSList* gtk_file_chooser_list_shortcut_folder_uris ( GtkFileChooser *chooser);
GtkWidget* gtk_file_chooser_button_new (const gchar *title, GtkFileChooserAction action);
GtkWidget* gtk_file_chooser_button_new_with_backend (const gchar *title, GtkFileChooserAction action,const gchar *backend);
GtkWidget* gtk_file_chooser_button_new_with_dialog ( GtkWidget *dialog);
const gchar* gtk_file_chooser_button_get_title ( GtkFileChooserButton *button);
void gtk_file_chooser_button_set_title ( GtkFileChooserButton *button,const gchar *title);
gint gtk_file_chooser_button_get_width_chars ( GtkFileChooserButton *button);
void gtk_file_chooser_button_set_width_chars ( GtkFileChooserButton *button,gint n_chars);
gboolean gtk_file_chooser_button_get_focus_on_click ( GtkFileChooserButton *button);
void gtk_file_chooser_button_set_focus_on_click ( GtkFileChooserButton *button,gboolean focus_on_click);
GtkWidget* gtk_file_chooser_dialog_new (const gchar *title, GtkWindow *parent, GtkFileChooserAction action,const gchar *first_button_text,...);
GtkWidget* gtk_file_chooser_dialog_new_with_backend (const gchar *title, GtkWindow *parent, GtkFileChooserAction action,const gchar *backend,const gchar *first_button_text,...);
GtkWidget* gtk_file_chooser_widget_new ( GtkFileChooserAction action);
GtkWidget* gtk_file_chooser_widget_new_with_backend ( GtkFileChooserAction action,const gchar *backend);
GtkFileFilter* gtk_file_filter_new (void);
void gtk_file_filter_set_name ( GtkFileFilter *filter,const gchar *name);
const gchar* gtk_file_filter_get_name ( GtkFileFilter *filter);
void gtk_file_filter_add_mime_type ( GtkFileFilter *filter,const gchar *mime_type);
void gtk_file_filter_add_pattern ( GtkFileFilter *filter,const gchar *pattern);
void gtk_file_filter_add_pixbuf_formats ( GtkFileFilter *filter);
void gtk_file_filter_add_custom ( GtkFileFilter *filter, GtkFileFilterFlags needed, GtkFileFilterFunc func,gpointer data,GDestroyNotify notify);
gboolean gtk_file_filter_filter ( GtkFileFilter *filter,const GtkFileFilterInfo *filter_info);
GtkWidget* gtk_font_button_new (void);
GtkWidget* gtk_font_button_new_with_font (const gchar *fontname);
gboolean gtk_font_button_set_font_name ( GtkFontButton *font_button,const gchar *fontname);
const gchar* gtk_font_button_get_font_name ( GtkFontButton *font_button);
void gtk_font_button_set_show_style ( GtkFontButton *font_button,gboolean show_style);
gboolean gtk_font_button_get_show_style ( GtkFontButton *font_button);
void gtk_font_button_set_show_size ( GtkFontButton *font_button,gboolean show_size);
gboolean gtk_font_button_get_show_size ( GtkFontButton *font_button);
void gtk_font_button_set_use_font ( GtkFontButton *font_button,gboolean use_font);
gboolean gtk_font_button_get_use_font ( GtkFontButton *font_button);
void gtk_font_button_set_use_size ( GtkFontButton *font_button,gboolean use_size);
gboolean gtk_font_button_get_use_size ( GtkFontButton *font_button);
void gtk_font_button_set_title ( GtkFontButton *font_button,const gchar *title);
const gchar* gtk_font_button_get_title ( GtkFontButton *font_button);
GtkWidget* gtk_font_selection_new (void);
GdkFont* gtk_font_selection_get_font ( GtkFontSelection *fontsel);
GdkFont* gtk_font_selection_get_font ( GtkFontSelection *fontsel);
gchar* gtk_font_selection_get_font_name ( GtkFontSelection *fontsel);
gboolean gtk_font_selection_set_font_name ( GtkFontSelection *fontsel,const gchar *fontname);
const gchar* gtk_font_selection_get_preview_text ( GtkFontSelection *fontsel);
void gtk_font_selection_set_preview_text ( GtkFontSelection *fontsel,const gchar *text);
GtkWidget* gtk_font_selection_dialog_new (const gchar *title);
GdkFont* gtk_font_selection_dialog_get_font ( GtkFontSelectionDialog *fsd);
GdkFont* gtk_font_selection_dialog_get_font ( GtkFontSelectionDialog *fsd);
gchar* gtk_font_selection_dialog_get_font_name ( GtkFontSelectionDialog *fsd);
gboolean gtk_font_selection_dialog_set_font_name ( GtkFontSelectionDialog *fsd,const gchar *fontname);
const gchar* gtk_font_selection_dialog_get_preview_text ( GtkFontSelectionDialog *fsd);
void gtk_font_selection_dialog_set_preview_text ( GtkFontSelectionDialog *fsd,const gchar *text);
GtkWidget* gtk_input_dialog_new (void);
GtkWidget* gtk_alignment_new (gfloat xalign,gfloat yalign,gfloat xscale,gfloat yscale);
void gtk_alignment_set ( GtkAlignment *alignment,gfloat xalign,gfloat yalign,gfloat xscale,gfloat yscale);
void gtk_alignment_get_padding ( GtkAlignment *alignment,guint *padding_top,guint *padding_bottom,guint *padding_left,guint *padding_right);
void gtk_alignment_set_padding ( GtkAlignment *alignment,guint padding_top,guint padding_bottom,guint padding_left,guint padding_right);
GtkWidget* gtk_aspect_frame_new (const gchar *label,gfloat xalign,gfloat yalign,gfloat ratio,gboolean obey_child);
void gtk_aspect_frame_set ( GtkAspectFrame *aspect_frame,gfloat xalign,gfloat yalign,gfloat ratio,gboolean obey_child);
GtkWidget* gtk_hbox_new (gboolean homogeneous,gint spacing);
GtkWidget* gtk_vbox_new (gboolean homogeneous,gint spacing);
GtkWidget* gtk_hbutton_box_new (void);
gint gtk_hbutton_box_get_spacing_default (void);
GtkButtonBoxStyle gtk_hbutton_box_get_layout_default (void);
void gtk_hbutton_box_set_spacing_default (gint spacing);
void gtk_hbutton_box_set_layout_default ( GtkButtonBoxStyle layout);
GtkWidget* gtk_vbutton_box_new (void);
gint gtk_vbutton_box_get_spacing_default (void);
void gtk_vbutton_box_set_spacing_default (gint spacing);
GtkButtonBoxStyle gtk_vbutton_box_get_layout_default (void);
void gtk_vbutton_box_set_layout_default ( GtkButtonBoxStyle layout);
GtkWidget* gtk_fixed_new (void);
void gtk_fixed_put ( GtkFixed *fixed, GtkWidget *widget,gint x,gint y);
void gtk_fixed_move ( GtkFixed *fixed, GtkWidget *widget,gint x,gint y);
gboolean gtk_fixed_get_has_window ( GtkFixed *fixed);
void gtk_fixed_set_has_window ( GtkFixed *fixed,gboolean has_window);
GtkWidget* gtk_hpaned_new (void);
GtkWidget* gtk_vpaned_new (void);
GtkWidget* gtk_layout_new ( GtkAdjustment *hadjustment, GtkAdjustment *vadjustment);
void gtk_layout_put ( GtkLayout *layout, GtkWidget *child_widget,gint x,gint y);
void gtk_layout_move ( GtkLayout *layout, GtkWidget *child_widget,gint x,gint y);
void gtk_layout_set_size ( GtkLayout *layout,guint width,guint height);
void gtk_layout_get_size ( GtkLayout *layout,guint *width,guint *height);
void gtk_layout_freeze ( GtkLayout *layout);
void gtk_layout_thaw ( GtkLayout *layout);
GtkAdjustment* gtk_layout_get_hadjustment ( GtkLayout *layout);
GtkAdjustment* gtk_layout_get_vadjustment ( GtkLayout *layout);
void gtk_layout_set_hadjustment ( GtkLayout *layout, GtkAdjustment *adjustment);
void gtk_layout_set_vadjustment ( GtkLayout *layout, GtkAdjustment *adjustment);
GtkWidget* gtk_notebook_new (void);
gint gtk_notebook_append_page ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
gint gtk_notebook_append_page_menu ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label);
gint gtk_notebook_prepend_page ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
gint gtk_notebook_prepend_page_menu ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label);
gint gtk_notebook_insert_page ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label,gint position);
gint gtk_notebook_insert_page_menu ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, GtkWidget *menu_label,gint position);
void gtk_notebook_remove_page ( GtkNotebook *notebook,gint page_num);
gint gtk_notebook_page_num ( GtkNotebook *notebook, GtkWidget *child);
void gtk_notebook_next_page ( GtkNotebook *notebook);
void gtk_notebook_prev_page ( GtkNotebook *notebook);
void gtk_notebook_reorder_child ( GtkNotebook *notebook, GtkWidget *child,gint position);
void gtk_notebook_set_tab_pos ( GtkNotebook *notebook, GtkPositionType pos);
void gtk_notebook_set_show_tabs ( GtkNotebook *notebook,gboolean show_tabs);
void gtk_notebook_set_show_border ( GtkNotebook *notebook,gboolean show_border);
void gtk_notebook_set_scrollable ( GtkNotebook *notebook,gboolean scrollable);
void gtk_notebook_set_tab_border ( GtkNotebook *notebook,guint border_width);
void gtk_notebook_popup_enable ( GtkNotebook *notebook);
void gtk_notebook_popup_disable ( GtkNotebook *notebook);
gint gtk_notebook_get_current_page ( GtkNotebook *notebook);
GtkWidget* gtk_notebook_get_menu_label ( GtkNotebook *notebook, GtkWidget *child);
GtkWidget* gtk_notebook_get_nth_page ( GtkNotebook *notebook,gint page_num);
gint gtk_notebook_get_n_pages ( GtkNotebook *notebook);
GtkWidget* gtk_notebook_get_tab_label ( GtkNotebook *notebook, GtkWidget *child);
void gtk_notebook_query_tab_label_packing ( GtkNotebook *notebook, GtkWidget *child,gboolean *expand,gboolean *fill, GtkPackType *pack_type);
void gtk_notebook_set_homogeneous_tabs ( GtkNotebook *notebook,gboolean homogeneous);
void gtk_notebook_set_menu_label ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *menu_label);
void gtk_notebook_set_menu_label_text ( GtkNotebook *notebook, GtkWidget *child,const gchar *menu_text);
void gtk_notebook_set_tab_hborder ( GtkNotebook *notebook,guint tab_hborder);
void gtk_notebook_set_tab_label ( GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);
void gtk_notebook_set_tab_label_packing ( GtkNotebook *notebook, GtkWidget *child,gboolean expand,gboolean fill, GtkPackType pack_type);
void gtk_notebook_set_tab_label_text ( GtkNotebook *notebook, GtkWidget *child,const gchar *tab_text);
void gtk_notebook_set_tab_vborder ( GtkNotebook *notebook,guint tab_vborder);
void gtk_notebook_set_tab_reorderable ( GtkNotebook *notebook, GtkWidget *child,gboolean reorderable);
void gtk_notebook_set_tab_detachable ( GtkNotebook *notebook, GtkWidget *child,gboolean detachable);
const gchar* gtk_notebook_get_menu_label_text ( GtkNotebook *notebook, GtkWidget *child);
gboolean gtk_notebook_get_scrollable ( GtkNotebook *notebook);
gboolean gtk_notebook_get_show_border ( GtkNotebook *notebook);
gboolean gtk_notebook_get_show_tabs ( GtkNotebook *notebook);
const gchar* gtk_notebook_get_tab_label_text ( GtkNotebook *notebook, GtkWidget *child);
GtkPositionType gtk_notebook_get_tab_pos ( GtkNotebook *notebook);
gboolean gtk_notebook_get_tab_reorderable ( GtkNotebook *notebook, GtkWidget *child);
gboolean gtk_notebook_get_tab_detachable ( GtkNotebook *notebook, GtkWidget *child);
void gtk_notebook_set_current_page ( GtkNotebook *notebook,gint page_num);
void gtk_notebook_set_group_id ( GtkNotebook *notebook,gint group_id);
gint gtk_notebook_get_group_id ( GtkNotebook *notebook);
void gtk_notebook_set_window_creation_hook ( GtkNotebookWindowCreationFunc func,gpointer data,GDestroyNotify destroy);
GtkWidget* gtk_table_new (guint rows,guint columns,gboolean homogeneous);
void gtk_table_resize ( GtkTable *table,guint rows,guint columns);
void gtk_table_attach ( GtkTable *table, GtkWidget *child,guint left_attach,guint right_attach,guint top_attach,guint bottom_attach, GtkAttachOptions xoptions, GtkAttachOptions yoptions,guint xpadding,guint ypadding);
void gtk_table_attach_defaults ( GtkTable *table, GtkWidget *widget,guint left_attach,guint right_attach,guint top_attach,guint bottom_attach);
void gtk_table_set_row_spacing ( GtkTable *table,guint row,guint spacing);
void gtk_table_set_col_spacing ( GtkTable *table,guint column,guint spacing);
void gtk_table_set_row_spacings ( GtkTable *table,guint spacing);
void gtk_table_set_col_spacings ( GtkTable *table,guint spacing);
void gtk_table_set_homogeneous ( GtkTable *table,gboolean homogeneous);
guint gtk_table_get_default_row_spacing ( GtkTable *table);
gboolean gtk_table_get_homogeneous ( GtkTable *table);
guint gtk_table_get_row_spacing ( GtkTable *table,guint row);
guint gtk_table_get_col_spacing ( GtkTable *table,guint column);
guint gtk_table_get_default_col_spacing ( GtkTable *table);
GtkWidget* gtk_expander_new (const gchar *label);
GtkWidget* gtk_expander_new_with_mnemonic (const gchar *label);
void gtk_expander_set_expanded ( GtkExpander *expander,gboolean expanded);
gboolean gtk_expander_get_expanded ( GtkExpander *expander);
void gtk_expander_set_spacing ( GtkExpander *expander,gint spacing);
gint gtk_expander_get_spacing ( GtkExpander *expander);
void gtk_expander_set_label ( GtkExpander *expander,const gchar *label);
const gchar* gtk_expander_get_label ( GtkExpander *expander);
void gtk_expander_set_use_underline ( GtkExpander *expander,gboolean use_underline);
gboolean gtk_expander_get_use_underline ( GtkExpander *expander);
void gtk_expander_set_use_markup ( GtkExpander *expander,gboolean use_markup);
gboolean gtk_expander_get_use_markup ( GtkExpander *expander);
void gtk_expander_set_label_widget ( GtkExpander *expander, GtkWidget *label_widget);
GtkWidget* gtk_expander_get_label_widget ( GtkExpander *expander);
GtkWidget* gtk_frame_new (const gchar *label);
void gtk_frame_set_label ( GtkFrame *frame,const gchar *label);
void gtk_frame_set_label_widget ( GtkFrame *frame, GtkWidget *label_widget);
void gtk_frame_set_label_align ( GtkFrame *frame,gfloat xalign,gfloat yalign);
void gtk_frame_set_shadow_type ( GtkFrame *frame, GtkShadowType type);
const gchar* gtk_frame_get_label ( GtkFrame *frame);
void gtk_frame_get_label_align ( GtkFrame *frame,gfloat *xalign,gfloat *yalign);
GtkWidget* gtk_frame_get_label_widget ( GtkFrame *frame);
GtkShadowType gtk_frame_get_shadow_type ( GtkFrame *frame);
GtkWidget* gtk_hseparator_new (void);
GtkWidget* gtk_vseparator_new (void);
GtkWidget* gtk_hscrollbar_new ( GtkAdjustment *adjustment);
GtkWidget* gtk_vscrollbar_new ( GtkAdjustment *adjustment);
GtkWidget* gtk_scrolled_window_new ( GtkAdjustment *hadjustment, GtkAdjustment *vadjustment);
GtkAdjustment* gtk_scrolled_window_get_hadjustment ( GtkScrolledWindow *scrolled_window);
GtkAdjustment* gtk_scrolled_window_get_vadjustment ( GtkScrolledWindow *scrolled_window);
GtkWidget* gtk_scrolled_window_get_hscrollbar ( GtkScrolledWindow *scrolled_window);
GtkWidget* gtk_scrolled_window_get_vscrollbar ( GtkScrolledWindow *scrolled_window);
void gtk_scrolled_window_set_policy ( GtkScrolledWindow *scrolled_window, GtkPolicyType hscrollbar_policy, GtkPolicyType vscrollbar_policy);
void gtk_scrolled_window_add_with_viewport ( GtkScrolledWindow *scrolled_window, GtkWidget *child);
void gtk_scrolled_window_set_placement ( GtkScrolledWindow *scrolled_window, GtkCornerType window_placement);
void gtk_scrolled_window_unset_placement ( GtkScrolledWindow *scrolled_window);
void gtk_scrolled_window_set_shadow_type ( GtkScrolledWindow *scrolled_window, GtkShadowType type);
void gtk_scrolled_window_set_hadjustment ( GtkScrolledWindow *scrolled_window, GtkAdjustment *hadjustment);
void gtk_scrolled_window_set_vadjustment ( GtkScrolledWindow *scrolled_window, GtkAdjustment *vadjustment);
GtkCornerType gtk_scrolled_window_get_placement ( GtkScrolledWindow *scrolled_window);
void gtk_scrolled_window_get_policy ( GtkScrolledWindow *scrolled_window, GtkPolicyType *hscrollbar_policy, GtkPolicyType *vscrollbar_policy);
GtkShadowType gtk_scrolled_window_get_shadow_type ( GtkScrolledWindow *scrolled_window);
GtkPrintOperation* gtk_print_operation_new (void);
void gtk_print_operation_set_allow_async ( GtkPrintOperation *op,gboolean allow_async);
void gtk_print_operation_set_default_page_setup ( GtkPrintOperation *op, GtkPageSetup *default_page_setup);
GtkPageSetup* gtk_print_operation_get_default_page_setup ( GtkPrintOperation *op);
void gtk_print_operation_set_print_settings ( GtkPrintOperation *op, GtkPrintSettings *print_settings);
GtkPrintSettings* gtk_print_operation_get_print_settings ( GtkPrintOperation *op);
void gtk_print_operation_set_job_name ( GtkPrintOperation *op,const gchar *job_name);
void gtk_print_operation_set_n_pages ( GtkPrintOperation *op,gint n_pages);
void gtk_print_operation_set_current_page ( GtkPrintOperation *op,gint current_page);
void gtk_print_operation_set_use_full_page ( GtkPrintOperation *op,gboolean full_page);
void gtk_print_operation_set_unit ( GtkPrintOperation *op, GtkUnit unit);
void gtk_print_operation_set_export_filename ( GtkPrintOperation *op,const gchar *filename);
void gtk_print_operation_set_show_progress ( GtkPrintOperation *op,gboolean show_progress);
void gtk_print_operation_set_track_print_status ( GtkPrintOperation *op,gboolean track_status);
void gtk_print_operation_set_custom_tab_label ( GtkPrintOperation *op,const gchar *label);
GtkPrintOperationResult gtk_print_operation_run ( GtkPrintOperation *op, GtkPrintOperationAction action, GtkWindow *parent,GError **error);
void gtk_print_operation_cancel ( GtkPrintOperation *op);
GtkPrintStatus gtk_print_operation_get_status ( GtkPrintOperation *op);
const gchar* gtk_print_operation_get_status_string ( GtkPrintOperation *op);
gboolean gtk_print_operation_is_finished ( GtkPrintOperation *op);
GtkPageSetup* gtk_print_run_page_setup_dialog ( GtkWindow *parent, GtkPageSetup *page_setup, GtkPrintSettings *settings);
void gtk_print_run_page_setup_dialog_async ( GtkWindow *parent, GtkPageSetup *page_setup, GtkPrintSettings *settings, GtkPageSetupDoneFunc done_cb,gpointer data);
void gtk_print_operation_preview_end_preview ( GtkPrintOperationPreview *preview);
gboolean gtk_print_operation_preview_is_selected ( GtkPrintOperationPreview *preview,gint page_nr);
void gtk_print_operation_preview_render_page ( GtkPrintOperationPreview *preview,gint page_nr);
cairo_t* gtk_print_context_get_cairo_context ( GtkPrintContext *context);
cairo_t* gtk_print_context_get_cairo_context ( GtkPrintContext *context);
GtkPageSetup* gtk_print_context_get_page_setup ( GtkPrintContext *context);
gdouble gtk_print_context_get_width ( GtkPrintContext *context);
gdouble gtk_print_context_get_height ( GtkPrintContext *context);
gdouble gtk_print_context_get_dpi_x ( GtkPrintContext *context);
gdouble gtk_print_context_get_dpi_y ( GtkPrintContext *context);
PangoFontMap* gtk_print_context_get_pango_fontmap ( GtkPrintContext *context);
PangoContext* gtk_print_context_create_pango_context ( GtkPrintContext *context);
PangoLayout* gtk_print_context_create_pango_layout ( GtkPrintContext *context);
GtkPrintSettings* gtk_print_settings_new (void);
GtkPrintSettings* gtk_print_settings_copy ( GtkPrintSettings *other);
gboolean gtk_print_settings_has_key ( GtkPrintSettings *settings,const gchar *key);
const gchar* gtk_print_settings_get ( GtkPrintSettings *settings,const gchar *key);
void gtk_print_settings_set ( GtkPrintSettings *settings,const gchar *key,const gchar *value);
void gtk_print_settings_unset ( GtkPrintSettings *settings,const gchar *key);
void gtk_print_settings_foreach ( GtkPrintSettings *settings, GtkPrintSettingsFunc func,gpointer user_data);
gboolean gtk_print_settings_get_bool ( GtkPrintSettings *settings,const gchar *key);
void gtk_print_settings_set_bool ( GtkPrintSettings *settings,const gchar *key,gboolean value);
gdouble gtk_print_settings_get_double ( GtkPrintSettings *settings,const gchar *key);
gdouble gtk_print_settings_get_double_with_default ( GtkPrintSettings *settings,const gchar *key,gdouble def);
void gtk_print_settings_set_double ( GtkPrintSettings *settings,const gchar *key,gdouble value);
gdouble gtk_print_settings_get_length ( GtkPrintSettings *settings,const gchar *key, GtkUnit unit);
void gtk_print_settings_set_length ( GtkPrintSettings *settings,const gchar *key,gdouble value, GtkUnit unit);
gint gtk_print_settings_get_int ( GtkPrintSettings *settings,const gchar *key);
gint gtk_print_settings_get_int_with_default ( GtkPrintSettings *settings,const gchar *key,gint def);
void gtk_print_settings_set_int ( GtkPrintSettings *settings,const gchar *key,gint value);
const gchar* gtk_print_settings_get_printer ( GtkPrintSettings *settings);
void gtk_print_settings_set_printer ( GtkPrintSettings *settings,const gchar *printer);
GtkPageOrientation gtk_print_settings_get_orientation ( GtkPrintSettings *settings);
void gtk_print_settings_set_orientation ( GtkPrintSettings *settings, GtkPageOrientation orientation);
GtkPaperSize* gtk_print_settings_get_paper_size ( GtkPrintSettings *settings);
void gtk_print_settings_set_paper_size ( GtkPrintSettings *settings, GtkPaperSize *paper_size);
gdouble gtk_print_settings_get_paper_width ( GtkPrintSettings *settings, GtkUnit unit);
void gtk_print_settings_set_paper_width ( GtkPrintSettings *settings,gdouble width, GtkUnit unit);
gdouble gtk_print_settings_get_paper_height ( GtkPrintSettings *settings, GtkUnit unit);
void gtk_print_settings_set_paper_height ( GtkPrintSettings *settings,gdouble height, GtkUnit unit);
gboolean gtk_print_settings_get_use_color ( GtkPrintSettings *settings);
void gtk_print_settings_set_use_color ( GtkPrintSettings *settings,gboolean use_color);
gboolean gtk_print_settings_get_collate ( GtkPrintSettings *settings);
void gtk_print_settings_set_collate ( GtkPrintSettings *settings,gboolean collate);
gboolean gtk_print_settings_get_reverse ( GtkPrintSettings *settings);
void gtk_print_settings_set_reverse ( GtkPrintSettings *settings,gboolean reverse);
GtkPrintDuplex gtk_print_settings_get_duplex ( GtkPrintSettings *settings);
void gtk_print_settings_set_duplex ( GtkPrintSettings *settings, GtkPrintDuplex duplex);
GtkPrintQuality gtk_print_settings_get_quality ( GtkPrintSettings *settings);
void gtk_print_settings_set_quality ( GtkPrintSettings *settings, GtkPrintQuality quality);
gint gtk_print_settings_get_n_copies ( GtkPrintSettings *settings);
void gtk_print_settings_set_n_copies ( GtkPrintSettings *settings,gint num_copies);
gint gtk_print_settings_get_number_up ( GtkPrintSettings *settings);
void gtk_print_settings_set_number_up ( GtkPrintSettings *settings,gint number_up);
gint gtk_print_settings_get_resolution ( GtkPrintSettings *settings);
void gtk_print_settings_set_resolution ( GtkPrintSettings *settings,gint resolution);
gdouble gtk_print_settings_get_scale ( GtkPrintSettings *settings);
void gtk_print_settings_set_scale ( GtkPrintSettings *settings,gdouble scale);
GtkPrintPages gtk_print_settings_get_print_pages ( GtkPrintSettings *settings);
void gtk_print_settings_set_print_pages ( GtkPrintSettings *settings, GtkPrintPages pages); GtkPageRange ;
GtkPageRange* gtk_print_settings_get_page_ranges ( GtkPrintSettings *settings,gint *num_ranges);
void gtk_print_settings_set_page_ranges ( GtkPrintSettings *settings, GtkPageRange *page_ranges,gint num_ranges);
GtkPageSet gtk_print_settings_get_page_set ( GtkPrintSettings *settings);
void gtk_print_settings_set_page_set ( GtkPrintSettings *settings, GtkPageSet page_set);
const gchar* gtk_print_settings_get_default_source ( GtkPrintSettings *settings);
void gtk_print_settings_set_default_source ( GtkPrintSettings *settings,const gchar *default_source);
const gchar* gtk_print_settings_get_media_type ( GtkPrintSettings *settings);
void gtk_print_settings_set_media_type ( GtkPrintSettings *settings,const gchar *media_type);
const gchar* gtk_print_settings_get_dither ( GtkPrintSettings *settings);
void gtk_print_settings_set_dither ( GtkPrintSettings *settings,const gchar *dither);
const gchar* gtk_print_settings_get_finishings ( GtkPrintSettings *settings);
void gtk_print_settings_set_finishings ( GtkPrintSettings *settings,const gchar *finishings);
const gchar* gtk_print_settings_get_output_bin ( GtkPrintSettings *settings);
void gtk_print_settings_set_output_bin ( GtkPrintSettings *settings,const gchar *output_bin);
GtkPageSetup* gtk_page_setup_new (void);
GtkPageSetup* gtk_page_setup_copy ( GtkPageSetup *other);
GtkPageOrientation gtk_page_setup_get_orientation ( GtkPageSetup *setup);
void gtk_page_setup_set_orientation ( GtkPageSetup *setup, GtkPageOrientation orientation);
GtkPaperSize* gtk_page_setup_get_paper_size ( GtkPageSetup *setup);
void gtk_page_setup_set_paper_size ( GtkPageSetup *setup, GtkPaperSize *size);
gdouble gtk_page_setup_get_top_margin ( GtkPageSetup *setup, GtkUnit unit);
void gtk_page_setup_set_top_margin ( GtkPageSetup *setup,gdouble margin, GtkUnit unit);
gdouble gtk_page_setup_get_bottom_margin ( GtkPageSetup *setup, GtkUnit unit);
void gtk_page_setup_set_bottom_margin ( GtkPageSetup *setup,gdouble margin, GtkUnit unit);
gdouble gtk_page_setup_get_left_margin ( GtkPageSetup *setup, GtkUnit unit);
void gtk_page_setup_set_left_margin ( GtkPageSetup *setup,gdouble margin, GtkUnit unit);
gdouble gtk_page_setup_get_right_margin ( GtkPageSetup *setup, GtkUnit unit);
void gtk_page_setup_set_right_margin ( GtkPageSetup *setup,gdouble margin, GtkUnit unit);
void gtk_page_setup_set_paper_size_and_default_margins ( GtkPageSetup *setup, GtkPaperSize *size);
gdouble gtk_page_setup_get_paper_width ( GtkPageSetup *setup, GtkUnit unit);
gdouble gtk_page_setup_get_paper_height ( GtkPageSetup *setup, GtkUnit unit);
gdouble gtk_page_setup_get_page_width ( GtkPageSetup *setup, GtkUnit unit);
gdouble gtk_page_setup_get_page_height ( GtkPageSetup *setup, GtkUnit unit);
GtkPaperSize* gtk_paper_size_new (const gchar *name);
GtkPaperSize* gtk_paper_size_new_from_ppd (const gchar *ppd_name,const gchar *ppd_display_name,gdouble width,gdouble height);
GtkPaperSize* gtk_paper_size_new_custom (const gchar *name,const gchar *display_name,gdouble width,gdouble height, GtkUnit unit);
GtkPaperSize* gtk_paper_size_copy ( GtkPaperSize *other);
void gtk_paper_size_free ( GtkPaperSize *size);
gboolean gtk_paper_size_is_equal ( GtkPaperSize *size1, GtkPaperSize *size2);
const gchar* gtk_paper_size_get_name ( GtkPaperSize *size);
const gchar* gtk_paper_size_get_display_name ( GtkPaperSize *size);
const gchar* gtk_paper_size_get_ppd_name ( GtkPaperSize *size);
gdouble gtk_paper_size_get_width ( GtkPaperSize *size, GtkUnit unit);
gdouble gtk_paper_size_get_height ( GtkPaperSize *size, GtkUnit unit);
gboolean gtk_paper_size_is_custom ( GtkPaperSize *size);
void gtk_paper_size_set_size ( GtkPaperSize *size,gdouble width,gdouble height, GtkUnit unit);
gdouble gtk_paper_size_get_default_top_margin ( GtkPaperSize *size, GtkUnit unit);
gdouble gtk_paper_size_get_default_bottom_margin ( GtkPaperSize *size, GtkUnit unit);
gdouble gtk_paper_size_get_default_left_margin ( GtkPaperSize *size, GtkUnit unit);
gdouble gtk_paper_size_get_default_right_margin ( GtkPaperSize *size, GtkUnit unit);
const gchar* gtk_paper_size_get_default (void);
GtkPrinter* gtk_printer_new (const gchar *name, GtkPrintBackend *backend,gboolean virtual_);
GtkPrintBackend* gtk_printer_get_backend ( GtkPrinter *printer);
const gchar* gtk_printer_get_name ( GtkPrinter *printer);
const gchar* gtk_printer_get_state_message ( GtkPrinter *printer);
const gchar* gtk_printer_get_description ( GtkPrinter *printer);
const gchar* gtk_printer_get_location ( GtkPrinter *printer);
const gchar* gtk_printer_get_icon_name ( GtkPrinter *printer);
gint gtk_printer_get_job_count ( GtkPrinter *printer);
gboolean gtk_printer_is_active ( GtkPrinter *printer);
gboolean gtk_printer_is_virtual ( GtkPrinter *printer);
gboolean gtk_printer_is_default ( GtkPrinter *printer);
gboolean gtk_printer_accepts_ps ( GtkPrinter *printer);
gboolean gtk_printer_accepts_pdf ( GtkPrinter *printer);
gint gtk_printer_compare ( GtkPrinter *a, GtkPrinter *b);
void gtk_enumerate_printers ( GtkPrinterFunc func,gpointer data,GDestroyNotify destroy,gboolean wait);
GtkPrintJob* gtk_print_job_new (const gchar *title, GtkPrinter *printer, GtkPrintSettings *settings, GtkPageSetup *page_setup);
GtkPrintSettings* gtk_print_job_get_settings ( GtkPrintJob *job);
GtkPrinter* gtk_print_job_get_printer ( GtkPrintJob *job);
const gchar* gtk_print_job_get_title ( GtkPrintJob *job);
GtkPrintStatus gtk_print_job_get_status ( GtkPrintJob *job);
gboolean gtk_print_job_set_source_file ( GtkPrintJob *job,const gchar *filename,GError **error);
cairo_surface_t* gtk_print_job_get_surface ( GtkPrintJob *job,GError **error);
cairo_surface_t* gtk_print_job_get_surface ( GtkPrintJob *job,GError **error);
void gtk_print_job_send ( GtkPrintJob *job, GtkPrintJobCompleteFunc callback,gpointer user_data,GDestroyNotify dnotify);
void gtk_print_job_set_track_print_status ( GtkPrintJob *job,gboolean track_status);
gboolean gtk_print_job_get_track_print_status ( GtkPrintJob *job);
GtkWidget* gtk_print_unix_dialog_new (const gchar *title, GtkWindow *parent);
void gtk_print_unix_dialog_set_page_setup ( GtkPrintUnixDialog *dialog, GtkPageSetup *page_setup);
GtkPageSetup* gtk_print_unix_dialog_get_page_setup ( GtkPrintUnixDialog *dialog);
void gtk_print_unix_dialog_set_current_page ( GtkPrintUnixDialog *dialog,gint current_page);
gint gtk_print_unix_dialog_get_current_page ( GtkPrintUnixDialog *dialog);
void gtk_print_unix_dialog_set_settings ( GtkPrintUnixDialog *dialog, GtkPrintSettings *settings);
GtkPrintSettings* gtk_print_unix_dialog_get_settings ( GtkPrintUnixDialog *dialog);
GtkPrinter* gtk_print_unix_dialog_get_selected_printer ( GtkPrintUnixDialog *dialog);
void gtk_print_unix_dialog_add_custom_tab ( GtkPrintUnixDialog *dialog, GtkWidget *child, GtkWidget *tab_label);
void gtk_print_unix_dialog_set_manual_capabilities ( GtkPrintUnixDialog *dialog, GtkPrintCapabilities capabilities);
GtkWidget* gtk_page_setup_unix_dialog_new (const gchar *title, GtkWindow *parent);
void gtk_page_setup_unix_dialog_set_page_setup ( GtkPageSetupUnixDialog *dialog, GtkPageSetup *page_setup);
GtkPageSetup* gtk_page_setup_unix_dialog_get_page_setup ( GtkPageSetupUnixDialog *dialog);
void gtk_page_setup_unix_dialog_set_print_settings ( GtkPageSetupUnixDialog *dialog, GtkPrintSettings *print_settings);
GtkPrintSettings* gtk_page_setup_unix_dialog_get_print_settings ( GtkPageSetupUnixDialog *dialog);
GtkObject* gtk_adjustment_new (gdouble value,gdouble lower,gdouble upper,gdouble step_increment,gdouble page_increment,gdouble page_size);
gdouble gtk_adjustment_get_value ( GtkAdjustment *adjustment);
void gtk_adjustment_set_value ( GtkAdjustment *adjustment,gdouble value);
void gtk_adjustment_clamp_page ( GtkAdjustment *adjustment,gdouble lower,gdouble upper);
void gtk_adjustment_changed ( GtkAdjustment *adjustment);
void gtk_adjustment_value_changed ( GtkAdjustment *adjustment);
GtkWidget* gtk_arrow_new ( GtkArrowType arrow_type, GtkShadowType shadow_type);
void gtk_arrow_set ( GtkArrow *arrow, GtkArrowType arrow_type, GtkShadowType shadow_type);
GtkWidget* gtk_calendar_new (void);
gboolean gtk_calendar_select_month ( GtkCalendar *calendar,guint month,guint year);
void gtk_calendar_select_day ( GtkCalendar *calendar,guint day);
gboolean gtk_calendar_mark_day ( GtkCalendar *calendar,guint day);
gboolean gtk_calendar_unmark_day ( GtkCalendar *calendar,guint day);
void gtk_calendar_clear_marks ( GtkCalendar *calendar);
GtkCalendarDisplayOptions gtk_calendar_get_display_options ( GtkCalendar *calendar);
void gtk_calendar_set_display_options ( GtkCalendar *calendar, GtkCalendarDisplayOptions flags);
void gtk_calendar_display_options ( GtkCalendar *calendar, GtkCalendarDisplayOptions flags);
void gtk_calendar_get_date ( GtkCalendar *calendar,guint *year,guint *month,guint *day);
void gtk_calendar_freeze ( GtkCalendar *calendar);
void gtk_calendar_thaw ( GtkCalendar *calendar);
GtkWidget* gtk_drawing_area_new (void);
void gtk_drawing_area_size ( GtkDrawingArea *darea,gint width,gint height);
GtkWidget* gtk_event_box_new (void);
void gtk_event_box_set_above_child ( GtkEventBox *event_box,gboolean above_child);
gboolean gtk_event_box_get_above_child ( GtkEventBox *event_box);
void gtk_event_box_set_visible_window ( GtkEventBox *event_box,gboolean visible_window);
gboolean gtk_event_box_get_visible_window ( GtkEventBox *event_box);
GtkWidget* gtk_handle_box_new (void);
void gtk_handle_box_set_shadow_type ( GtkHandleBox *handle_box, GtkShadowType type);
void gtk_handle_box_set_handle_position ( GtkHandleBox *handle_box, GtkPositionType position);
void gtk_handle_box_set_snap_edge ( GtkHandleBox *handle_box, GtkPositionType edge);
GtkPositionType gtk_handle_box_get_handle_position ( GtkHandleBox *handle_box);
GtkShadowType gtk_handle_box_get_shadow_type ( GtkHandleBox *handle_box);
GtkPositionType gtk_handle_box_get_snap_edge ( GtkHandleBox *handle_box);
GtkIMContext* gtk_im_context_simple_new (void);
void gtk_im_context_simple_add_table ( GtkIMContextSimple *context_simple,guint16 *data,gint max_seq_len,gint n_seqs);
GtkIMContext* gtk_im_multicontext_new (void);
void gtk_im_multicontext_append_menuitems ( GtkIMMulticontext *context, GtkMenuShell *menushell);
GtkSizeGroup* gtk_size_group_new ( GtkSizeGroupMode mode);
void gtk_size_group_set_mode ( GtkSizeGroup *size_group, GtkSizeGroupMode mode);
GtkSizeGroupMode gtk_size_group_get_mode ( GtkSizeGroup *size_group);
void gtk_size_group_set_ignore_hidden ( GtkSizeGroup *size_group,gboolean ignore_hidden);
gboolean gtk_size_group_get_ignore_hidden ( GtkSizeGroup *size_group);
void gtk_size_group_add_widget ( GtkSizeGroup *size_group, GtkWidget *widget);
void gtk_size_group_remove_widget ( GtkSizeGroup *size_group, GtkWidget *widget);
GSList* gtk_size_group_get_widgets ( GtkSizeGroup *size_group);
GtkTooltips* gtk_tooltips_new (void);
void gtk_tooltips_enable ( GtkTooltips *tooltips);
void gtk_tooltips_disable ( GtkTooltips *tooltips);
void gtk_tooltips_set_delay ( GtkTooltips *tooltips,guint delay);
void gtk_tooltips_set_tip ( GtkTooltips *tooltips, GtkWidget *widget,const gchar *tip_text,const gchar *tip_private);
GtkTooltipsData* gtk_tooltips_data_get ( GtkWidget *widget);
void gtk_tooltips_force_window ( GtkTooltips *tooltips);
gboolean gtk_tooltips_get_info_from_tip_window ( GtkWindow *tip_window, GtkTooltips **tooltips, GtkWidget **current_widget);
GtkWidget* gtk_viewport_new ( GtkAdjustment *hadjustment, GtkAdjustment *vadjustment);
GtkAdjustment* gtk_viewport_get_hadjustment ( GtkViewport *viewport);
GtkAdjustment* gtk_viewport_get_vadjustment ( GtkViewport *viewport);
void gtk_viewport_set_hadjustment ( GtkViewport *viewport, GtkAdjustment *adjustment);
void gtk_viewport_set_vadjustment ( GtkViewport *viewport, GtkAdjustment *adjustment);
void gtk_viewport_set_shadow_type ( GtkViewport *viewport, GtkShadowType type);
GtkShadowType gtk_viewport_get_shadow_type ( GtkViewport *viewport);
void gtk_accessible_connect_widget_destroyed ( GtkAccessible *accessible);
GtkWidget* gtk_bin_get_child ( GtkBin *bin);
void gtk_box_pack_start ( GtkBox *box, GtkWidget *child,gboolean expand,gboolean fill,guint padding);
void gtk_box_pack_end ( GtkBox *box, GtkWidget *child,gboolean expand,gboolean fill,guint padding);
void gtk_box_pack_start_defaults ( GtkBox *box, GtkWidget *widget);
void gtk_box_pack_end_defaults ( GtkBox *box, GtkWidget *widget);
gboolean gtk_box_get_homogeneous ( GtkBox *box);
void gtk_box_set_homogeneous ( GtkBox *box,gboolean homogeneous);
gint gtk_box_get_spacing ( GtkBox *box);
void gtk_box_set_spacing ( GtkBox *box,gint spacing);
void gtk_box_reorder_child ( GtkBox *box, GtkWidget *child,gint position);
void gtk_box_query_child_packing ( GtkBox *box, GtkWidget *child,gboolean *expand,gboolean *fill,guint *padding, GtkPackType *pack_type);
void gtk_box_set_child_packing ( GtkBox *box, GtkWidget *child,gboolean expand,gboolean fill,guint padding, GtkPackType pack_type);
GtkButtonBoxStyle gtk_button_box_get_layout ( GtkButtonBox *widget);
void gtk_button_box_get_child_size ( GtkButtonBox *widget,gint *min_width,gint *min_height);
void gtk_button_box_get_child_ipadding ( GtkButtonBox *widget,gint *ipad_x,gint *ipad_y);
gboolean gtk_button_box_get_child_secondary ( GtkButtonBox *widget, GtkWidget *child);
void gtk_button_box_set_layout ( GtkButtonBox *widget, GtkButtonBoxStyle layout_style);
void gtk_button_box_set_child_size ( GtkButtonBox *widget,gint min_width,gint min_height);
void gtk_button_box_set_child_ipadding ( GtkButtonBox *widget,gint ipad_x,gint ipad_y);
void gtk_button_box_set_child_secondary ( GtkButtonBox *widget, GtkWidget *child,gboolean is_secondary);
void gtk_container_add ( GtkContainer *container, GtkWidget *widget);
void gtk_container_remove ( GtkContainer *container, GtkWidget *widget);
void gtk_container_add_with_properties ( GtkContainer *container, GtkWidget *widget,const gchar *first_prop_name,...);
GtkResizeMode gtk_container_get_resize_mode ( GtkContainer *container);
void gtk_container_set_resize_mode ( GtkContainer *container, GtkResizeMode resize_mode);
void gtk_container_check_resize ( GtkContainer *container);
void gtk_container_foreach ( GtkContainer *container, GtkCallback callback,gpointer callback_data);
void gtk_container_foreach_full ( GtkContainer *container, GtkCallback callback, GtkCallbackMarshal marshal,gpointer callback_data, GtkDestroyNotify notify);
GList* gtk_container_get_children ( GtkContainer *container);
void gtk_container_set_reallocate_redraws ( GtkContainer *container,gboolean needs_redraws);
void gtk_container_set_focus_child ( GtkContainer *container, GtkWidget *child);
GtkAdjustment* gtk_container_get_focus_vadjustment ( GtkContainer *container);
void gtk_container_set_focus_vadjustment ( GtkContainer *container, GtkAdjustment *adjustment);
GtkAdjustment* gtk_container_get_focus_hadjustment ( GtkContainer *container);
void gtk_container_set_focus_hadjustment ( GtkContainer *container, GtkAdjustment *adjustment);
void gtk_container_resize_children ( GtkContainer *container);
GType gtk_container_child_type ( GtkContainer *container);
void gtk_container_child_get ( GtkContainer *container, GtkWidget *child,const gchar *first_prop_name,...);
void gtk_container_child_set ( GtkContainer *container, GtkWidget *child,const gchar *first_prop_name,...);
void gtk_container_child_get_property ( GtkContainer *container, GtkWidget *child,const gchar *property_name,GValue *value);
void gtk_container_child_set_property ( GtkContainer *container, GtkWidget *child,const gchar *property_name,const GValue *value);
void gtk_container_child_get_valist ( GtkContainer *container, GtkWidget *child,const gchar *first_property_name,va_list var_args);
void gtk_container_child_set_valist ( GtkContainer *container, GtkWidget *child,const gchar *first_property_name,va_list var_args);
void gtk_container_forall ( GtkContainer *container, GtkCallback callback,gpointer callback_data);
guint gtk_container_get_border_width ( GtkContainer *container);
void gtk_container_set_border_width ( GtkContainer *container,guint border_width);
void gtk_container_propagate_expose ( GtkContainer *container, GtkWidget *child, GdkEventExpose *event);
gboolean gtk_container_get_focus_chain ( GtkContainer *container,GList **focusable_widgets);
void gtk_container_set_focus_chain ( GtkContainer *container,GList *focusable_widgets);
void gtk_container_unset_focus_chain ( GtkContainer *container);
GParamSpec* gtk_container_class_find_child_property (GObjectClass *cclass,const gchar *property_name);
void gtk_container_class_install_child_property (GtkContainerClass *cclass,guint property_id,GParamSpec *pspec);
GParamSpec** gtk_container_class_list_child_properties (GObjectClass *cclass,guint *n_properties);
void gtk_item_select ( GtkItem *item);
void gtk_item_deselect ( GtkItem *item);
void gtk_item_toggle ( GtkItem *item);
void gtk_misc_set_alignment ( GtkMisc *misc,gfloat xalign,gfloat yalign);
void gtk_misc_set_padding ( GtkMisc *misc,gint xpad,gint ypad);
void gtk_misc_get_alignment ( GtkMisc *misc,gfloat *xalign,gfloat *yalign);
void gtk_misc_get_padding ( GtkMisc *misc,gint *xpad,gint *ypad);
GtkObject* gtk_object_new ( GtkType type,const gchar *first_property_name,...);
void gtk_object_sink ( GtkObject *object);
GtkObject* gtk_object_ref ( GtkObject *object);
void gtk_object_unref ( GtkObject *object);
void gtk_object_weakref ( GtkObject *object, GtkDestroyNotify notify,gpointer data);
void gtk_object_weakunref ( GtkObject *object, GtkDestroyNotify notify,gpointer data);
void gtk_object_destroy ( GtkObject *object);
void gtk_object_get ( GtkObject *object,const gchar *first_property_name,...);
void gtk_object_set ( GtkObject *object,const gchar *first_property_name,...);
void gtk_object_set_data ( GtkObject *object,const gchar *key,gpointer data);
void gtk_object_set_data_full ( GtkObject *object,const gchar *key,gpointer data, GtkDestroyNotify destroy);
void gtk_object_remove_data ( GtkObject *object,const gchar *key);
gpointer gtk_object_get_data ( GtkObject *object,const gchar *key);
void gtk_object_remove_no_notify ( GtkObject *object,const gchar *key);
void gtk_object_set_user_data ( GtkObject *object,gpointer data);
gpointer gtk_object_get_user_data ( GtkObject *object);
void gtk_object_add_arg_type (const gchar *arg_name, GtkType arg_type,guint arg_flags,guint arg_id);
void gtk_object_set_data_by_id ( GtkObject *object,GQuark data_id,gpointer data);
void gtk_object_set_data_by_id_full ( GtkObject *object,GQuark data_id,gpointer data, GtkDestroyNotify destroy);
gpointer gtk_object_get_data_by_id ( GtkObject *object,GQuark data_id);
void gtk_object_remove_data_by_id ( GtkObject *object,GQuark data_id);
void gtk_object_remove_no_notify_by_id ( GtkObject *object,GQuark key_id);
void gtk_paned_add1 ( GtkPaned *paned, GtkWidget *child);
void gtk_paned_add2 ( GtkPaned *paned, GtkWidget *child);
void gtk_paned_pack1 ( GtkPaned *paned, GtkWidget *child,gboolean resize,gboolean shrink);
void gtk_paned_pack2 ( GtkPaned *paned, GtkWidget *child,gboolean resize,gboolean shrink);
GtkWidget* gtk_paned_get_child1 ( GtkPaned *paned);
GtkWidget* gtk_paned_get_child2 ( GtkPaned *paned);
void gtk_paned_set_position ( GtkPaned *paned,gint position);
gint gtk_paned_get_position ( GtkPaned *paned);
GtkAdjustment* gtk_range_get_adjustment ( GtkRange *range);
void gtk_range_set_update_policy ( GtkRange *range, GtkUpdateType policy);
void gtk_range_set_adjustment ( GtkRange *range, GtkAdjustment *adjustment);
gboolean gtk_range_get_inverted ( GtkRange *range);
void gtk_range_set_inverted ( GtkRange *range,gboolean setting);
GtkUpdateType gtk_range_get_update_policy ( GtkRange *range);
gdouble gtk_range_get_value ( GtkRange *range);
void gtk_range_set_increments ( GtkRange *range,gdouble step,gdouble page);
void gtk_range_set_range ( GtkRange *range,gdouble min,gdouble max);
void gtk_range_set_value ( GtkRange *range,gdouble value);
void gtk_range_set_lower_stepper_sensitivity ( GtkRange *range, GtkSensitivityType sensitivity);
GtkSensitivityType gtk_range_get_lower_stepper_sensitivity ( GtkRange *range);
void gtk_range_set_upper_stepper_sensitivity ( GtkRange *range, GtkSensitivityType sensitivity);
GtkSensitivityType gtk_range_get_upper_stepper_sensitivity ( GtkRange *range);
void gtk_scale_set_digits ( GtkScale *scale,gint digits);
void gtk_scale_set_draw_value ( GtkScale *scale,gboolean draw_value);
void gtk_scale_set_value_pos ( GtkScale *scale, GtkPositionType pos);
gint gtk_scale_get_digits ( GtkScale *scale);
gboolean gtk_scale_get_draw_value ( GtkScale *scale);
GtkPositionType gtk_scale_get_value_pos ( GtkScale *scale);
PangoLayout* gtk_scale_get_layout ( GtkScale *scale);
void gtk_scale_get_layout_offsets ( GtkScale *scale,gint *x,gint *y);
GtkWidget* gtk_widget_new (GType type,const gchar *first_property_name,...);
GtkWidget* gtk_widget_ref ( GtkWidget *widget);
void gtk_widget_unref ( GtkWidget *widget);
void gtk_widget_destroy ( GtkWidget *widget);
void gtk_widget_destroyed ( GtkWidget *widget, GtkWidget **widget_pointer);
void gtk_widget_set ( GtkWidget *widget,const gchar *first_property_name,...);
void gtk_widget_unparent ( GtkWidget *widget);
void gtk_widget_show ( GtkWidget *widget);
void gtk_widget_show_now ( GtkWidget *widget);
void gtk_widget_hide ( GtkWidget *widget);
void gtk_widget_show_all ( GtkWidget *widget);
void gtk_widget_hide_all ( GtkWidget *widget);
void gtk_widget_map ( GtkWidget *widget);
void gtk_widget_unmap ( GtkWidget *widget);
void gtk_widget_realize ( GtkWidget *widget);
void gtk_widget_unrealize ( GtkWidget *widget);
void gtk_widget_queue_draw ( GtkWidget *widget);
void gtk_widget_queue_resize ( GtkWidget *widget);
void gtk_widget_queue_resize_no_redraw ( GtkWidget *widget);
void gtk_widget_draw ( GtkWidget *widget, GdkRectangle *area);
void gtk_widget_size_request ( GtkWidget *widget, GtkRequisition *requisition);
void gtk_widget_get_child_requisition ( GtkWidget *widget, GtkRequisition *requisition);
void gtk_widget_size_allocate ( GtkWidget *widget, GtkAllocation *allocation);
void gtk_widget_add_accelerator ( GtkWidget *widget,const gchar *accel_signal, GtkAccelGroup *accel_group,guint accel_key, GdkModifierType accel_mods, GtkAccelFlags accel_flags);
gboolean gtk_widget_remove_accelerator ( GtkWidget *widget, GtkAccelGroup *accel_group,guint accel_key, GdkModifierType accel_mods);
void gtk_widget_set_accel_path ( GtkWidget *widget,const gchar *accel_path, GtkAccelGroup *accel_group);
GList* gtk_widget_list_accel_closures ( GtkWidget *widget);
gboolean gtk_widget_can_activate_accel ( GtkWidget *widget,guint signal_id);
gboolean gtk_widget_event ( GtkWidget *widget, GdkEvent *event);
gboolean gtk_widget_activate ( GtkWidget *widget);
void gtk_widget_reparent ( GtkWidget *widget, GtkWidget *new_parent);
gboolean gtk_widget_intersect ( GtkWidget *widget, GdkRectangle *area, GdkRectangle *intersection);
gboolean gtk_widget_is_focus ( GtkWidget *widget);
void gtk_widget_grab_focus ( GtkWidget *widget);
void gtk_widget_grab_default ( GtkWidget *widget);
void gtk_widget_set_name ( GtkWidget *widget,const gchar *name);
const gchar* gtk_widget_get_name ( GtkWidget *widget);
void gtk_widget_set_state ( GtkWidget *widget, GtkStateType state);
void gtk_widget_set_sensitive ( GtkWidget *widget,gboolean sensitive);
void gtk_widget_set_parent ( GtkWidget *widget, GtkWidget *parent);
void gtk_widget_set_parent_window ( GtkWidget *widget, GdkWindow *parent_window);
GdkWindow* gtk_widget_get_parent_window ( GtkWidget *widget);
GdkWindow* gtk_widget_get_parent_window ( GtkWidget *widget);
void gtk_widget_set_uposition ( GtkWidget *widget,gint x,gint y);
void gtk_widget_set_usize ( GtkWidget *widget,gint width,gint height);
void gtk_widget_set_events ( GtkWidget *widget,gint events);
void gtk_widget_add_events ( GtkWidget *widget,gint events);
void gtk_widget_set_extension_events ( GtkWidget *widget, GdkExtensionMode mode);
GdkExtensionMode gtk_widget_get_extension_events ( GtkWidget *widget);
GdkExtensionMode gtk_widget_get_extension_events ( GtkWidget *widget);
GtkWidget* gtk_widget_get_toplevel ( GtkWidget *widget);
GtkWidget* gtk_widget_get_ancestor ( GtkWidget *widget,GType widget_type);
GdkColormap* gtk_widget_get_colormap ( GtkWidget *widget);
GdkColormap* gtk_widget_get_colormap ( GtkWidget *widget);
void gtk_widget_set_colormap ( GtkWidget *widget, GdkColormap *colormap);
GdkVisual* gtk_widget_get_visual ( GtkWidget *widget);
GdkVisual* gtk_widget_get_visual ( GtkWidget *widget);
gint gtk_widget_get_events ( GtkWidget *widget);
void gtk_widget_get_pointer ( GtkWidget *widget,gint *x,gint *y);
gboolean gtk_widget_is_ancestor ( GtkWidget *widget, GtkWidget *ancestor);
gboolean gtk_widget_translate_coordinates ( GtkWidget *src_widget, GtkWidget *dest_widget,gint src_x,gint src_y,gint *dest_x,gint *dest_y);
gboolean gtk_widget_hide_on_delete ( GtkWidget *widget);
void gtk_widget_set_style ( GtkWidget *widget, GtkStyle *style);
void gtk_widget_ensure_style ( GtkWidget *widget);
GtkStyle* gtk_widget_get_style ( GtkWidget *widget);
void gtk_widget_reset_rc_styles ( GtkWidget *widget);
void gtk_widget_push_colormap ( GdkColormap *cmap);
void gtk_widget_pop_colormap (void);
void gtk_widget_set_default_colormap ( GdkColormap *colormap);
GtkStyle* gtk_widget_get_default_style (void);
GdkColormap* gtk_widget_get_default_colormap (void);
GdkColormap* gtk_widget_get_default_colormap (void);
GdkVisual* gtk_widget_get_default_visual (void);
GdkVisual* gtk_widget_get_default_visual (void);
void gtk_widget_set_direction ( GtkWidget *widget, GtkTextDirection dir);
GtkTextDirection gtk_widget_get_direction ( GtkWidget *widget);
void gtk_widget_set_default_direction ( GtkTextDirection dir);
GtkTextDirection gtk_widget_get_default_direction (void);
void gtk_widget_shape_combine_mask ( GtkWidget *widget, GdkBitmap *shape_mask,gint offset_x,gint offset_y);
void gtk_widget_input_shape_combine_mask ( GtkWidget *widget, GdkBitmap *shape_mask,gint offset_x,gint offset_y);
void gtk_widget_path ( GtkWidget *widget,guint *path_length,gchar **path,gchar **path_reversed);
void gtk_widget_class_path ( GtkWidget *widget,guint *path_length,gchar **path,gchar **path_reversed);
gchar* gtk_widget_get_composite_name ( GtkWidget *widget);
void gtk_widget_modify_style ( GtkWidget *widget, GtkRcStyle *style);
GtkRcStyle* gtk_widget_get_modifier_style ( GtkWidget *widget);
void gtk_widget_modify_fg ( GtkWidget *widget, GtkStateType state,const GdkColor *color);
void gtk_widget_modify_bg ( GtkWidget *widget, GtkStateType state,const GdkColor *color);
void gtk_widget_modify_text ( GtkWidget *widget, GtkStateType state,const GdkColor *color);
void gtk_widget_modify_base ( GtkWidget *widget, GtkStateType state,const GdkColor *color);
void gtk_widget_modify_font ( GtkWidget *widget,PangoFontDescription *font_desc);
PangoContext* gtk_widget_create_pango_context ( GtkWidget *widget);
PangoContext* gtk_widget_get_pango_context ( GtkWidget *widget);
PangoLayout* gtk_widget_create_pango_layout ( GtkWidget *widget,const gchar *text);
GdkPixbuf* gtk_widget_render_icon ( GtkWidget *widget,const gchar *stock_id, GtkIconSize size,const gchar *detail);
GdkPixbuf* gtk_widget_render_icon ( GtkWidget *widget,const gchar *stock_id, GtkIconSize size,const gchar *detail);
void gtk_widget_pop_composite_child (void);
void gtk_widget_push_composite_child (void);
void gtk_widget_queue_clear ( GtkWidget *widget);
void gtk_widget_queue_clear_area ( GtkWidget *widget,gint x,gint y,gint width,gint height);
void gtk_widget_queue_draw_area ( GtkWidget *widget,gint x,gint y,gint width,gint height);
void gtk_widget_reset_shapes ( GtkWidget *widget);
void gtk_widget_set_app_paintable ( GtkWidget *widget,gboolean app_paintable);
void gtk_widget_set_double_buffered ( GtkWidget *widget,gboolean double_buffered);
void gtk_widget_set_redraw_on_allocate ( GtkWidget *widget,gboolean redraw_on_allocate);
void gtk_widget_set_composite_name ( GtkWidget *widget,const gchar *name);
gboolean gtk_widget_set_scroll_adjustments ( GtkWidget *widget, GtkAdjustment *hadjustment, GtkAdjustment *vadjustment);
gboolean gtk_widget_mnemonic_activate ( GtkWidget *widget,gboolean group_cycling);
void gtk_widget_class_install_style_property ( GtkWidgetClass *klass,GParamSpec *pspec);
void gtk_widget_class_install_style_property_parser ( GtkWidgetClass *klass,GParamSpec *pspec, GtkRcPropertyParser parser);
GParamSpec* gtk_widget_class_find_style_property ( GtkWidgetClass *klass,const gchar *property_name);
GParamSpec** gtk_widget_class_list_style_properties ( GtkWidgetClass *klass,guint *n_properties);
GdkRegion* gtk_widget_region_intersect ( GtkWidget *widget, GdkRegion *region);
GdkRegion* gtk_widget_region_intersect ( GtkWidget *widget, GdkRegion *region);
gint gtk_widget_send_expose ( GtkWidget *widget, GdkEvent *event);
void gtk_widget_style_get ( GtkWidget *widget,const gchar *first_property_name,...);
void gtk_widget_style_get_property ( GtkWidget *widget,const gchar *property_name,GValue *value);
void gtk_widget_style_get_valist ( GtkWidget *widget,const gchar *first_property_name,va_list var_args);
AtkObject* gtk_widget_get_accessible ( GtkWidget *widget);
gboolean gtk_widget_child_focus ( GtkWidget *widget, GtkDirectionType direction);
void gtk_widget_child_notify ( GtkWidget *widget,const gchar *child_property);
void gtk_widget_freeze_child_notify ( GtkWidget *widget);
gboolean gtk_widget_get_child_visible ( GtkWidget *widget);
GtkWidget* gtk_widget_get_parent ( GtkWidget *widget);
GtkSettings* gtk_widget_get_settings ( GtkWidget *widget);
GtkClipboard* gtk_widget_get_clipboard ( GtkWidget *widget, GdkAtom selection);
GdkDisplay* gtk_widget_get_display ( GtkWidget *widget);
GdkDisplay* gtk_widget_get_display ( GtkWidget *widget);
GdkWindow* gtk_widget_get_root_window ( GtkWidget *widget);
GdkWindow* gtk_widget_get_root_window ( GtkWidget *widget);
GdkScreen* gtk_widget_get_screen ( GtkWidget *widget);
GdkScreen* gtk_widget_get_screen ( GtkWidget *widget);
gboolean gtk_widget_has_screen ( GtkWidget *widget);
void gtk_widget_get_size_request ( GtkWidget *widget,gint *width,gint *height);
void gtk_widget_set_child_visible ( GtkWidget *widget,gboolean is_visible);
void gtk_widget_set_size_request ( GtkWidget *widget,gint width,gint height);
void gtk_widget_thaw_child_notify ( GtkWidget *widget);
void gtk_widget_set_no_show_all ( GtkWidget *widget,gboolean no_show_all);
gboolean gtk_widget_get_no_show_all ( GtkWidget *widget);
GList* gtk_widget_list_mnemonic_labels ( GtkWidget *widget);
void gtk_widget_add_mnemonic_label ( GtkWidget *widget, GtkWidget *label);
void gtk_widget_remove_mnemonic_label ( GtkWidget *widget, GtkWidget *label);
GtkAction* gtk_widget_get_action ( GtkWidget *widget);
gboolean gtk_widget_is_composited ( GtkWidget *widget);
GtkRequisition* gtk_requisition_copy (const GtkRequisition *requisition);
void gtk_requisition_free ( GtkRequisition *requisition);
void gtk_im_context_set_client_window ( GtkIMContext *context, GdkWindow *window);
void gtk_im_context_get_preedit_string ( GtkIMContext *context,gchar **str,PangoAttrList **attrs,gint *cursor_pos);
gboolean gtk_im_context_filter_keypress ( GtkIMContext *context, GdkEventKey *event);
void gtk_im_context_focus_in ( GtkIMContext *context);
void gtk_im_context_focus_out ( GtkIMContext *context);
void gtk_im_context_reset ( GtkIMContext *context);
void gtk_im_context_set_cursor_location ( GtkIMContext *context, GdkRectangle *area);
void gtk_im_context_set_use_preedit ( GtkIMContext *context,gboolean use_preedit);
void gtk_im_context_set_surrounding ( GtkIMContext *context,const gchar *text,gint len,gint cursor_index);
gboolean gtk_im_context_get_surrounding ( GtkIMContext *context,gchar **text,gint *cursor_index);
gboolean gtk_im_context_delete_surrounding ( GtkIMContext *context,gint offset,gint n_chars);
GtkWidget* gtk_clist_new (gint columns);
GtkWidget* gtk_clist_new_with_titles (gint columns,gchar *titles[]);
void gtk_clist_set_shadow_type ( GtkCList *clist, GtkShadowType type);
void gtk_clist_set_selection_mode ( GtkCList *clist, GtkSelectionMode mode);
void gtk_clist_freeze ( GtkCList *clist);
void gtk_clist_thaw ( GtkCList *clist);
void gtk_clist_column_titles_show ( GtkCList *clist);
void gtk_clist_column_titles_hide ( GtkCList *clist);
void gtk_clist_column_title_active ( GtkCList *clist,gint column);
void gtk_clist_column_title_passive ( GtkCList *clist,gint column);
void gtk_clist_column_titles_active ( GtkCList *clist);
void gtk_clist_column_titles_passive ( GtkCList *clist);
void gtk_clist_set_column_title ( GtkCList *clist,gint column,const gchar *title);
void gtk_clist_set_column_widget ( GtkCList *clist,gint column, GtkWidget *widget);
void gtk_clist_set_column_justification ( GtkCList *clist,gint column, GtkJustification justification);
void gtk_clist_set_column_visibility ( GtkCList *clist,gint column,gboolean visible);
void gtk_clist_set_column_resizeable ( GtkCList *clist,gint column,gboolean resizeable);
void gtk_clist_set_column_auto_resize ( GtkCList *clist,gint column,gboolean auto_resize);
gint gtk_clist_optimal_column_width ( GtkCList *clist,gint column);
void gtk_clist_set_column_width ( GtkCList *clist,gint column,gint width);
void gtk_clist_set_column_min_width ( GtkCList *clist,gint column,gint min_width);
void gtk_clist_set_column_max_width ( GtkCList *clist,gint column,gint max_width);
void gtk_clist_set_row_height ( GtkCList *clist,guint height);
void gtk_clist_moveto ( GtkCList *clist,gint row,gint column,gfloat row_align,gfloat col_align);
GtkVisibility gtk_clist_row_is_visible ( GtkCList *clist,gint row);
GtkCellType gtk_clist_get_cell_type ( GtkCList *clist,gint row,gint column);
void gtk_clist_set_text ( GtkCList *clist,gint row,gint column,const gchar *text);
gint gtk_clist_get_text ( GtkCList *clist,gint row,gint column,gchar **text);
void gtk_clist_set_pixmap ( GtkCList *clist,gint row,gint column, GdkPixmap *pixmap, GdkBitmap *mask);
gint gtk_clist_get_pixmap ( GtkCList *clist,gint row,gint column, GdkPixmap **pixmap, GdkBitmap **mask);
void gtk_clist_set_pixtext ( GtkCList *clist,gint row,gint column,const gchar *text,guint8 spacing, GdkPixmap *pixmap, GdkBitmap *mask);
gint gtk_clist_get_pixtext ( GtkCList *clist,gint row,gint column,gchar **text,guint8 *spacing, GdkPixmap **pixmap, GdkBitmap **mask);
void gtk_clist_set_foreground ( GtkCList *clist,gint row,const GdkColor *color);
void gtk_clist_set_background ( GtkCList *clist,gint row,const GdkColor *color);
void gtk_clist_set_cell_style ( GtkCList *clist,gint row,gint column, GtkStyle *style);
GtkStyle* gtk_clist_get_cell_style ( GtkCList *clist,gint row,gint column);
void gtk_clist_set_row_style ( GtkCList *clist,gint row, GtkStyle *style);
GtkStyle* gtk_clist_get_row_style ( GtkCList *clist,gint row);
void gtk_clist_set_shift ( GtkCList *clist,gint row,gint column,gint vertical,gint horizontal);
void gtk_clist_set_selectable ( GtkCList *clist,gint row,gboolean selectable);
gboolean gtk_clist_get_selectable ( GtkCList *clist,gint row);
gint gtk_clist_prepend ( GtkCList *clist,gchar *text[]);
gint gtk_clist_append ( GtkCList *clist,gchar *text[]);
gint gtk_clist_insert ( GtkCList *clist,gint row,gchar *text[]);
void gtk_clist_remove ( GtkCList *clist,gint row);
void gtk_clist_set_row_data ( GtkCList *clist,gint row,gpointer data);
void gtk_clist_set_row_data_full ( GtkCList *clist,gint row,gpointer data, GtkDestroyNotify destroy);
gpointer gtk_clist_get_row_data ( GtkCList *clist,gint row);
gint gtk_clist_find_row_from_data ( GtkCList *clist,gpointer data);
void gtk_clist_select_row ( GtkCList *clist,gint row,gint column);
void gtk_clist_unselect_row ( GtkCList *clist,gint row,gint column);
void gtk_clist_undo_selection ( GtkCList *clist);
void gtk_clist_clear ( GtkCList *clist);
gint gtk_clist_get_selection_info ( GtkCList *clist,gint x,gint y,gint *row,gint *column);
void gtk_clist_select_all ( GtkCList *clist);
void gtk_clist_unselect_all ( GtkCList *clist);
void gtk_clist_swap_rows ( GtkCList *clist,gint row1,gint row2);
void gtk_clist_set_compare_func ( GtkCList *clist, GtkCListCompareFunc cmp_func);
void gtk_clist_set_sort_column ( GtkCList *clist,gint column);
void gtk_clist_set_sort_type ( GtkCList *clist, GtkSortType sort_type);
void gtk_clist_sort ( GtkCList *clist);
void gtk_clist_set_auto_sort ( GtkCList *clist,gboolean auto_sort);
gint gtk_clist_columns_autosize ( GtkCList *clist);
gchar* gtk_clist_get_column_title ( GtkCList *clist,gint column);
GtkWidget* gtk_clist_get_column_widget ( GtkCList *clist,gint column);
GtkAdjustment* gtk_clist_get_hadjustment ( GtkCList *clist);
GtkAdjustment* gtk_clist_get_vadjustment ( GtkCList *clist);
void gtk_clist_row_move ( GtkCList *clist,gint source_row,gint dest_row);
void gtk_clist_set_button_actions ( GtkCList *clist,guint button,guint8 button_actions);
void gtk_clist_set_hadjustment ( GtkCList *clist, GtkAdjustment *adjustment);
void gtk_clist_set_reorderable ( GtkCList *clist,gboolean reorderable);
void gtk_clist_set_use_drag_icons ( GtkCList *clist,gboolean use_icons);
void gtk_clist_set_vadjustment ( GtkCList *clist, GtkAdjustment *adjustment);
GtkWidget* gtk_pixmap_new ( GdkPixmap *pixmap, GdkBitmap *mask);
void gtk_pixmap_set ( GtkPixmap *pixmap, GdkPixmap *val, GdkBitmap *mask);
void gtk_pixmap_get ( GtkPixmap *pixmap, GdkPixmap **val, GdkBitmap **mask);
void gtk_pixmap_set_build_insensitive ( GtkPixmap *pixmap,gboolean build);
void gtk_plug_construct ( GtkPlug *plug, GdkNativeWindow socket_id);
void gtk_plug_construct_for_display ( GtkPlug *plug, GdkDisplay *display, GdkNativeWindow socket_id);
GtkWidget* gtk_plug_new ( GdkNativeWindow socket_id);
GtkWidget* gtk_plug_new_for_display ( GdkDisplay *display, GdkNativeWindow socket_id);
GdkNativeWindow gtk_plug_get_id ( GtkPlug *plug);
GdkNativeWindow gtk_plug_get_id ( GtkPlug *plug);
GtkWidget* gtk_socket_new (void);
void gtk_socket_steal ( GtkSocket *socket_, GdkNativeWindow wid);
void gtk_socket_add_id ( GtkSocket *socket_, GdkNativeWindow window_id);
GdkNativeWindow gtk_socket_get_id ( GtkSocket *socket_);
GdkNativeWindow gtk_socket_get_id ( GtkSocket *socket_);
GtkWidget* gtk_curve_new (void);
void gtk_curve_reset ( GtkCurve *curve);
void gtk_curve_set_gamma ( GtkCurve *curve,gfloat gamma_);
void gtk_curve_set_range ( GtkCurve *curve,gfloat min_x,gfloat max_x,gfloat min_y,gfloat max_y);
void gtk_curve_set_curve_type ( GtkCurve *curve, GtkCurveType type);
GtkWidget* gtk_gamma_curve_new (void);
void gtk_ruler_set_metric ( GtkRuler *ruler, GtkMetricType metric);
void gtk_ruler_set_range ( GtkRuler *ruler,gdouble lower,gdouble upper,gdouble position,gdouble max_size);
GtkMetricType gtk_ruler_get_metric ( GtkRuler *ruler);
void gtk_ruler_get_range ( GtkRuler *ruler,gdouble *lower,gdouble *upper,gdouble *position,gdouble *max_size);
GtkWidget* gtk_hruler_new (void);
GtkWidget* gtk_vruler_new (void);
GtkRecentManager* gtk_recent_manager_new (void);
GtkRecentManager* gtk_recent_manager_get_default (void);
GtkRecentManager* gtk_recent_manager_get_for_screen ( GdkScreen *screen);
void gtk_recent_manager_set_screen ( GtkRecentManager *manager, GdkScreen *screen);
gboolean gtk_recent_manager_add_item ( GtkRecentManager *manager,const gchar *uri);
gboolean gtk_recent_manager_add_full ( GtkRecentManager *manager,const gchar *uri,const GtkRecentData *recent_data);
gboolean gtk_recent_manager_remove_item ( GtkRecentManager *manager,const gchar *uri,GError **error);
GtkRecentInfo* gtk_recent_manager_lookup_item ( GtkRecentManager *manager,const gchar *uri,GError **error);
gboolean gtk_recent_manager_has_item ( GtkRecentManager *manager,const gchar *uri);
gboolean gtk_recent_manager_move_item ( GtkRecentManager *manager,const gchar *uri,const gchar *new_uri,GError **error);
gint gtk_recent_manager_get_limit ( GtkRecentManager *manager);
void gtk_recent_manager_set_limit ( GtkRecentManager *manager,gint limit);
GList* gtk_recent_manager_get_items ( GtkRecentManager *manager);
gint gtk_recent_manager_purge_items ( GtkRecentManager *manager,GError **error);
GtkRecentInfo* gtk_recent_info_ref ( GtkRecentInfo *info);
void gtk_recent_info_unref ( GtkRecentInfo *info);
const gchar* gtk_recent_info_get_uri ( GtkRecentInfo *info);
const gchar* gtk_recent_info_get_display_name ( GtkRecentInfo *info);
const gchar* gtk_recent_info_get_description ( GtkRecentInfo *info);
const gchar* gtk_recent_info_get_mime_type ( GtkRecentInfo *info);
time_t gtk_recent_info_get_added ( GtkRecentInfo *info);
time_t gtk_recent_info_get_modified ( GtkRecentInfo *info);
time_t gtk_recent_info_get_visited ( GtkRecentInfo *info);
gboolean gtk_recent_info_get_private_hint ( GtkRecentInfo *info);
gboolean gtk_recent_info_get_application_info ( GtkRecentInfo *info,const gchar *app_name,gchar **app_exec,guint *count,time_t *time_);
gchar** gtk_recent_info_get_applications ( GtkRecentInfo *info,gsize *length);
gchar* gtk_recent_info_last_application ( GtkRecentInfo *info);
gchar** gtk_recent_info_get_groups ( GtkRecentInfo *info,gsize *length);
gboolean gtk_recent_info_has_group ( GtkRecentInfo *info,const gchar *group_name);
gboolean gtk_recent_info_has_application ( GtkRecentInfo *info,const gchar *app_name);
GdkPixbuf* gtk_recent_info_get_icon ( GtkRecentInfo *info,gint size);
GdkPixbuf* gtk_recent_info_get_icon ( GtkRecentInfo *info,gint size);
gchar* gtk_recent_info_get_short_name ( GtkRecentInfo *info);
gchar* gtk_recent_info_get_uri_display ( GtkRecentInfo *info);
gint gtk_recent_info_get_age ( GtkRecentInfo *info);
gboolean gtk_recent_info_is_local ( GtkRecentInfo *info);
gboolean gtk_recent_info_exists ( GtkRecentInfo *info);
gboolean gtk_recent_info_match ( GtkRecentInfo *info_a, GtkRecentInfo *info_b);
void gtk_recent_chooser_set_show_private ( GtkRecentChooser *chooser,gboolean show_private);
gboolean gtk_recent_chooser_get_show_private ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_show_not_found ( GtkRecentChooser *chooser,gboolean show_not_found);
gboolean gtk_recent_chooser_get_show_not_found ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_show_icons ( GtkRecentChooser *chooser,gboolean show_icons);
gboolean gtk_recent_chooser_get_show_icons ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_select_multiple ( GtkRecentChooser *chooser,gboolean select_multiple);
gboolean gtk_recent_chooser_get_select_multiple ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_local_only ( GtkRecentChooser *chooser,gboolean local_only);
gboolean gtk_recent_chooser_get_local_only ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_limit ( GtkRecentChooser *chooser,gint limit);
gint gtk_recent_chooser_get_limit ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_show_tips ( GtkRecentChooser *chooser,gboolean show_tips);
gboolean gtk_recent_chooser_get_show_tips ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_show_numbers ( GtkRecentChooser *chooser,gboolean show_numbers);
gboolean gtk_recent_chooser_get_show_numbers ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_sort_type ( GtkRecentChooser *chooser, GtkRecentSortType sort_type);
GtkRecentSortType gtk_recent_chooser_get_sort_type ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_sort_func ( GtkRecentChooser *chooser, GtkRecentSortFunc sort_func,gpointer sort_data,GDestroyNotify data_destroy);
gboolean gtk_recent_chooser_set_current_uri ( GtkRecentChooser *chooser,const gchar *uri,GError **error);
gchar* gtk_recent_chooser_get_current_uri ( GtkRecentChooser *chooser);
GtkRecentInfo* gtk_recent_chooser_get_current_item ( GtkRecentChooser *chooser);
gboolean gtk_recent_chooser_select_uri ( GtkRecentChooser *chooser,const gchar *uri,GError **error);
void gtk_recent_chooser_unselect_uri ( GtkRecentChooser *chooser,const gchar *uri);
void gtk_recent_chooser_select_all ( GtkRecentChooser *chooser);
void gtk_recent_chooser_unselect_all ( GtkRecentChooser *chooser);
GList* gtk_recent_chooser_get_items ( GtkRecentChooser *chooser);
gchar** gtk_recent_chooser_get_uris ( GtkRecentChooser *chooser,gsize *length);
void gtk_recent_chooser_add_filter ( GtkRecentChooser *chooser, GtkRecentFilter *filter);
void gtk_recent_chooser_remove_filter ( GtkRecentChooser *chooser, GtkRecentFilter *filter);
GSList* gtk_recent_chooser_list_filters ( GtkRecentChooser *chooser);
void gtk_recent_chooser_set_filter ( GtkRecentChooser *chooser, GtkRecentFilter *filter);
GtkRecentFilter* gtk_recent_chooser_get_filter ( GtkRecentChooser *chooser);
GtkWidget* gtk_recent_chooser_dialog_new (const gchar *title, GtkWindow *parent,const gchar *first_button_text,...);
GtkWidget* gtk_recent_chooser_dialog_new_for_manager (const gchar *title, GtkWindow *parent, GtkRecentManager *manager,const gchar *first_button_text,...);
GtkWidget* gtk_recent_chooser_menu_new (void);
GtkWidget* gtk_recent_chooser_menu_new_for_manager ( GtkRecentManager *manager);
gboolean gtk_recent_chooser_menu_get_show_numbers ( GtkRecentChooserMenu *menu);
void gtk_recent_chooser_menu_set_show_numbers ( GtkRecentChooserMenu *menu,gboolean show_numbers);
GtkWidget* gtk_recent_chooser_widget_new (void);
GtkWidget* gtk_recent_chooser_widget_new_for_manager ( GtkRecentManager *manager);
GtkRecentFilter* gtk_recent_filter_new (void);
const gchar* gtk_recent_filter_get_name ( GtkRecentFilter *filter);
void gtk_recent_filter_set_name ( GtkRecentFilter *filter,const gchar *name);
void gtk_recent_filter_add_mime_type ( GtkRecentFilter *filter,const gchar *mime_type);
void gtk_recent_filter_add_pattern ( GtkRecentFilter *filter,const gchar *pattern);
void gtk_recent_filter_add_pixbuf_formats ( GtkRecentFilter *filter);
void gtk_recent_filter_add_application ( GtkRecentFilter *filter,const gchar *application);
void gtk_recent_filter_add_group ( GtkRecentFilter *filter,const gchar *group);
void gtk_recent_filter_add_age ( GtkRecentFilter *filter,gint days);
void gtk_recent_filter_add_custom ( GtkRecentFilter *filter, GtkRecentFilterFlags needed, GtkRecentFilterFunc func,gpointer data,GDestroyNotify data_destroy);
GtkRecentFilterFlags gtk_recent_filter_get_needed ( GtkRecentFilter *filter);
gboolean gtk_recent_filter_filter ( GtkRecentFilter *filter,const GtkRecentFilterInfo *filter_info);
void gdk_init (gint *argc,gchar ***argv);
gboolean gdk_init_check (gint *argc,gchar ***argv);
void gdk_parse_args (gint *argc,gchar ***argv);
const gchar* gdk_get_display_arg_name (void);
gchar* gdk_set_locale (void);
void gdk_set_sm_client_id (const gchar *sm_client_id);
void gdk_exit (gint error_code);
void gdk_notify_startup_complete (void);
const char* gdk_get_program_class (void);
void gdk_set_program_class (const char *program_class);
gchar* gdk_get_display (void);
void gdk_flush (void);
gint gdk_screen_width (void);
gint gdk_screen_height (void);
gint gdk_screen_width_mm (void);
gint gdk_screen_height_mm (void);
GdkGrabStatus gdk_pointer_grab ( GdkWindow *window,gboolean owner_events, GdkEventMask event_mask, GdkWindow *confine_to, GdkCursor *cursor,guint32 time_);
void gdk_pointer_ungrab (guint32 time_);
gboolean gdk_pointer_is_grabbed (void);
void gdk_set_double_click_time (guint msec);
GdkGrabStatus gdk_keyboard_grab ( GdkWindow *window,gboolean owner_events,guint32 time_);
void gdk_keyboard_ungrab (guint32 time_);
void gdk_beep (void);
gboolean gdk_get_use_xshm (void);
void gdk_set_use_xshm (gboolean use_xshm);
void gdk_error_trap_push (void);
gint gdk_error_trap_pop (void);
GdkDisplay* gdk_display_open (const gchar *display_name);
GdkDisplay* gdk_display_get_default (void);
const gchar* gdk_display_get_name ( GdkDisplay *display);
gint gdk_display_get_n_screens ( GdkDisplay *display);
GdkScreen* gdk_display_get_screen ( GdkDisplay *display,gint screen_num);
GdkScreen* gdk_display_get_default_screen ( GdkDisplay *display);
void gdk_display_pointer_ungrab ( GdkDisplay *display,guint32 time_);
void gdk_display_keyboard_ungrab ( GdkDisplay *display,guint32 time_);
gboolean gdk_display_pointer_is_grabbed ( GdkDisplay *display);
void gdk_display_beep ( GdkDisplay *display);
void gdk_display_sync ( GdkDisplay *display);
void gdk_display_flush ( GdkDisplay *display);
void gdk_display_close ( GdkDisplay *display);
GList* gdk_display_list_devices ( GdkDisplay *display);
GdkEvent* gdk_display_get_event ( GdkDisplay *display);
GdkEvent* gdk_display_peek_event ( GdkDisplay *display);
void gdk_display_put_event ( GdkDisplay *display, GdkEvent *event);
void gdk_display_add_client_message_filter ( GdkDisplay *display, GdkAtom message_type, GdkFilterFunc func,gpointer data);
void gdk_display_set_double_click_time ( GdkDisplay *display,guint msec);
void gdk_display_set_double_click_distance ( GdkDisplay *display,guint distance);
void gdk_display_get_pointer ( GdkDisplay *display, GdkScreen **screen,gint *x,gint *y, GdkModifierType *mask);
GdkWindow* gdk_display_get_window_at_pointer ( GdkDisplay *display,gint *win_x,gint *win_y); GdkDisplayPointerHooks ;
GdkDisplayPointerHooks* gdk_display_set_pointer_hooks ( GdkDisplay *display,const GdkDisplayPointerHooks *new_hooks);
void gdk_display_warp_pointer ( GdkDisplay *display, GdkScreen *screen,gint x,gint y);
gboolean gdk_display_supports_cursor_color ( GdkDisplay *display);
gboolean gdk_display_supports_cursor_alpha ( GdkDisplay *display);
guint gdk_display_get_default_cursor_size ( GdkDisplay *display);
void gdk_display_get_maximal_cursor_size ( GdkDisplay *display,guint *width,guint *height);
GdkWindow* gdk_display_get_default_group ( GdkDisplay *display);
gboolean gdk_display_supports_selection_notification ( GdkDisplay *display);
gboolean gdk_display_request_selection_notification ( GdkDisplay *display, GdkAtom selection);
gboolean gdk_display_supports_clipboard_persistence ( GdkDisplay *display);
void gdk_display_store_clipboard ( GdkDisplay *display, GdkWindow *clipboard_window,guint32 time_, GdkAtom *targets,gint n_targets);
gboolean gdk_display_supports_shapes ( GdkDisplay *display);
gboolean gdk_display_supports_input_shapes ( GdkDisplay *display);
GdkDisplayManager* gdk_display_manager_get (void);
GdkDisplay* gdk_display_manager_get_default_display ( GdkDisplayManager *display_manager);
void gdk_display_manager_set_default_display ( GdkDisplayManager *display_manager, GdkDisplay *display);
GSList* gdk_display_manager_list_displays ( GdkDisplayManager *display_manager);
GdkDevice* gdk_display_get_core_pointer ( GdkDisplay *display);
GdkScreen* gdk_screen_get_default (void);
GdkColormap* gdk_screen_get_default_colormap ( GdkScreen *screen);
void gdk_screen_set_default_colormap ( GdkScreen *screen, GdkColormap *colormap);
GdkColormap* gdk_screen_get_system_colormap ( GdkScreen *screen);
GdkVisual* gdk_screen_get_system_visual ( GdkScreen *screen);
GdkColormap* gdk_screen_get_rgb_colormap ( GdkScreen *screen);
GdkVisual* gdk_screen_get_rgb_visual ( GdkScreen *screen);
GdkColormap* gdk_screen_get_rgba_colormap ( GdkScreen *screen);
GdkVisual* gdk_screen_get_rgba_visual ( GdkScreen *screen);
gboolean gdk_screen_is_composited ( GdkScreen *screen);
GdkWindow* gdk_screen_get_root_window ( GdkScreen *screen);
GdkDisplay* gdk_screen_get_display ( GdkScreen *screen);
gint gdk_screen_get_number ( GdkScreen *screen);
gint gdk_screen_get_width ( GdkScreen *screen);
gint gdk_screen_get_height ( GdkScreen *screen);
gint gdk_screen_get_width_mm ( GdkScreen *screen);
gint gdk_screen_get_height_mm ( GdkScreen *screen);
GList* gdk_screen_list_visuals ( GdkScreen *screen);
GList* gdk_screen_get_toplevel_windows ( GdkScreen *screen);
gchar* gdk_screen_make_display_name ( GdkScreen *screen);
gint gdk_screen_get_n_monitors ( GdkScreen *screen);
void gdk_screen_get_monitor_geometry ( GdkScreen *screen,gint monitor_num, GdkRectangle *dest);
gint gdk_screen_get_monitor_at_point ( GdkScreen *screen,gint x,gint y);
gint gdk_screen_get_monitor_at_window ( GdkScreen *screen, GdkWindow *window);
void gdk_screen_broadcast_client_message ( GdkScreen *screen, GdkEvent *event);
gboolean gdk_screen_get_setting ( GdkScreen *screen,const gchar *name,GValue *value);
const cairo_font_options_t* gdk_screen_get_font_options ( GdkScreen *screen);
cairo_font_options_t* gdk_screen_get_font_options ( GdkScreen *screen);
void gdk_screen_set_font_options ( GdkScreen *screen,const cairo_font_options_t *options);
gdouble gdk_screen_get_resolution ( GdkScreen *screen);
void gdk_screen_set_resolution ( GdkScreen *screen,gdouble dpi);
GdkWindow* gdk_screen_get_active_window ( GdkScreen *screen);
GList* gdk_screen_get_window_stack ( GdkScreen *screen);
gboolean gdk_spawn_on_screen ( GdkScreen *screen,const gchar *working_directory,gchar **argv,gchar **envp,GSpawnFlags flags,GSpawnChildSetupFunc child_setup,gpointer user_data,gint *child_pid,GError **error);
gboolean gdk_spawn_on_screen_with_pipes ( GdkScreen *screen,const gchar *working_directory,gchar **argv,gchar **envp,GSpawnFlags flags,GSpawnChildSetupFunc child_setup,gpointer user_data,gint *child_pid,gint *standard_input,gint *standard_output,gint *standard_error,GError **error);
gboolean gdk_spawn_command_line_on_screen ( GdkScreen *screen,const gchar *command_line,GError **error);
GdkGC* gdk_gc_new ( GdkDrawable *drawable);
GdkGC* gdk_gc_new_with_values ( GdkDrawable *drawable, GdkGCValues *values, GdkGCValuesMask values_mask);
GdkScreen* gdk_gc_get_screen ( GdkGC *gc);
GdkGC* gdk_gc_ref ( GdkGC *gc);
void gdk_gc_unref ( GdkGC *gc);
void gdk_gc_set_values ( GdkGC *gc, GdkGCValues *values, GdkGCValuesMask values_mask);
void gdk_gc_get_values ( GdkGC *gc, GdkGCValues *values);
void gdk_gc_set_foreground ( GdkGC *gc,const GdkColor *color);
void gdk_gc_set_background ( GdkGC *gc,const GdkColor *color);
void gdk_gc_set_rgb_fg_color ( GdkGC *gc,const GdkColor *color);
void gdk_gc_set_rgb_bg_color ( GdkGC *gc,const GdkColor *color);
void gdk_gc_set_font ( GdkGC *gc, GdkFont *font);
void gdk_gc_set_function ( GdkGC *gc, GdkFunction function);
void gdk_gc_set_fill ( GdkGC *gc, GdkFill fill);
void gdk_gc_set_tile ( GdkGC *gc, GdkPixmap *tile);
void gdk_gc_set_stipple ( GdkGC *gc, GdkPixmap *stipple);
void gdk_gc_set_ts_origin ( GdkGC *gc,gint x,gint y);
void gdk_gc_set_clip_origin ( GdkGC *gc,gint x,gint y);
void gdk_gc_set_clip_mask ( GdkGC *gc, GdkBitmap *mask);
void gdk_gc_set_clip_rectangle ( GdkGC *gc, GdkRectangle *rectangle);
void gdk_gc_set_clip_region ( GdkGC *gc, GdkRegion *region);
void gdk_gc_set_subwindow ( GdkGC *gc, GdkSubwindowMode mode);
void gdk_gc_set_exposures ( GdkGC *gc,gboolean exposures);
void gdk_gc_set_line_attributes ( GdkGC *gc,gint line_width, GdkLineStyle line_style, GdkCapStyle cap_style, GdkJoinStyle join_style);
void gdk_gc_set_dashes ( GdkGC *gc,gint dash_offset,gint8 dash_list[],gint n);
void gdk_gc_copy ( GdkGC *dst_gc, GdkGC *src_gc);
void gdk_gc_set_colormap ( GdkGC *gc, GdkColormap *colormap);
GdkColormap* gdk_gc_get_colormap ( GdkGC *gc);
void gdk_gc_offset ( GdkGC *gc,gint x_offset,gint y_offset);
GdkDrawable* gdk_drawable_ref ( GdkDrawable *drawable);
void gdk_drawable_unref ( GdkDrawable *drawable);
void gdk_drawable_set_data ( GdkDrawable *drawable,const gchar *key,gpointer data,GDestroyNotify destroy_func);
gpointer gdk_drawable_get_data ( GdkDrawable *drawable,const gchar *key);
GdkDisplay* gdk_drawable_get_display ( GdkDrawable *drawable);
GdkScreen* gdk_drawable_get_screen ( GdkDrawable *drawable);
GdkVisual* gdk_drawable_get_visual ( GdkDrawable *drawable);
void gdk_drawable_set_colormap ( GdkDrawable *drawable, GdkColormap *colormap);
GdkColormap* gdk_drawable_get_colormap ( GdkDrawable *drawable);
gint gdk_drawable_get_depth ( GdkDrawable *drawable);
void gdk_drawable_get_size ( GdkDrawable *drawable,gint *width,gint *height);
GdkRegion* gdk_drawable_get_clip_region ( GdkDrawable *drawable);
GdkRegion* gdk_drawable_get_visible_region ( GdkDrawable *drawable);
void gdk_draw_point ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y);
void gdk_draw_points ( GdkDrawable *drawable, GdkGC *gc, GdkPoint *points,gint npoints);
void gdk_draw_line ( GdkDrawable *drawable, GdkGC *gc,gint x1_,gint y1_,gint x2_,gint y2_);
void gdk_draw_lines ( GdkDrawable *drawable, GdkGC *gc, GdkPoint *points,gint npoints);
void gdk_draw_pixbuf ( GdkDrawable *drawable, GdkGC *gc, GdkPixbuf *pixbuf,gint src_x,gint src_y,gint dest_x,gint dest_y,gint width,gint height, GdkRgbDither dither,gint x_dither,gint y_dither);
void gdk_draw_segments ( GdkDrawable *drawable, GdkGC *gc, GdkSegment *segs,gint nsegs); GdkSegment ;
void gdk_draw_rectangle ( GdkDrawable *drawable, GdkGC *gc,gboolean filled,gint x,gint y,gint width,gint height);
void gdk_draw_arc ( GdkDrawable *drawable, GdkGC *gc,gboolean filled,gint x,gint y,gint width,gint height,gint angle1,gint angle2);
void gdk_draw_polygon ( GdkDrawable *drawable, GdkGC *gc,gboolean filled, GdkPoint *points,gint npoints);
void gdk_draw_trapezoids ( GdkDrawable *drawable, GdkGC *gc, GdkTrapezoid *trapezoids,gint n_trapezoids); GdkTrapezoid ;
void gdk_draw_glyphs ( GdkDrawable *drawable, GdkGC *gc,PangoFont *font,gint x,gint y,PangoGlyphString *glyphs);
void gdk_draw_glyphs_transformed ( GdkDrawable *drawable, GdkGC *gc,PangoMatrix *matrix,PangoFont *font,gint x,gint y,PangoGlyphString *glyphs);
void gdk_draw_layout_line ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,PangoLayoutLine *line);
void gdk_draw_layout_line_with_colors ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,PangoLayoutLine *line,const GdkColor *foreground,const GdkColor *background);
void gdk_draw_layout ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,PangoLayout *layout);
void gdk_draw_layout_with_colors ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,PangoLayout *layout,const GdkColor *foreground,const GdkColor *background);
void gdk_draw_string ( GdkDrawable *drawable, GdkFont *font, GdkGC *gc,gint x,gint y,const gchar *string);
void gdk_draw_text ( GdkDrawable *drawable, GdkFont *font, GdkGC *gc,gint x,gint y,const gchar *text,gint text_length);
void gdk_draw_text_wc ( GdkDrawable *drawable, GdkFont *font, GdkGC *gc,gint x,gint y,const GdkWChar *text,gint text_length);
void gdk_draw_drawable ( GdkDrawable *drawable, GdkGC *gc, GdkDrawable *src,gint xsrc,gint ysrc,gint xdest,gint ydest,gint width,gint height);
void gdk_draw_image ( GdkDrawable *drawable, GdkGC *gc, GdkImage *image,gint xsrc,gint ysrc,gint xdest,gint ydest,gint width,gint height);
GdkImage* gdk_drawable_get_image ( GdkDrawable *drawable,gint x,gint y,gint width,gint height);
GdkImage* gdk_drawable_copy_to_image ( GdkDrawable *drawable, GdkImage *image,gint src_x,gint src_y,gint dest_x,gint dest_y,gint width,gint height);
GdkPixmap* gdk_pixmap_new ( GdkDrawable *drawable,gint width,gint height,gint depth);
GdkBitmap* gdk_bitmap_create_from_data ( GdkDrawable *drawable,const gchar *data,gint width,gint height);
GdkPixmap* gdk_pixmap_create_from_data ( GdkDrawable *drawable,const gchar *data,gint width,gint height,gint depth,const GdkColor *fg,const GdkColor *bg);
GdkPixmap* gdk_pixmap_create_from_xpm ( GdkDrawable *drawable, GdkBitmap **mask,const GdkColor *transparent_color,const gchar *filename);
GdkPixmap* gdk_pixmap_colormap_create_from_xpm ( GdkDrawable *drawable, GdkColormap *colormap, GdkBitmap **mask,const GdkColor *transparent_color,const gchar *filename);
GdkPixmap* gdk_pixmap_create_from_xpm_d ( GdkDrawable *drawable, GdkBitmap **mask,const GdkColor *transparent_color,gchar **data);
GdkPixmap* gdk_pixmap_colormap_create_from_xpm_d ( GdkDrawable *drawable, GdkColormap *colormap, GdkBitmap **mask,const GdkColor *transparent_color,gchar **data);
void gdk_rgb_init (void);
void gdk_draw_rgb_image ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,gint width,gint height, GdkRgbDither dith,guchar *rgb_buf,gint rowstride);
void gdk_draw_rgb_image_dithalign ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,gint width,gint height, GdkRgbDither dith,guchar *rgb_buf,gint rowstride,gint xdith,gint ydith);
void gdk_draw_indexed_image ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,gint width,gint height, GdkRgbDither dith,guchar *buf,gint rowstride, GdkRgbCmap *cmap);
void gdk_draw_gray_image ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,gint width,gint height, GdkRgbDither dith,guchar *buf,gint rowstride);
void gdk_draw_rgb_32_image ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,gint width,gint height, GdkRgbDither dith,guchar *buf,gint rowstride);
void gdk_draw_rgb_32_image_dithalign ( GdkDrawable *drawable, GdkGC *gc,gint x,gint y,gint width,gint height, GdkRgbDither dith,guchar *buf,gint rowstride,gint xdith,gint ydith);
GdkRgbCmap* gdk_rgb_cmap_new (guint32 *colors,gint n_colors);
void gdk_rgb_cmap_free ( GdkRgbCmap *cmap); GdkRgbCmap ;
void gdk_rgb_gc_set_foreground ( GdkGC *gc,guint32 rgb);
void gdk_rgb_gc_set_background ( GdkGC *gc,guint32 rgb);
gulong gdk_rgb_xpixel_from_rgb (guint32 rgb);
void gdk_rgb_find_color ( GdkColormap *colormap, GdkColor *color);
void gdk_rgb_set_install (gboolean install);
void gdk_rgb_set_min_colors (gint min_colors);
GdkVisual* gdk_rgb_get_visual (void);
GdkColormap* gdk_rgb_get_colormap (void);
gboolean gdk_rgb_ditherable (void);
gboolean gdk_rgb_colormap_ditherable ( GdkColormap *cmap);
void gdk_rgb_set_verbose (gboolean verbose);
GdkImage* gdk_image_new ( GdkImageType type, GdkVisual *visual,gint width,gint height);
GdkImage* gdk_image_new_bitmap ( GdkVisual *visual,gpointer data,gint width,gint height);
GdkImage* gdk_image_get ( GdkDrawable *drawable,gint x,gint y,gint width,gint height);
GdkImage* gdk_image_ref ( GdkImage *image);
void gdk_image_unref ( GdkImage *image);
GdkColormap* gdk_image_get_colormap ( GdkImage *image);
void gdk_image_set_colormap ( GdkImage *image, GdkColormap *colormap);
void gdk_image_put_pixel ( GdkImage *image,gint x,gint y,guint32 pixel);
guint32 gdk_image_get_pixel ( GdkImage *image,gint x,gint y);
void gdk_pixbuf_render_threshold_alpha ( GdkPixbuf *pixbuf, GdkBitmap *bitmap,int src_x,int src_y,int dest_x,int dest_y,int width,int height,int alpha_threshold);
void gdk_pixbuf_render_to_drawable ( GdkPixbuf *pixbuf, GdkDrawable *drawable, GdkGC *gc,int src_x,int src_y,int dest_x,int dest_y,int width,int height, GdkRgbDither dither,int x_dither,int y_dither);
void gdk_pixbuf_render_to_drawable_alpha ( GdkPixbuf *pixbuf, GdkDrawable *drawable,int src_x,int src_y,int dest_x,int dest_y,int width,int height, GdkPixbufAlphaMode alpha_mode,int alpha_threshold, GdkRgbDither dither,int x_dither,int y_dither);
void gdk_pixbuf_render_pixmap_and_mask ( GdkPixbuf *pixbuf, GdkPixmap **pixmap_return, GdkBitmap **mask_return,int alpha_threshold);
void gdk_pixbuf_render_pixmap_and_mask_for_colormap ( GdkPixbuf *pixbuf, GdkColormap *colormap, GdkPixmap **pixmap_return, GdkBitmap **mask_return,int alpha_threshold);
GdkPixbuf* gdk_pixbuf_get_from_drawable ( GdkPixbuf *dest, GdkDrawable *src, GdkColormap *cmap,int src_x,int src_y,int dest_x,int dest_y,int width,int height);
GdkPixbuf* gdk_pixbuf_get_from_drawable ( GdkPixbuf *dest, GdkDrawable *src, GdkColormap *cmap,int src_x,int src_y,int dest_x,int dest_y,int width,int height);
GdkPixbuf* gdk_pixbuf_get_from_image ( GdkPixbuf *dest, GdkImage *src, GdkColormap *cmap,int src_x,int src_y,int dest_x,int dest_y,int width,int height);
GdkPixbuf* gdk_pixbuf_get_from_image ( GdkPixbuf *dest, GdkImage *src, GdkColormap *cmap,int src_x,int src_y,int dest_x,int dest_y,int width,int height);
GdkColormap* gdk_colormap_new ( GdkVisual *visual,gboolean allocate);
GdkColormap* gdk_colormap_ref ( GdkColormap *cmap);
void gdk_colormap_unref ( GdkColormap *cmap);
GdkColormap* gdk_colormap_get_system (void);
gint gdk_colormap_get_system_size (void);
void gdk_colormap_change ( GdkColormap *colormap,gint ncolors);
gint gdk_colormap_alloc_colors ( GdkColormap *colormap, GdkColor *colors,gint ncolors,gboolean writeable,gboolean best_match,gboolean *success);
gboolean gdk_colormap_alloc_color ( GdkColormap *colormap, GdkColor *color,gboolean writeable,gboolean best_match);
void gdk_colormap_free_colors ( GdkColormap *colormap, GdkColor *colors,gint ncolors);
void gdk_colormap_query_color ( GdkColormap *colormap,gulong pixel, GdkColor *result);
GdkVisual* gdk_colormap_get_visual ( GdkColormap *colormap);
GdkScreen* gdk_colormap_get_screen ( GdkColormap *cmap);
void gdk_colors_store ( GdkColormap *colormap, GdkColor *colors,gint ncolors);
GdkColor* gdk_color_copy (const GdkColor *color);
void gdk_color_free ( GdkColor *color);
gint gdk_colors_alloc ( GdkColormap *colormap,gboolean contiguous,gulong *planes,gint nplanes,gulong *pixels,gint npixels);
void gdk_colors_free ( GdkColormap *colormap,gulong *pixels,gint npixels,gulong planes);
gint gdk_color_white ( GdkColormap *colormap, GdkColor *color);
gint gdk_color_black ( GdkColormap *colormap, GdkColor *color);
gboolean gdk_color_parse (const gchar *spec, GdkColor *color);
gint gdk_color_alloc ( GdkColormap *colormap, GdkColor *color);
gint gdk_color_change ( GdkColormap *colormap, GdkColor *color);
gboolean gdk_color_equal (const GdkColor *colora,const GdkColor *colorb);
guint gdk_color_hash (const GdkColor *colora);
void gdk_query_depths (gint **depths,gint *count);
void gdk_query_visual_types ( GdkVisualType **visual_types,gint *count);
GList* gdk_list_visuals (void);
gint gdk_visual_get_best_depth (void);
GdkVisualType gdk_visual_get_best_type (void);
GdkVisual* gdk_visual_get_system (void);
GdkVisual* gdk_visual_get_best (void);
GdkVisual* gdk_visual_get_best_with_depth (gint depth);
GdkVisual* gdk_visual_get_best_with_type ( GdkVisualType visual_type);
GdkVisual* gdk_visual_get_best_with_both (gint depth, GdkVisualType visual_type);
GdkScreen* gdk_visual_get_screen ( GdkVisual *visual);
GdkFont* gdk_font_load (const gchar *font_name);
GdkFont* gdk_font_load_for_display ( GdkDisplay *display,const gchar *font_name);
GdkFont* gdk_fontset_load (const gchar *fontset_name);
GdkFont* gdk_fontset_load_for_display ( GdkDisplay *display,const gchar *fontset_name);
GdkFont* gdk_font_from_description (PangoFontDescription *font_desc);
GdkFont* gdk_font_from_description_for_display ( GdkDisplay *display,PangoFontDescription *font_desc);
GdkDisplay* gdk_font_get_display ( GdkFont *font);
GdkFont* gdk_font_ref ( GdkFont *font);
void gdk_font_unref ( GdkFont *font);
gint gdk_font_id (const GdkFont *font);
gboolean gdk_font_equal (const GdkFont *fonta,const GdkFont *fontb);
void gdk_string_extents ( GdkFont *font,const gchar *string,gint *lbearing,gint *rbearing,gint *width,gint *ascent,gint *descent);
void gdk_text_extents ( GdkFont *font,const gchar *text,gint text_length,gint *lbearing,gint *rbearing,gint *width,gint *ascent,gint *descent);
void gdk_text_extents_wc ( GdkFont *font,const GdkWChar *text,gint text_length,gint *lbearing,gint *rbearing,gint *width,gint *ascent,gint *descent);
gint gdk_string_width ( GdkFont *font,const gchar *string);
gint gdk_text_width ( GdkFont *font,const gchar *text,gint text_length);
gint gdk_text_width_wc ( GdkFont *font,const GdkWChar *text,gint text_length);
gint gdk_char_width ( GdkFont *font,gchar character);
gint gdk_char_width_wc ( GdkFont *font, GdkWChar character);
gint gdk_string_measure ( GdkFont *font,const gchar *string);
gint gdk_text_measure ( GdkFont *font,const gchar *text,gint text_length);
gint gdk_char_measure ( GdkFont *font,gchar character);
gint gdk_string_height ( GdkFont *font,const gchar *string);
gint gdk_text_height ( GdkFont *font,const gchar *text,gint text_length);
gint gdk_char_height ( GdkFont *font,gchar character);
gchar* gdk_wcstombs (const GdkWChar *src);
gint gdk_mbstowcs ( GdkWChar *dest,const gchar *src,gint dest_max);
GdkCursor* gdk_cursor_new ( GdkCursorType cursor_type);
GdkCursor* gdk_cursor_new_from_pixmap ( GdkPixmap *source, GdkPixmap *mask,const GdkColor *fg,const GdkColor *bg,gint x,gint y);
GdkCursor* gdk_cursor_new_from_pixbuf ( GdkDisplay *display, GdkPixbuf *pixbuf,gint x,gint y);
GdkCursor* gdk_cursor_new_from_name ( GdkDisplay *display,const gchar *name);
GdkCursor* gdk_cursor_new_for_display ( GdkDisplay *display, GdkCursorType cursor_type);
GdkDisplay* gdk_cursor_get_display ( GdkCursor *cursor);
GdkPixbuf* gdk_cursor_get_image ( GdkCursor *cursor);
GdkPixbuf* gdk_cursor_get_image ( GdkCursor *cursor);
GdkCursor* gdk_cursor_ref ( GdkCursor *cursor);
void gdk_cursor_unref ( GdkCursor *cursor);
GdkWindow* gdk_window_new ( GdkWindow *parent, GdkWindowAttr *attributes,gint attributes_mask);
void gdk_window_destroy ( GdkWindow *window);
GdkWindowType gdk_window_get_window_type ( GdkWindow *window);
GdkWindow* gdk_window_at_pointer (gint *win_x,gint *win_y);
void gdk_window_show ( GdkWindow *window);
void gdk_window_show_unraised ( GdkWindow *window);
void gdk_window_hide ( GdkWindow *window);
gboolean gdk_window_is_visible ( GdkWindow *window);
gboolean gdk_window_is_viewable ( GdkWindow *window);
GdkWindowState gdk_window_get_state ( GdkWindow *window);
void gdk_window_withdraw ( GdkWindow *window);
void gdk_window_iconify ( GdkWindow *window);
void gdk_window_deiconify ( GdkWindow *window);
void gdk_window_stick ( GdkWindow *window);
void gdk_window_unstick ( GdkWindow *window);
void gdk_window_maximize ( GdkWindow *window);
void gdk_window_unmaximize ( GdkWindow *window);
void gdk_window_fullscreen ( GdkWindow *window);
void gdk_window_unfullscreen ( GdkWindow *window);
void gdk_window_set_keep_above ( GdkWindow *window,gboolean setting);
void gdk_window_set_keep_below ( GdkWindow *window,gboolean setting);
void gdk_window_move ( GdkWindow *window,gint x,gint y);
void gdk_window_resize ( GdkWindow *window,gint width,gint height);
void gdk_window_move_resize ( GdkWindow *window,gint x,gint y,gint width,gint height);
void gdk_window_scroll ( GdkWindow *window,gint dx,gint dy);
void gdk_window_move_region ( GdkWindow *window, GdkRegion *region,gint dx,gint dy);
void gdk_window_reparent ( GdkWindow *window, GdkWindow *new_parent,gint x,gint y);
void gdk_window_clear ( GdkWindow *window);
void gdk_window_clear_area ( GdkWindow *window,gint x,gint y,gint width,gint height);
void gdk_window_clear_area_e ( GdkWindow *window,gint x,gint y,gint width,gint height);
void gdk_window_raise ( GdkWindow *window);
void gdk_window_lower ( GdkWindow *window);
void gdk_window_focus ( GdkWindow *window,guint32 timestamp);
void gdk_window_register_dnd ( GdkWindow *window);
void gdk_window_begin_resize_drag ( GdkWindow *window, GdkWindowEdge edge,gint button,gint root_x,gint root_y,guint32 timestamp);
void gdk_window_begin_move_drag ( GdkWindow *window,gint button,gint root_x,gint root_y,guint32 timestamp);
void gdk_window_constrain_size ( GdkGeometry *geometry,guint flags,gint width,gint height,gint *new_width,gint *new_height);
void gdk_window_begin_paint_rect ( GdkWindow *window, GdkRectangle *rectangle);
void gdk_window_begin_paint_region ( GdkWindow *window, GdkRegion *region);
void gdk_window_end_paint ( GdkWindow *window);
void gdk_window_invalidate_rect ( GdkWindow *window, GdkRectangle *rect,gboolean invalidate_children);
void gdk_window_invalidate_region ( GdkWindow *window, GdkRegion *region,gboolean invalidate_children);
GdkRegion* gdk_window_get_update_area ( GdkWindow *window);
void gdk_window_freeze_updates ( GdkWindow *window);
void gdk_window_thaw_updates ( GdkWindow *window);
void gdk_window_process_all_updates (void);
void gdk_window_process_updates ( GdkWindow *window,gboolean update_children);
void gdk_window_set_debug_updates (gboolean setting);
void gdk_window_get_internal_paint_info ( GdkWindow *window, GdkDrawable **real_drawable,gint *x_offset,gint *y_offset);
void gdk_window_enable_synchronized_configure ( GdkWindow *window);
void gdk_window_configure_finished ( GdkWindow *window);
void gdk_window_set_user_data ( GdkWindow *window,gpointer user_data);
void gdk_window_set_override_redirect ( GdkWindow *window,gboolean override_redirect);
void gdk_window_set_accept_focus ( GdkWindow *window,gboolean accept_focus);
void gdk_window_set_focus_on_map ( GdkWindow *window,gboolean focus_on_map);
void gdk_window_add_filter ( GdkWindow *window, GdkFilterFunc function,gpointer data);
void gdk_window_remove_filter ( GdkWindow *window, GdkFilterFunc function,gpointer data);
void gdk_window_shape_combine_mask ( GdkWindow *window, GdkBitmap *mask,gint x,gint y);
void gdk_window_shape_combine_region ( GdkWindow *window, GdkRegion *shape_region,gint offset_x,gint offset_y);
void gdk_window_set_child_shapes ( GdkWindow *window);
void gdk_window_merge_child_shapes ( GdkWindow *window);
void gdk_window_input_shape_combine_mask ( GdkWindow *window, GdkBitmap *mask,gint x,gint y);
void gdk_window_input_shape_combine_region ( GdkWindow *window, GdkRegion *shape_region,gint offset_x,gint offset_y);
void gdk_window_set_child_input_shapes ( GdkWindow *window);
void gdk_window_merge_child_input_shapes ( GdkWindow *window);
gboolean gdk_window_set_static_gravities ( GdkWindow *window,gboolean use_static);
void gdk_window_set_hints ( GdkWindow *window,gint x,gint y,gint min_width,gint min_height,gint max_width,gint max_height,gint flags);
void gdk_window_set_title ( GdkWindow *window,const gchar *title);
void gdk_window_set_background ( GdkWindow *window,const GdkColor *color);
void gdk_window_set_back_pixmap ( GdkWindow *window, GdkPixmap *pixmap,gboolean parent_relative);
void gdk_window_set_cursor ( GdkWindow *window, GdkCursor *cursor);
void gdk_window_get_user_data ( GdkWindow *window,gpointer *data);
void gdk_window_get_geometry ( GdkWindow *window,gint *x,gint *y,gint *width,gint *height,gint *depth);
void gdk_window_set_geometry_hints ( GdkWindow *window, GdkGeometry *geometry, GdkWindowHints geom_mask);
void gdk_window_set_icon_list ( GdkWindow *window,GList *pixbufs);
void gdk_window_set_modal_hint ( GdkWindow *window,gboolean modal);
void gdk_window_set_type_hint ( GdkWindow *window, GdkWindowTypeHint hint);
GdkWindowTypeHint gdk_window_get_type_hint ( GdkWindow *window);
void gdk_window_set_skip_taskbar_hint ( GdkWindow *window,gboolean skips_taskbar);
void gdk_window_set_skip_pager_hint ( GdkWindow *window,gboolean skips_pager);
void gdk_window_set_urgency_hint ( GdkWindow *window,gboolean urgent);
void gdk_window_get_position ( GdkWindow *window,gint *x,gint *y);
void gdk_window_get_root_origin ( GdkWindow *window,gint *x,gint *y);
void gdk_window_get_frame_extents ( GdkWindow *window, GdkRectangle *rect);
gint gdk_window_get_origin ( GdkWindow *window,gint *x,gint *y);
gboolean gdk_window_get_deskrelative_origin ( GdkWindow *window,gint *x,gint *y);
GdkWindow* gdk_window_get_pointer ( GdkWindow *window,gint *x,gint *y, GdkModifierType *mask);
GdkWindow* gdk_window_get_parent ( GdkWindow *window);
GdkWindow* gdk_window_get_toplevel ( GdkWindow *window);
GList* gdk_window_get_children ( GdkWindow *window);
GList* gdk_window_peek_children ( GdkWindow *window);
GdkEventMask gdk_window_get_events ( GdkWindow *window);
void gdk_window_set_events ( GdkWindow *window, GdkEventMask event_mask);
void gdk_window_set_icon ( GdkWindow *window, GdkWindow *icon_window, GdkPixmap *pixmap, GdkBitmap *mask);
void gdk_window_set_icon_name ( GdkWindow *window,const gchar *name);
void gdk_window_set_transient_for ( GdkWindow *window, GdkWindow *parent);
void gdk_window_set_role ( GdkWindow *window,const gchar *role);
void gdk_window_set_group ( GdkWindow *window, GdkWindow *leader);
GdkWindow* gdk_window_get_group ( GdkWindow *window);
void gdk_window_set_decorations ( GdkWindow *window, GdkWMDecoration decorations);
gboolean gdk_window_get_decorations ( GdkWindow *window, GdkWMDecoration *decorations);
void gdk_window_set_functions ( GdkWindow *window, GdkWMFunction functions);
GList* gdk_window_get_toplevels (void);
GdkWindow* gdk_get_default_root_window (void);
GdkPointerHooks* gdk_set_pointer_hooks (const GdkPointerHooks *new_hooks);
gboolean gdk_events_pending (void);
GdkEvent* gdk_event_peek (void);
GdkEvent* gdk_event_get (void);
GdkEvent* gdk_event_get_graphics_expose ( GdkWindow *window);
void gdk_event_put ( GdkEvent *event);
GdkEvent* gdk_event_new ( GdkEventType type);
GdkEvent* gdk_event_copy ( GdkEvent *event);
void gdk_event_free ( GdkEvent *event);
guint32 gdk_event_get_time ( GdkEvent *event);
gboolean gdk_event_get_state ( GdkEvent *event, GdkModifierType *state);
gboolean gdk_event_get_axis ( GdkEvent *event, GdkAxisUse axis_use,gdouble *value);
gboolean gdk_event_get_coords ( GdkEvent *event,gdouble *x_win,gdouble *y_win);
gboolean gdk_event_get_root_coords ( GdkEvent *event,gdouble *x_root,gdouble *y_root);
void gdk_event_handler_set ( GdkEventFunc func,gpointer data,GDestroyNotify notify);
gboolean gdk_event_send_client_message ( GdkEvent *event, GdkNativeWindow winid);
gboolean gdk_event_send_client_message_for_display ( GdkDisplay *display, GdkEvent *event, GdkNativeWindow winid);
void gdk_event_send_clientmessage_toall ( GdkEvent *event);
void gdk_add_client_message_filter ( GdkAtom message_type, GdkFilterFunc func,gpointer data);
gboolean gdk_get_show_events (void);
void gdk_set_show_events (gboolean show_events);
void gdk_event_set_screen ( GdkEvent *event, GdkScreen *screen);
GdkScreen* gdk_event_get_screen ( GdkEvent *event);
gboolean gdk_setting_get (const gchar *name,GValue *value);
GdkKeymap* gdk_keymap_get_default (void);
GdkKeymap* gdk_keymap_get_for_display ( GdkDisplay *display);
guint gdk_keymap_lookup_key ( GdkKeymap *keymap,const GdkKeymapKey *key);
gboolean gdk_keymap_translate_keyboard_state ( GdkKeymap *keymap,guint hardware_keycode, GdkModifierType state,gint group,guint *keyval,gint *effective_group,gint *level, GdkModifierType *consumed_modifiers);
gboolean gdk_keymap_get_entries_for_keyval ( GdkKeymap *keymap,guint keyval, GdkKeymapKey **keys,gint *n_keys);
gboolean gdk_keymap_get_entries_for_keycode ( GdkKeymap *keymap,guint hardware_keycode, GdkKeymapKey **keys,guint **keyvals,gint *n_entries);
PangoDirection gdk_keymap_get_direction ( GdkKeymap *keymap);
gchar* gdk_keyval_name (guint keyval);
guint gdk_keyval_from_name (const gchar *keyval_name);
void gdk_keyval_convert_case (guint symbol,guint *lower,guint *upper);
guint gdk_keyval_to_upper (guint keyval);
guint gdk_keyval_to_lower (guint keyval);
gboolean gdk_keyval_is_upper (guint keyval);
gboolean gdk_keyval_is_lower (guint keyval);
guint32 gdk_keyval_to_unicode (guint keyval);
guint gdk_unicode_to_keyval (guint32 wc);
gboolean gdk_selection_owner_set ( GdkWindow *owner, GdkAtom selection,guint32 time_,gboolean send_event);
gboolean gdk_selection_owner_set_for_display ( GdkDisplay *display, GdkWindow *owner, GdkAtom selection,guint32 time_,gboolean send_event);
GdkWindow* gdk_selection_owner_get ( GdkAtom selection);
GdkWindow* gdk_selection_owner_get_for_display ( GdkDisplay *display, GdkAtom selection);
void gdk_selection_convert ( GdkWindow *requestor, GdkAtom selection, GdkAtom target,guint32 time_);
gboolean gdk_selection_property_get ( GdkWindow *requestor,guchar **data, GdkAtom *prop_type,gint *prop_format);
void gdk_selection_send_notify (guint32 requestor, GdkAtom selection, GdkAtom target, GdkAtom property,guint32 time_);
void gdk_selection_send_notify_for_display ( GdkDisplay *display,guint32 requestor, GdkAtom selection, GdkAtom target, GdkAtom property,guint32 time_);
GdkAtom gdk_drag_get_selection ( GdkDragContext *context);
void gdk_drag_abort ( GdkDragContext *context,guint32 time_);
void gdk_drop_reply ( GdkDragContext *context,gboolean ok,guint32 time_);
GdkDragContext* gdk_drag_context_new (void);
void gdk_drag_drop ( GdkDragContext *context,guint32 time_);
void gdk_drag_find_window ( GdkDragContext *context, GdkWindow *drag_window,gint x_root,gint y_root, GdkWindow **dest_window, GdkDragProtocol *protocol);
void gdk_drag_find_window_for_screen ( GdkDragContext *context, GdkWindow *drag_window, GdkScreen *screen,gint x_root,gint y_root, GdkWindow **dest_window, GdkDragProtocol *protocol);
void gdk_drag_context_ref ( GdkDragContext *context);
GdkDragContext* gdk_drag_begin ( GdkWindow *window,GList *targets);
gboolean gdk_drag_motion ( GdkDragContext *context, GdkWindow *dest_window, GdkDragProtocol protocol,gint x_root,gint y_root, GdkDragAction suggested_action, GdkDragAction possible_actions,guint32 time_);
void gdk_drop_finish ( GdkDragContext *context,gboolean success,guint32 time_);
guint32 gdk_drag_get_protocol (guint32 xid, GdkDragProtocol *protocol);
guint32 gdk_drag_get_protocol_for_display ( GdkDisplay *display,guint32 xid, GdkDragProtocol *protocol);
void gdk_drag_context_unref ( GdkDragContext *context); GdkDragContext ;
void gdk_drag_status ( GdkDragContext *context, GdkDragAction action,guint32 time_);
gboolean gdk_drag_drop_succeeded ( GdkDragContext *context);
gint gdk_text_property_to_text_list ( GdkAtom encoding,gint format,const guchar *text,gint length,gchar ***list);
gint gdk_text_property_to_text_list_for_display ( GdkDisplay *display, GdkAtom encoding,gint format,const guchar *text,gint length,gchar ***list);
void gdk_free_text_list (gchar **list);
gint gdk_text_property_to_utf8_list ( GdkAtom encoding,gint format,const guchar *text,gint length,gchar ***list);
gint gdk_text_property_to_utf8_list_for_display ( GdkDisplay *display, GdkAtom encoding,gint format,const guchar *text,gint length,gchar ***list);
gint gdk_string_to_compound_text (const gchar *str, GdkAtom *encoding,gint *format,guchar **ctext,gint *length);
gint gdk_string_to_compound_text_for_display ( GdkDisplay *display,const gchar *str, GdkAtom *encoding,gint *format,guchar **ctext,gint *length);
void gdk_free_compound_text (guchar *ctext);
gchar* gdk_utf8_to_string_target (const gchar *str);
gboolean gdk_utf8_to_compound_text (const gchar *str, GdkAtom *encoding,gint *format,guchar **ctext,gint *length);
gboolean gdk_utf8_to_compound_text_for_display ( GdkDisplay *display,const gchar *str, GdkAtom *encoding,gint *format,guchar **ctext,gint *length);
GdkAtom gdk_atom_intern (const gchar *atom_name,gboolean only_if_exists);
GdkAtom gdk_atom_intern_static_string (const gchar *atom_name);
gchar* gdk_atom_name ( GdkAtom atom);
gboolean gdk_property_get ( GdkWindow *window, GdkAtom property, GdkAtom type,gulong offset,gulong length,gint pdelete, GdkAtom *actual_property_type,gint *actual_format,gint *actual_length,guchar **data);
void gdk_property_change ( GdkWindow *window, GdkAtom property, GdkAtom type,gint format, GdkPropMode mode,const guchar *data,gint nelements);
void gdk_property_delete ( GdkWindow *window, GdkAtom property);
gboolean gdk_rectangle_intersect ( GdkRectangle *src1, GdkRectangle *src2, GdkRectangle *dest);
void gdk_rectangle_union ( GdkRectangle *src1, GdkRectangle *src2, GdkRectangle *dest);
GdkRegion* gdk_region_new (void);
GdkRegion* gdk_region_polygon ( GdkPoint *points,gint npoints, GdkFillRule fill_rule);
GdkRegion* gdk_region_copy ( GdkRegion *region);
GdkRegion* gdk_region_rectangle ( GdkRectangle *rectangle);
void gdk_region_destroy ( GdkRegion *region);
void gdk_region_get_clipbox ( GdkRegion *region, GdkRectangle *rectangle);
void gdk_region_get_rectangles ( GdkRegion *region, GdkRectangle **rectangles,gint *n_rectangles);
gboolean gdk_region_empty ( GdkRegion *region);
gboolean gdk_region_equal ( GdkRegion *region1, GdkRegion *region2);
gboolean gdk_region_point_in ( GdkRegion *region,int x,int y);
GdkOverlapType gdk_region_rect_in ( GdkRegion *region, GdkRectangle *rectangle);
void gdk_region_offset ( GdkRegion *region,gint dx,gint dy);
void gdk_region_shrink ( GdkRegion *region,gint dx,gint dy);
void gdk_region_union_with_rect ( GdkRegion *region, GdkRectangle *rect);
void gdk_region_intersect ( GdkRegion *source1, GdkRegion *source2);
void gdk_region_union ( GdkRegion *source1, GdkRegion *source2);
void gdk_region_subtract ( GdkRegion *source1, GdkRegion *source2);
void gdk_region_xor ( GdkRegion *source1, GdkRegion *source2);
void gdk_region_spans_intersect_foreach ( GdkRegion *region, GdkSpan *spans,int n_spans,gboolean sorted, GdkSpanFunc function,gpointer data);
GList* gdk_devices_list (void);
void gdk_device_set_source ( GdkDevice *device, GdkInputSource source);
gboolean gdk_device_set_mode ( GdkDevice *device, GdkInputMode mode);
void gdk_device_set_key ( GdkDevice *device,guint index_,guint keyval, GdkModifierType modifiers);
void gdk_device_set_axis_use ( GdkDevice *device,guint index_, GdkAxisUse use);
GdkDevice* gdk_device_get_core_pointer (void);
void gdk_device_get_state ( GdkDevice *device, GdkWindow *window,gdouble *axes, GdkModifierType *mask);
gboolean gdk_device_get_history ( GdkDevice *device, GdkWindow *window,guint32 start,guint32 stop, GdkTimeCoord ***events,gint *n_events);
void gdk_device_free_history ( GdkTimeCoord **events,gint n_events); GdkTimeCoord ;
gboolean gdk_device_get_axis ( GdkDevice *device,gdouble *axes, GdkAxisUse use,gdouble *value);
void gdk_input_set_extension_events ( GdkWindow *window,gint mask, GdkExtensionMode mode);
void gdk_threads_init (void);
void gdk_threads_enter (void);
void gdk_threads_leave (void);
void gdk_threads_set_lock_functions (GCallback enter_fn,GCallback leave_fn);
gint gdk_input_add_full (gint source, GdkInputCondition condition, GdkInputFunction function,gpointer data, GdkDestroyNotify destroy);
gint gdk_input_add (gint source, GdkInputCondition condition, GdkInputFunction function,gpointer data);
void gdk_input_remove (gint tag);
GList* gdk_devices_list (void);
void gdk_device_set_source ( GdkDevice *device, GdkInputSource source);
gboolean gdk_device_set_mode ( GdkDevice *device, GdkInputMode mode);
void gdk_device_set_key ( GdkDevice *device,guint index_,guint keyval, GdkModifierType modifiers);
void gdk_device_set_axis_use ( GdkDevice *device,guint index_, GdkAxisUse use);
GdkDevice* gdk_device_get_core_pointer (void);
void gdk_device_get_state ( GdkDevice *device, GdkWindow *window,gdouble *axes, GdkModifierType *mask);
gboolean gdk_device_get_history ( GdkDevice *device, GdkWindow *window,guint32 start,guint32 stop, GdkTimeCoord ***events,gint *n_events);
void gdk_device_free_history ( GdkTimeCoord **events,gint n_events); GdkTimeCoord ;
gboolean gdk_device_get_axis ( GdkDevice *device,gdouble *axes, GdkAxisUse use,gdouble *value);
void gdk_input_set_extension_events ( GdkWindow *window,gint mask, GdkExtensionMode mode);
PangoRenderer* gdk_pango_renderer_new ( GdkScreen *screen);
PangoRenderer* gdk_pango_renderer_get_default ( GdkScreen *screen);
void gdk_pango_renderer_set_drawable ( GdkPangoRenderer *gdk_renderer, GdkDrawable *drawable);
void gdk_pango_renderer_set_gc ( GdkPangoRenderer *gdk_renderer, GdkGC *gc);
void gdk_pango_renderer_set_stipple ( GdkPangoRenderer *gdk_renderer,PangoRenderPart part, GdkBitmap *stipple);
void gdk_pango_renderer_set_override_color ( GdkPangoRenderer *gdk_renderer,PangoRenderPart part,const GdkColor *color);
PangoContext* gdk_pango_context_get (void);
PangoContext* gdk_pango_context_get_for_screen ( GdkScreen *screen);
void gdk_pango_context_set_colormap (PangoContext *context, GdkColormap *colormap); GdkPangoAttrEmbossed ; GdkPangoAttrStipple ;
PangoAttribute* gdk_pango_attr_embossed_new (gboolean embossed);
PangoAttribute* gdk_pango_attr_stipple_new ( GdkBitmap *stipple);
GdkRegion* gdk_pango_layout_get_clip_region (PangoLayout *layout,gint x_origin,gint y_origin,gint *index_ranges,gint n_ranges);
GdkRegion* gdk_pango_layout_line_get_clip_region (PangoLayoutLine *line,gint x_origin,gint y_origin,gint *index_ranges,gint n_ranges);
GdkVisual* gdkx_visual_get (VisualID xvisualid);
GdkColormap* gdkx_colormap_get (Colormap xcolormap);
GdkPixmap* gdk_pixmap_foreign_new ( GdkNativeWindow anid);
GdkPixmap* gdk_pixmap_foreign_new_for_display ( GdkDisplay *display, GdkNativeWindow anid);
GdkPixmap* gdk_pixmap_foreign_new_for_screen ( GdkScreen *screen, GdkNativeWindow anid,gint width,gint height,gint depth);
GdkWindow* gdk_window_foreign_new ( GdkNativeWindow anid);
GdkWindow* gdk_window_foreign_new_for_display ( GdkDisplay *display, GdkNativeWindow anid);
gpointer gdk_xid_table_lookup (XID xid);
gpointer gdk_xid_table_lookup_for_display ( GdkDisplay *display,XID xid);
GdkWindow* gdk_window_lookup ( GdkNativeWindow anid);
GdkWindow* gdk_window_lookup_for_display ( GdkDisplay *display, GdkNativeWindow anid);
GdkPixmap* gdk_pixmap_lookup ( GdkNativeWindow anid);
GdkPixmap* gdk_pixmap_lookup_for_display ( GdkDisplay *display, GdkNativeWindow anid);
GdkDisplay* gdk_x11_lookup_xdisplay (Display *xdisplay);
guint32 gdk_x11_get_server_time ( GdkWindow *window);
gboolean gdk_net_wm_supports ( GdkAtom property);
gboolean gdk_x11_screen_supports_net_wm_hint ( GdkScreen *screen, GdkAtom property);
const char* gdk_x11_screen_get_window_manager_name ( GdkScreen *screen);
GdkVisual* gdk_x11_screen_lookup_visual ( GdkScreen *screen,VisualID xvisualid);
void gdk_x11_window_set_user_time ( GdkWindow *window,guint32 timestamp);
void gdk_x11_window_move_to_current_desktop ( GdkWindow *window);
guint32 gdk_x11_display_get_user_time ( GdkDisplay *display);
GdkColormap* gdk_x11_colormap_foreign_new ( GdkVisual *visual,Colormap xcolormap);
Colormap gdk_x11_colormap_get_xcolormap ( GdkColormap *colormap);
Display* gdk_x11_colormap_get_xdisplay ( GdkColormap *colormap);
Cursor gdk_x11_cursor_get_xcursor ( GdkCursor *cursor);
Display* gdk_x11_cursor_get_xdisplay ( GdkCursor *cursor);
Display* gdk_x11_display_get_xdisplay ( GdkDisplay *display);
void gdk_x11_display_grab ( GdkDisplay *display);
void gdk_x11_display_ungrab ( GdkDisplay *display);
void gdk_x11_display_set_cursor_theme ( GdkDisplay *display,const gchar *theme,const gint size);
void gdk_x11_register_standard_event_type ( GdkDisplay *display,gint event_base,gint n_events);
Display* gdk_x11_drawable_get_xdisplay ( GdkDrawable *drawable);
XID gdk_x11_drawable_get_xid ( GdkDrawable *drawable);
const char* gdk_x11_font_get_name ( GdkFont *font);
Display* gdk_x11_font_get_xdisplay ( GdkFont *font);
gpointer gdk_x11_font_get_xfont ( GdkFont *font);
Display* gdk_x11_gc_get_xdisplay ( GdkGC *gc);
GC gdk_x11_gc_get_xgc ( GdkGC *gc);
Window gdk_x11_get_default_root_xwindow (void);
gint gdk_x11_get_default_screen (void);
Display* gdk_x11_get_default_xdisplay (void);
void gdk_x11_grab_server (void);
Display* gdk_x11_image_get_xdisplay ( GdkImage *image);
XImage* gdk_x11_image_get_ximage ( GdkImage *image);
int gdk_x11_screen_get_screen_number ( GdkScreen *screen);
Screen* gdk_x11_screen_get_xscreen ( GdkScreen *screen);
void gdk_x11_ungrab_server (void);
Visual* gdk_x11_visual_get_xvisual ( GdkVisual *visual);
Atom gdk_x11_atom_to_xatom ( GdkAtom atom);
Atom gdk_x11_atom_to_xatom_for_display ( GdkDisplay *display, GdkAtom atom);
GdkAtom gdk_x11_xatom_to_atom (Atom xatom);
GdkAtom gdk_x11_xatom_to_atom_for_display ( GdkDisplay *display,Atom xatom);
Atom gdk_x11_get_xatom_by_name (const gchar *atom_name);
Atom gdk_x11_get_xatom_by_name_for_display ( GdkDisplay *display,const gchar *atom_name);
const gchar* gdk_x11_get_xatom_name (Atom xatom);
const gchar* gdk_x11_get_xatom_name_for_display ( GdkDisplay *display,Atom xatom);
