GXK-Functions - Gtk+ Extension Kit Function Reference

Document Revised: Wed May 25 23:38:23 2005

CBbst_gmask_container_create(CIborder_width, CIdislodge_columns);

CBbst_gmask_foreach(CImask, CIfunc, CIdata);

CBbst_gmask_form(CIgmask_container, CIaction, CIgpack);

CBbst_gmask_get_action(CImask);

CBbst_gmask_get_aux1(CImask);

CBbst_gmask_get_aux2(CImask);

CBbst_gmask_get_aux3(CImask);

CBbst_gmask_get_prompt(CImask);

CBbst_gmask_pack(CImask);

CBbst_gmask_quick(CIgmask_container, CIcolumn, CIprompt, CIaction, CItip_text);

CBbst_gmask_set_aux1(CImask, CIwidget);

CBbst_gmask_set_aux2(CImask, CIwidget);

CBbst_gmask_set_aux3(CImask, CIwidget);

CBbst_gmask_set_column(CImask, CIcolumn);

CBbst_gmask_set_prompt(CImask, CIwidget);

CBbst_gmask_set_tip(CImask, CItip_text);

CBg_object_get_double(CIobject, CIname);

CBg_object_get_long(CIobject, CIname);

CBg_object_set_double(CIobject, CIname, CIv_double);

CBg_object_set_long(CIobject, CIname, CIv_long);

CBgnome_canvas_set_zoom(CIcanvas, CIpixels_per_unit);

CBgnome_canvas_text_set_zoom_size(CIitem, CIpixels);

CBgtk_box_get_nth_child(CIbox, CIpos);

CBgtk_notebook_current_widget(CInotebook);

CBgxk_cell_editable_canceled(CIecell);

CBgxk_cell_editable_is_focus_handler(CIecell);

CBgxk_cell_renderer_popup_get_type();

CBgxk_color_alloc(CIcolormap, CIcolor);

CBgxk_dialog_action*(CIdialog, CIaction, CIcallback, CIdata);

CBgxk_dialog_add_flags(CIdialog, CIflags);

CBgxk_dialog_clear_flags(CIdialog, CIflags);

CBgxk_dialog_get_child(CIdialog);

CBgxk_dialog_get_status_window();

CBgxk_dialog_new(CIpointer_loc, CIalive_object, CIflags, CItitle, CIchild);

CBgxk_dialog_remove_actions(CIdialog);

CBgxk_dialog_set_child(CIdialog, CIchild);

CBgxk_dialog_set_default(CIself, CIdefault_widget);

CBgxk_dialog_set_focus(CIself, CIfocus_widget);

CBgxk_dialog_set_sizes(CIdialog, CImin_width, CImin_height, CIdefault_width, CIdefault_height);

CBgxk_dialog_set_title(CIdialog, CItitle);

CBgxk_expander_connect_to_widget(CIexpander, CIwidget);

CBgxk_file_selection_heal(CIfs);

CBgxk_grab_pointer_and_keyboard(CIwindow, CIowner_events, CIevent_mask, CIconfine_to, CIcursor, CItime);

CBgxk_idle_show_widget(CIwidget);

CBgxk_idle_showraise(CIwidget);

CBgxk_idle_unrealize_widget(CIwidget);

CBgxk_item_factory_get_item(CIifactory, CIpath);

CBgxk_item_factory_get_widget(CIifactory, CIpath);

CBgxk_item_factory_sensitize(CIifactory, CIpath, CIsensitive);

CBgxk_label_set_attributes:(CIlabel, CI...);

CBgxk_led_new(CIcolor);

CBgxk_led_set_color(CIself, CIcolor);

CBgxk_menu_attach_as_popup(CImenu, CIwidget);

CBgxk_menu_attach_as_popup_with_func(CImenu, CIwidget, CImdfunc);

CBgxk_menu_attach_as_submenu(CImenu, CImenu_item);

CBgxk_menu_check_sensitive(CImenu);

CBgxk_menu_set_active(CImenu, CIchild);

CBgxk_notebook_append(CInotebook, CIchild, CItab_text, CIfillexpand);

CBgxk_notebook_descendant_get_page(CIwidget);

CBgxk_notebook_descendant_get_tab(CIwidget);

CBgxk_notebook_set_current_page_widget(CInotebook, CIpage);

CBgxk_option_menu_set_menu(CIoption_menu, CImenu);

CBgxk_polygon_new(CIpolygon_graph);

CBgxk_polygon_set_arcs(CIself, CIn_arcs, CIarcs);

CBgxk_polygon_set_graph(CIself, CIpolygon_graph);

CBgxk_polygon_set_length(CIself, CIlength);

CBgxk_polygon_set_lines(CIself, CIn_lines, CIlines);

CBgxk_proxy_editable_get_type();

CBgxk_proxy_editable_set_cell_editable(CIself, CIecell);

CBgxk_scroll_text_advance(CIsctext, CIuri);

CBgxk_scroll_text_append(CIsctext, CIstring);

CBgxk_scroll_text_append_file(CIsctext, CIfile_name);

CBgxk_scroll_text_append_file_tsm(CIsctext, CIfile_name);

CBgxk_scroll_text_append_tsm(CIsctext, CIstring);

CBgxk_scroll_text_aprintf(CIsctext, CItext_fmt);

CBgxk_scroll_text_clear(CIsctext);

CBgxk_scroll_text_create(CIflags, CIstring);

CBgxk_scroll_text_display(CIsctext, CIuri);

CBgxk_scroll_text_enter(CIsctext, CIuri);

CBgxk_scroll_text_get_text_view(CIsctext);

CBgxk_scroll_text_pop_indent(CIsctext);

CBgxk_scroll_text_push_indent(CIsctext);

CBgxk_scroll_text_rewind(CIsctext);

CBgxk_scroll_text_set(CIsctext, CIstring);

CBgxk_scroll_text_set_index(CIsctext, CIuri);

CBgxk_scroll_text_set_tsm(CIsctext, CIstring);

CBgxk_scrolled_window_create(CIchild, CIshadow_type, CIxrequest, CIyrequest);

CBgxk_scrolled_window_spare_space(CIscwin);

CBgxk_scrolled_window_unspare_space(CIscwin);

CBgxk_signal_handler_exists(CIinstance, CIdetailed_signal, CIcallback, CIdata);

CBgxk_signal_handler_pending(CIinstance, CIdetailed_signal, CIcallback, CIdata);

CBgxk_size_group(CIsgmode, CI...);

CBgxk_size_height(CIicon_size);

CBgxk_size_width(CIicon_size);

CBgxk_spline_copy(CIspline);

CBgxk_spline_dump(CIspline);

CBgxk_spline_eval(CIspline, CIx, CIyd1);

CBgxk_spline_findx(CIspline, CIy);

CBgxk_spline_free(CIspline);

CBgxk_spline_new(CIn_points, CIpoints, CIdy_start, CIdy_end);

CBgxk_spline_new_natural(CIn_points, CIpoints);

CBgxk_spline_y(CIspline, CIx);

CBgxk_status_bar_create();

CBgxk_status_clear();

CBgxk_status_errnoprintf(CIlibc_errno, CImessage_fmt);

CBgxk_status_printf(CIpercentage, CIstatus_msg, CImessage_fmt);

CBgxk_status_set(CIpercentage, CImessage, CIstatus_msg);

CBgxk_status_window_pop();

CBgxk_status_window_push(CIwidget);

CBgxk_stock_button(CIstock_id, CIlabel);

CBgxk_stock_button_child(CIstock_id, CIlabel);

CBgxk_stock_fallback_pixbuf(CIstock_id);

CBgxk_stock_icon_window(CIstock_id);

CBgxk_stock_image(CIstock_icon_id, CIicon_size);

CBgxk_stock_register_icon(CIicon);

CBgxk_stock_register_icons(CIn_icons, CIicons);

CBgxk_stock_register_item(CIitem);

CBgxk_stock_register_items(CIn_items, CIitems);

CBgxk_text_view_cursor_to_end(CItview);

CBgxk_text_view_cursor_to_start(CItview);

CBgxk_text_view_enter_browse_mode(CItview);

CBgxk_text_view_leave_browse_mode(CItview);

CBgxk_toplevel_activate_default(CIwidget);

CBgxk_toplevel_delete(CIwidget);

CBgxk_toplevel_hide(CIwidget);

CBgxk_tree_model_get_iter(CItree_model, CIiter, CIpath);

CBgxk_tree_path_prev(CIpath);

CBgxk_tree_selection_force_browse(CIselection, CImodel);

CBgxk_tree_selection_select_ipath(CIselection, CI...);

CBgxk_tree_selection_select_spath(CIselection, CIstr_path);

CBgxk_tree_selection_unselect_ipath(CIselection, CI...);

CBgxk_tree_selection_unselect_spath(CIselection, CIstr_path);

CBgxk_tree_spath_index0(CIstrpath);

CBgxk_tree_view_add_column(CItree_view, CIposition, CIcolumn, CIcell, CI...);

CBgxk_tree_view_add_popup_column(CItree_view, CImodel_column, CIcolumn_flags, CIxalign, CItitle, CItooltip, CIedited_callback, CIpopup_callback, CIdata, CIcflags);

CBgxk_tree_view_add_text_column(CItree_view, CImodel_column, CIcolumn_flags, CIxalign, CItitle, CItooltip, CIedited_callback, CIdata, CIcflags);

CBgxk_tree_view_add_toggle_column(CItree_view, CImodel_column, CIcolumn_flags, CIxalign, CItitle, CItooltip, CItoggled_callback, CIdata, CIcflags);

CBgxk_tree_view_append_text_columns(CItree_view, CIn_cols, CI...);

CBgxk_tree_view_column_set_tip_title(CItree_column, CItitle, CItooltip);

CBgxk_tree_view_focus_row(CItree, CIrow);

CBgxk_tree_view_get_bin_window_pos(CItree, CIx_p, CIy_p);

CBgxk_tree_view_get_row_area(CItree, CIrow, CIy_p, CIheight_p, CIcontent_area);

CBgxk_tree_view_get_row_from_coord(CItree, CIy, CIrow_p);

CBgxk_tree_view_get_selected_row(CItree);

CBgxk_tree_view_is_row_selected(CItree, CIrow);

CBgxk_type_register_generated(CIn_entries, CIentries);

CBgxk_ungrab_pointer_and_keyboard(CIwindow, CItime);

CBgxk_vseparator_space_new(CIdraw_seperator);

CBgxk_widget_activate_accel_group(CIwidget, CIaccel_group);

CBgxk_widget_add_font_requisition(CIwidget, CIn_chars, CIn_digits);

CBgxk_widget_add_option(CIwidget, CIoption, CIvalue);

CBgxk_widget_ancestry_viewable(CIwidget);

CBgxk_widget_attached_hierarchy_changed(CIwidget);

CBgxk_widget_check_option(CIwidget, CIoption);

CBgxk_widget_find_level_ordered(CItoplevel, CIname);

CBgxk_widget_force_bg_clear(CIwidget);

CBgxk_widget_get_attach_toplevel(CIwidget);

CBgxk_widget_get_latent_tooltip(CIwidget);

CBgxk_widget_get_options(CIwidget);

CBgxk_widget_has_ancestor(CIwidget, CIancestor);

CBgxk_widget_make_insensitive(CIwidget);

CBgxk_widget_make_sensitive(CIwidget);

CBgxk_widget_modify_as_title(CIwidget);

CBgxk_widget_modify_base_as_bg(CIwidget);

CBgxk_widget_modify_bg_as_active(CIwidget);

CBgxk_widget_modify_bg_as_base(CIwidget);

CBgxk_widget_modify_normal_bg_as_base(CIwidget);

CBgxk_widget_proxy_requisition(CIwidget, CIxscale, CIyscale);

CBgxk_widget_regulate(CIwidget, CIsensitive, CIactive);

CBgxk_widget_regulate_uses_active(CIwidget);

CBgxk_widget_request_hclient_height(CIwidget, CIclient);

CBgxk_widget_request_vclient_width(CIwidget, CIclient);

CBgxk_widget_set_latent_tooltip(CIwidget, CItooltip);

CBgxk_widget_set_tooltip(CIwidget, CItooltip);

CBgxk_widget_showraise(CIwidget);

CBgxk_widget_viewable(CIwidget);

CBgxk_widget_viewable_changed(CIwidget);

CBgxk_window_get_menu_accel_group(CIwindow);

CBgxk_window_process_next(CIwindow, CIupdate_children);

CBgxk_window_set_cursor_type(CIwindow, CIcursor);

CBbst_gmask_container_create(CIborder_width, CIdislodge_columns); nokeep; l l l. CIguint CIborder_width; T{ Border width of this GUI mask T} CIgboolean CIdislodge_columns; T{ Provide expandable space between columns T} h'-2m'CIRETURNS: T{ GUI field mask container T}

Create a container capable to hold GUI field masks. This is the container to be passed into CBbst_gmask_form(). In case multiple field mask columns are packed into the container (by using CBbst_gmask_set_column() on the filed masks), CIdislodge_columns specifies whether the field mask columns are to be closely aligned.

CBbst_gmask_foreach(CImask, CIfunc, CIdata); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} CIgpointer CIfunc; T{ foreach function as: void CBfunc(GtkWidget*, gpointer data); T} CIgpointer CIdata; T{ data passed in to CIfunc T}

Invoke CIfunc() with each of the widgets set for this field mask.

CBbst_gmask_form(CIgmask_container, CIaction, CIgpack); nokeep; l l l. CIGtkWidget* CIgmask_container; T{ container created with CBbst_gmask_container_create() T} CIGtkWidget* CIaction; T{ valid CIGtkWidget T} CIBstGMaskPack CIgpack; T{ CIBstGMaskPack packing type T} h'-2m'CIRETURNS: T{ a new GUI field mask T}

Create a new GUI field mask with CIaction as action widget. Each GUI field mask consists of an action widget which may be neighboured by pre and post action widgets, the action widget is usually something like a CIGtkEntry input widget. Also, most field masks have a prompt widget, usually a CIGtkLabel, labeling the field mask with a name. Optionally, up to three auxillary widgets are supported per field mask, layed out between the prompt and the action widgets. The second auxillary widget will expand if additional space is available. Other layout details are configured through the CIgpack packing type:

BST_GMASK_FIT - the action widget is not expanded,

BST_GMASK_INTERLEAVE - allow the action widget to expand across auxillary columns if it requests that much space,

BST_GMASK_BIG - force expansion of the action widget across all possible columns up to the prompt,

BST_GMASK_CENTER - center the action widget within space across all possible columns up to the prompt.

BST_GMASK_MULTI_SPAN - span aux2 widget across multiple gmask columns.

CBbst_gmask_get_action(CImask); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} h'-2m'CIRETURNS: T{ the requested CIGtkWidget or NULL T}

Retrieve the action widget of this GUI field CImask.

CBbst_gmask_get_aux1(CImask); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} h'-2m'CIRETURNS: T{ the requested CIGtkWidget or NULL T}

Retrieve the first auxillary widget of this GUI field CImask.

CBbst_gmask_get_aux2(CImask); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} h'-2m'CIRETURNS: T{ the requested CIGtkWidget or NULL T}

Retrieve the second auxillary widget of this GUI field CImask.

CBbst_gmask_get_aux3(CImask); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} h'-2m'CIRETURNS: T{ the requested CIGtkWidget or NULL T}

Retrieve the third auxillary widget of this GUI field CImask.

CBbst_gmask_get_prompt(CImask); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} h'-2m'CIRETURNS: T{ the requested CIGtkWidget or NULL T}

Retrieve the prompt widget of this GUI field CImask.

CBbst_gmask_pack(CImask); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T}

After the GUI field mask is fully configured, by setting all associated widgets on it, column tooltip text, etc., this function actually packs it into its container. The field mask setters shouldn't be used after this point.

CBbst_gmask_quick(CIgmask_container, CIcolumn, CIprompt, CIaction, CItip_text); nokeep; l l l. CIGtkWidget* CIgmask_container; T{ container created with CBbst_gmask_container_create() T} CIguint CIcolumn; T{ column number for CBbst_gmask_set_column() T} CIconst gchar* CIprompt; T{ valid CIGtkWidget for CBbst_gmask_set_prompt() T} CIgpointer CIaction; T{ valid CIGtkWidget as with CBbst_gmask_form() T} CIconst gchar* CItip_text; T{ text for CBbst_gmask_set_tip() T} h'-2m'CIRETURNS: T{ an already packed GUI field mask T}

Shorthand to form a GUI field mask in CIcolumn of type BST_GMASK_INTERLEAVE, with CIprompt and CItip_text. Note that this function already calls CBbst_gmask_pack(), so the returned field mask already can't be modified anymore.

CBbst_gmask_set_aux1(CImask, CIwidget); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} CIgpointer CIwidget; T{ valid CIGtkWidget T}

Set the first auxillary widget of this GUI field CImask.

CBbst_gmask_set_aux2(CImask, CIwidget); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} CIgpointer CIwidget; T{ valid CIGtkWidget T}

Set the second auxillary widget of this GUI field CImask. In contrast to the first and third auxillary widget, this one is expanded if extra space is available.

CBbst_gmask_set_aux3(CImask, CIwidget); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} CIgpointer CIwidget; T{ valid CIGtkWidget T}

Set the third auxillary widget of this GUI field CImask.

CBbst_gmask_set_column(CImask, CIcolumn); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} CIguint CIcolumn; T{ column number T}

Set the field mask column. By default all field masks are packed into column 0, so that only vertical packing occours.

CBbst_gmask_set_prompt(CImask, CIwidget); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} CIgpointer CIwidget; T{ valid CIGtkWidget T}

Set the prompt widget of this GUI field CImask.

CBbst_gmask_set_tip(CImask, CItip_text); nokeep; l l l. CIBstGMask* CImask; T{ valid CIBstGMask T} CIconst gchar* CItip_text; T{ tooltip text T}

Set the tooltip text of this GUI field CImask.

CBg_object_get_double(CIobject, CIname); nokeep; l l l. CIgpointer CIobject; T{ a valid GObject T} CIconst gchar* CIname; T{ name of the double value to retrieve T} h'-2m'CIRETURNS: T{ the actual value T}

Convenience variant of CBg_object_get_data() to retrieve a double instead of a pointer.

CBg_object_get_long(CIobject, CIname); nokeep; l l l. CIgpointer CIobject; T{ a valid GObject T} CIconst gchar* CIname; T{ name of the long value to retrieve T} h'-2m'CIRETURNS: T{ the actual value T}

Convenience variant of CBg_object_get_data() to retrieve a long instead of a pointer.

CBg_object_set_double(CIobject, CIname, CIv_double); nokeep; l l l. CIgpointer CIobject; T{ a valid GObject T} CIconst gchar* CIname; T{ name of the double value to set T} CIgdouble CIv_double; T{ the actual value T}

Convenience variant of CBg_object_set_data() to set a double instead of a pointer.

CBg_object_set_long(CIobject, CIname, CIv_long); nokeep; l l l. CIgpointer CIobject; T{ a valid GObject T} CIconst gchar* CIname; T{ name of the long value to set T} CIglong CIv_long; T{ the actual value T}

Convenience variant of CBg_object_set_data() to set a long instead of a pointer.

CBgnome_canvas_set_zoom(CIcanvas, CIpixels_per_unit); nokeep; l l l. CIGnomeCanvas* CIcanvas; T{ valid CIGnomeCanvas T} CIgdouble CIpixels_per_unit; T{ zoom factor (defaults to 1.0) T}

This function calls CBgnome_canvas_set_pixels_per_unit() with its arguments and in addition adjusts the font sizes of all canvas text items where CBgnome_canvas_text_set_zoom_size() was used before.

CBgnome_canvas_text_set_zoom_size(CIitem, CIpixels); nokeep; l l l. CIGnomeCanvasText* CIitem; T{ canvas text item T} CIgdouble CIpixels; T{ default font size T}

Set the default font size in pixels of a canvas text item. The size will be adjusted when the canvas zoomed via CBgnome_canvas_set_zoom().

CBgtk_box_get_nth_child(CIbox, CIpos); nokeep; l l l. CIGtkBox* CIbox; T{ a valid GtkBox T} CIgint CIpos; T{ position of the requested child T} h'-2m'CIRETURNS: T{ a child of CIbox or NULL T}

Find the child at position CIpos (0 indicates the first child) of CIbox and return it. To retrieve the last xchild of CIbox, -1 may be passed as CIpos.

CBgtk_notebook_current_widget(CInotebook); nokeep; l l l. CIGtkNotebook* CInotebook; T{ valid CIGtkNotebook T} h'-2m'CIRETURNS: T{ the widget corresponding to the current page T}

This function is essentially a shortcut for CBgtk_notebook_get_current_page() and CBgtk_notebook_get_nth_page().

CBgxk_cell_editable_canceled(CIecell); nokeep; l l l. CIGtkCellEditable* CIecell; T{ valid CIGtkCellEditable T} h'-2m'CIRETURNS: T{ whether editing got aborted T}

Return whether editing was canceled (currently supported by GtkEntry and triggered by pressing Escape during editing).

CBgxk_cell_editable_is_focus_handler(CIecell); nokeep; l l l. CIGtkCellEditable* CIecell; T{ valid CIGtkCellEditable T} h'-2m'CIRETURNS: T{ returns FALSE T}

Call CBgtk_cell_editable_editing_done() if necessary and return FALSE. This function is meant to be used to handle "notify::is-focus" signals on CIGtkCellEditable widgets.

CBgxk_cell_renderer_popup_get_type(); nokeep; l l l. h'-2m'CIRETURNS: T{ GXK_TYPE_CELL_RENDERER_POPUP T}

CIGxkCellRendererPopup is an editable text cell renderer which supports popping up an auxillary window.

CBgxk_color_alloc(CIcolormap, CIcolor); nokeep; l l l. CIGdkColormap* CIcolormap; T{ valid CIGdkColormap T} CIGdkColor* CIcolor; T{ valid CIGdkColor T}

Allocate a color like CBgdk_color_alloc() with automated error checking.

CBgxk_dialog_action*(CIdialog, CIaction, CIcallback, CIdata); nokeep; l l l. CIdialog; T{ valid GxkDialog T} CIaction; T{ button label or stock ID T} CIcallback; T{ callback function for button activation T} CIdata; T{ callback data T}

Add a new (stock) button to a dialog.

CBgxk_dialog_add_flags(CIdialog, CIflags); nokeep; l l l. CIGxkDialog* CIdialog; T{ valid GxkDialog T} CIGxkDialogFlags CIflags; T{ additional flags to set on the dialog. T}

Alter dialog flags, see CBgxk_dialog_new().

CBgxk_dialog_clear_flags(CIdialog, CIflags); nokeep; l l l. CIGxkDialog* CIdialog; T{ valid GxkDialog T} CIGxkDialogFlags CIflags; T{ flags to unset on the dialog. T}

Alter dialog flags, see CBgxk_dialog_new().

CBgxk_dialog_get_child(CIdialog); nokeep; l l l. CIGxkDialog* CIdialog; T{ valid GxkDialog T}

Retrieve the primary child of the dialog.

CBgxk_dialog_get_status_window(); nokeep; l l l. h'-2m'CIRETURNS: T{ a valid GxkDialog or NULL T}

Retrieve the most recently entered GxkDialog if any.

CBgxk_dialog_new(CIpointer_loc, CIalive_object, CIflags, CItitle, CIchild); nokeep; l l l. CIgpointer CIpointer_loc; T{ pointer to nullify upon dialog destruction T} CIGtkObject* CIalive_object; T{ object which upon destruction, takes the dialog with it T} CIGxkDialogFlags CIflags; T{ dialog flags T} CIconst gchar* CItitle; T{ window title for the dialog T} CIGtkWidget* CIchild; T{ child to pack into the dialog T}

Create a new configurable dialog. Possible values for the flags are:

GXK_DIALOG_HIDE_ON_DELETE: only hide and not destroy the dialog upon window manager delete events;

GXK_DIALOG_IGNORE_ESCAPE: prevents delete event generation on Escape key presses;

GXK_DIALOG_DELETE_BUTTON: add a "Close" button to the dialog;

GXK_DIALOG_STATUS_BAR: add a status bar widget to the dialog;

GXK_DIALOG_WINDOW_GROUP: open up an extra window group for the dialog;

GXK_DIALOG_MODAL: the dialog is modal while visible;

GXK_DIALOG_POPUP_POS: popup the dialog below mouse pointer;

GXK_DIALOG_PRESERVE_STATE: prevents unrealization of the dialog upon hiding, which preserves properties like the window size.

CBgxk_dialog_remove_actions(CIdialog); nokeep; l l l. CIGxkDialog* CIdialog; T{ valid GxkDialog T}

Remove all action buttons setup for this dialog.

CBgxk_dialog_set_child(CIdialog, CIchild); nokeep; l l l. CIGxkDialog* CIdialog; T{ valid GxkDialog T} CIGtkWidget* CIchild; T{ new child T}

Change the dialog's primary child to CIchild. Destroys the old child if any.

CBgxk_dialog_set_default(CIself, CIdefault_widget); nokeep; l l l. CIGxkDialog* CIself; T{

T} CIGtkWidget* CIdefault_widget; T{ valid CIGtkWidget T}

This function is similar to CBgxk_dialog_set_focus(), it just affects the widget taking the default activation.

CBgxk_dialog_set_focus(CIself, CIfocus_widget); nokeep; l l l. CIGxkDialog* CIself; T{

T} CIGtkWidget* CIfocus_widget; T{ valid CIGtkWidget T}

A CIGxkDialog will automatically unset the focus everytime it is shown, unless CIfocus_widget is a valid widget that can be focused each time.

CBgxk_dialog_set_sizes(CIdialog, CImin_width, CImin_height, CIdefault_width, CIdefault_height); nokeep; l l l. CIGxkDialog* CIdialog; T{ valid GxkDialog T} CIgint CImin_width; T{ minimum dialog width or -1 T} CIgint CImin_height; T{ minimum dialog height or -1 T} CIgint CIdefault_width; T{ default dialog width or -1 T} CIgint CIdefault_height; T{ default dialog height or -1 T}

Set the dialog's minimum and default sizes, constrained to not exceed the screen dimensions.

CBgxk_dialog_set_title(CIdialog, CItitle); nokeep; l l l. CIGxkDialog* CIdialog; T{ valid GxkDialog T} CIconst gchar* CItitle; T{ dialog window manager title T}

Change the dialog's window manager title and role.

CBgxk_expander_connect_to_widget(CIexpander, CIwidget); nokeep; l l l. CIGtkWidget* CIexpander; T{ valid CIGtkWidget with boolean ::expanded property T} CIGtkWidget* CIwidget; T{ valid CIGtkWidget T}

Setup signal connections, so that the visibility of CIwidget is controlled by the ::expanded property of CIexpander.

CBgxk_file_selection_heal(CIfs); nokeep; l l l. CIGtkFileSelection* CIfs; T{ valid CIGtkFileSelection T} h'-2m'CIRETURNS: T{ new toplevel VBox of the file selection T}

Fixup various oddities that happened to the Gtk+ file selection widget over time. This function corrects container border widths, spacing, button placement and the default and focus widgets. Also, the lifetime of the file selection window is tied to the returned CIGtkVBox, enabling removal of the CIGtkVBox from it's parent and thus using the file selection widgets in a custom CIGtkWindow.

CBgxk_grab_pointer_and_keyboard(CIwindow, CIowner_events, CIevent_mask, CIconfine_to, CIcursor, CItime); nokeep; l l l. CIGdkWindow* CIwindow; T{ the window receiving the grab T} CIgboolean CIowner_events; T{ if TRUE, events will be reported relative to CIwindow T} CIGdkEventMask CIevent_mask; T{ mask of interesting events T} CIGdkWindow* CIconfine_to; T{ limits the pointer to the specified window T} CIGdkCursor* CIcursor; T{ cursor to use for the duration of the grab T} CIguint32 CItime; T{ event time when grab is requested T} h'-2m'CIRETURNS: T{ TRUE if pointer and keyboard could successfully be grabbed T}

This function grabs the pointer and keyboard simultaneously. This is recommended over plain pointer grabs, to reduce the risk of other applications (for instance the window manager) aborting the current grab and leaving the application in an invalid state.

CBgxk_idle_show_widget(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid CIGtkWidget T}

Defer showing this widget until the next idle handler is run. This is useful if other things are pending which need to be processed first, for instance hiding other toplevels.

CBgxk_idle_showraise(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid CIGtkWidget T}

Defers showing and raising this widget like CBgxk_widget_showraise() until the next idle handler is run. This is useful if other things are pending which need to be processed first, for instance hiding other toplevels or constructing remaining parts of the widget hierarchy.

CBgxk_idle_unrealize_widget(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid CIGtkWindow T}

Defer unrealizing this widget until the next idle handler is run. This is useful if other things are pending which need to be processed first, e.g. completing a running signal emission.

CBgxk_item_factory_get_item(CIifactory, CIpath); nokeep; l l l. CIGtkItemFactory* CIifactory; T{ valid CIGtkItemFactory T} CIconst gchar* CIpath; T{ item factory path T} h'-2m'CIRETURNS: T{ menu item according to CIpath T}

This function strips unescaped underlines ('_') from CIpath and then calls CBgtk_item_factory_get_item().

CBgxk_item_factory_get_widget(CIifactory, CIpath); nokeep; l l l. CIGtkItemFactory* CIifactory; T{ valid CIGtkItemFactory T} CIconst gchar* CIpath; T{ item factory path T} h'-2m'CIRETURNS: T{ widget according to CIpath T}

This function strips unescaped underlines ('_') from CIpath and then calls CBgtk_item_factory_get_widget().

CBgxk_item_factory_sensitize(CIifactory, CIpath, CIsensitive); nokeep; l l l. CIGtkItemFactory* CIifactory; T{ valid CIGtkItemFactory T} CIconst gchar* CIpath; T{ item factory path T} CIgboolean CIsensitive; T{ whether menu item should be sensitive T} h'-2m'CIRETURNS: T{ menu item according to CIpath T}

This function turns the menu item found via CBgxk_item_factory_get_item() (in-)sensitive according to CIsensitive. Additional checks are performed before making a menu item sensitive to avoid showing e.g. empty submenus.

CBgxk_label_set_attributes:(CIlabel, CI...); nokeep; l l l. CIlabel; T{ a CIGtkLabel T} CI...; T{ a list of PangoAttrType and value pairs terminated by -1. T}

Sets Pango attributes on a CIGtkLabel in a more convenient way than CBgtk_label_set_attributes(). This function is useful if you want to change the font attributes of a CIGtkLabel. This is an alternative to using PangoMarkup which is slow to parse and akward to handle in an i18n-friendly way. The attributes are set on the complete label, from start to end. If you need to set attributes on part of the label, you will have to use the PangoAttributes API directly. This function is based on CBgimp_label_set_attributes().

CBgxk_led_new(CIcolor); nokeep; l l l. CIguint CIcolor; T{ rgb color T}

Create a new led widget. It's active color can be specified as 24bit RGB CIcolor value.

CBgxk_led_set_color(CIself, CIcolor); nokeep; l l l. CIGxkLed* CIself; T{ valid GxkLed T} CIguint CIcolor; T{ color as RGB byte triple T}

Set the current led color as 24bit RGB values.

CBgxk_menu_attach_as_popup(CImenu, CIwidget); nokeep; l l l. CIGtkMenu* CImenu; T{ valid CIGtkMenu T} CIGtkWidget* CIwidget; T{

T}

This function is a replacement for CBgtk_menu_attach_to_widget(). Similar to CBgxk_menu_attach_as_submenu(), it sets up a propagation mechanism, so CImenu and submenus thereof automatically fetch their accelerator groups via CBgxk_window_get_menu_accel_group() from the toplevel window. In addition, this function allowes CBgxk_widget_find_level_ordered() to also consider popup menus in its search.

CBgxk_menu_attach_as_popup_with_func(CImenu, CIwidget, CImdfunc); nokeep; l l l. CIGtkMenu* CImenu; T{ valid CIGtkMenu T} CIGtkWidget* CIwidget; T{

T} CIGtkMenuDetachFunc CImdfunc; T{ a CIGtkMenuDetachFunc func as in CBgtk_menu_attach_to_widget() T}

Variant of CBgxk_menu_attach_as_popup() which preserves the CIGtkMenuDetachFunc.

CBgxk_menu_attach_as_submenu(CImenu, CImenu_item); nokeep; l l l. CIGtkMenu* CImenu; T{ valid CIGtkMenu T} CIGtkMenuItem* CImenu_item; T{ valid CIGtkMenuItem T}

This function is a replacement for CBgtk_menu_item_set_submenu(). It installs the necessary hooks on the CImenu to automatically update sensitivity of CImenu_item in response to children being deleted or added to the CImenu. The rationale behind this is to avoid empty submenus popups. Also, a propagation mechanism is set up, so CImenu and submenus thereof automatically fetch their accelerator groups via CBgxk_window_get_menu_accel_group() from the toplevel window.

CBgxk_menu_check_sensitive(CImenu); nokeep; l l l. CIGtkMenu* CImenu; T{ valid CIGtkMenu T} h'-2m'CIRETURNS: T{ TRUE if CImenu contains selectable items T}

This function tests whether a menu contains selectable menu items. It can be used to determine sensitivity for menu items containing submenus.

CBgxk_menu_set_active(CImenu, CIchild); nokeep; l l l. CIGtkMenu* CImenu; T{ valid CIGtkMenu T} CIGtkWidget* CIchild; T{ an immediate child of CImenu T}

This function replaces CBgtk_menu_set_active(). The CIchild to be set as last selection is passed in as ordinary child pointer and if the menu is attached to an option menu or menu button, the attach widget is updated after the selection changed, due to the emission of ::selection-done.

CBgxk_notebook_append(CInotebook, CIchild, CItab_text, CIfillexpand); nokeep; l l l. CIGtkNotebook* CInotebook; T{ a valid notebook T} CIGtkWidget* CIchild; T{ a valid parent-less widget T} CIconst gchar* CItab_text; T{

T} CIgboolean CIfillexpand; T{ whether the tab label should expand T}

Add a new page containing CIchild to CInotebook, naming the page CIlabel.

CBgxk_notebook_descendant_get_page(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} h'-2m'CIRETURNS: T{ notebook page widget or NULL T}

Find the innermost notebook page widget that contains CIwidget.

CBgxk_notebook_descendant_get_tab(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} h'-2m'CIRETURNS: T{ notebook page tab widget or NULL T}

Find the innermost notebook page widget that contains CIwidget and return its tabulator widget.

CBgxk_notebook_set_current_page_widget(CInotebook, CIpage); nokeep; l l l. CIGtkNotebook* CInotebook; T{ valid CIGtkNotebook T} CIGtkWidget* CIpage; T{ CInotebook page widget T}

Set the current notebook page from a page widget, instead of a page number.

CBgxk_option_menu_set_menu(CIoption_menu, CImenu); nokeep; l l l. CIGtkOptionMenu* CIoption_menu; T{ valid CIGtkOptionMenu T} CIGtkMenu* CImenu; T{ valid CIGtkMenu T}

This function is a replacement for CBgtk_option_menu_set_menu(). Similar to CBgxk_menu_attach_as_submenu(), it sets up a propagation mechanism, so CImenu and submenus thereof automatically fetch their accelerator groups via CBgxk_window_get_menu_accel_group() from the toplevel window.

CBgxk_polygon_new(CIpolygon_graph); nokeep; l l l. CIGxkPolygonGraph* CIpolygon_graph; T{ set of lines and arcs T}

Create a new polygon widget.

CBgxk_polygon_set_arcs(CIself, CIn_arcs, CIarcs); nokeep; l l l. CIGxkPolygon* CIself; T{ valid CIGxkPolygon T} CIguint CIn_arcs; T{ number of arcs T} CIGxkPolygonArc* CIarcs; T{ array of arcs T}

Set the arcs for this polygon. The direction of an arc determines it's shadow type.

CBgxk_polygon_set_graph(CIself, CIpolygon_graph); nokeep; l l l. CIGxkPolygon* CIself; T{ valid CIGxkPolygon T} CIGxkPolygonGraph* CIpolygon_graph; T{ set of lines and arcs T}

Set the lines and arcs for this polygon, see CBgxk_polygon_set_lines() and CBgxk_polygon_set_arcs().

CBgxk_polygon_set_length(CIself, CIlength); nokeep; l l l. CIGxkPolygon* CIself; T{ valid CIGxkPolygon T} CIguint CIlength; T{ set of lines and arcs T}

Set the desired width and height for this polygon to CIlength.

CBgxk_polygon_set_lines(CIself, CIn_lines, CIlines); nokeep; l l l. CIGxkPolygon* CIself; T{ valid CIGxkPolygon T} CIguint CIn_lines; T{ number of lines T} CIGxkPolygonLine* CIlines; T{ array of lines T}

Set the lines for this polygon. The direction of a line determines it's shadow type.

CBgxk_proxy_editable_get_type(); nokeep; l l l. h'-2m'CIRETURNS: T{ GXK_TYPE_PROXY_EDITABLE T}

CIGxkProxyEditable is a CIGtkEventBox which proxies the CIGtkCellEditable interface onto a backend widget which also implements the CIGtkCellEditable interface.

CBgxk_proxy_editable_set_cell_editable(CIself, CIecell); nokeep; l l l. CIGxkProxyEditable* CIself; T{ valid CIGxkProxyEditable T} CIGtkCellEditable* CIecell; T{ valid CIGtkCellEditable T}

Set the backend CIecell onto which CIGtkCellEditable methods issued on CIself are to be forwarded. This function may only be called once per CIGxkProxyEditable.

CBgxk_scroll_text_advance(CIsctext, CIuri); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIuri; T{ resource locator T}

Relative to the url currently being displayed load and display the possibly partial (relative) url CIuri. Navigation history is affected.

CBgxk_scroll_text_append(CIsctext, CIstring); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIstring; T{ the text to be displayed T}

Append CIstring to the textual contents of this CIsctext.

CBgxk_scroll_text_append_file(CIsctext, CIfile_name); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIfile_name; T{ file holding the text to be displayed T}

Append the contents of CIfile_name to the textual contents of this CIsctext.

CBgxk_scroll_text_append_file_tsm(CIsctext, CIfile_name); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIfile_name; T{ file holding the text to be displayed in tag-span-markup T}

Append the contents of CIfile_name to the textual contents of this CIsctext, where those contents are marked up with tag-span-markup.

CBgxk_scroll_text_append_tsm(CIsctext, CIstring); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIstring; T{ the text to be displayed in tag-span-markup T}

Append CIstring to the textual contents of this CIsctext, where CIstring is marked up with tag-span-markup.

CBgxk_scroll_text_aprintf(CIsctext, CItext_fmt); nokeep; l l l. CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CItext_fmt; T{ CBprintf(3) style format string T}

Append CItext_fmt to the textual contents of this CIsctext.

CBgxk_scroll_text_clear(CIsctext); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T}

Clear the textual contents of this CIsctext and reset the indentation level.

CBgxk_scroll_text_create(CIflags, CIstring); nokeep; l l l. CIGxkScrollTextFlags CIflags; T{

T} CIconst gchar* CIstring; T{ default contents T}

Create a scrollable text view. Behaviour and apperance can

GXK_SCROLL_TEXT_MONO - use a fixed width font;

GXK_SCROLL_TEXT_SANS - use a sans serif font;

GXK_SCROLL_TEXT_SERIF - use a serif font;

GXK_SCROLL_TEXT_WRAP - allow word wrapping of CIstring;

GXK_SCROLL_TEXT_CENTER - center CIstring;

GXK_SCROLL_TEXT_WIDGET_BG - do not use white as background, but keep the usual (grey) widget background;

GXK_SCROLL_TEXT_NAVIGATABLE - add a navigation bar and allow the user to navigate through clickable links;

GXK_SCROLL_TEXT_EDITABLE - permit modifications of the text;

GXK_SCROLL_TEXT_HFIXED - make horizontal dimension unscrollable

GXK_SCROLL_TEXT_VFIXED - make vertical dimension unscrollable

GXK_SCROLL_TEXT_WIDGET_LOOK - this is a combination of flags to adjust the scroll text to look like an ordinary CIGtkLabel, which amounts to using a sans serif font, normal widget background and allowing word wrapping.

CBgxk_scroll_text_display(CIsctext, CIuri); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIuri; T{ resource locator T}

Load and display the resource from CIuri without altering the navigation history.

CBgxk_scroll_text_enter(CIsctext, CIuri); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIuri; T{ resource locator T}

Load and display the url CIuri. Navigation history is affected.

CBgxk_scroll_text_get_text_view(CIsctext); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} h'-2m'CIRETURNS: T{ a GtkTextView widget T}

Return the internally used GtkTextView of this CIsctext.

CBgxk_scroll_text_pop_indent(CIsctext); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T}

Decrement the global indentation level after a previous increment with CBgxk_scroll_text_push_indent().

CBgxk_scroll_text_push_indent(CIsctext); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T}

Increment the global indentation level, which affects overall indentation of text added with CBgxk_scroll_text_append() and friends.

CBgxk_scroll_text_rewind(CIsctext); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T}

Go back in navigation history as far as possible.

CBgxk_scroll_text_set(CIsctext, CIstring); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIstring; T{ the new text to be displayed T}

Replace the textual contents of this CIsctext with CIstring.

CBgxk_scroll_text_set_index(CIsctext, CIuri); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIuri; T{ resource locator T}

Affect what uri is being displayed by pressing on the "Index" navigation button.

CBgxk_scroll_text_set_tsm(CIsctext, CIstring); nokeep; l l l. CIGtkWidget* CIsctext; T{ a scroll text widget as returned from CBgxk_scroll_text_create() T} CIconst gchar* CIstring; T{ the new text to be displayed in tag-span-markup T}

Replace the textual contents of this CIsctext with CIstring, where CIstring is marked up with tag-span-markup.

CBgxk_scrolled_window_create(CIchild, CIshadow_type, CIxrequest, CIyrequest); nokeep; l l l. CIGtkWidget* CIchild; T{ valid CIGtkWidget T} CIGtkShadowType CIshadow_type; T{ shadow around the CIGtkViewport T} CIgdouble CIxrequest; T{ fractional factor for screen width T} CIgdouble CIyrequest; T{ fractional factor for screen height T} h'-2m'CIRETURNS: T{ the newly created CIGtkScrolledWindow T}

Create a CIGtkScrolledWindow with a CIGtkViewport as parent of CIchild. The CIxrequest and CIyrequest arguments are passed on to CBgxk_widget_proxy_requisition().

CBgxk_scrolled_window_spare_space(CIscwin); nokeep; l l l. CIGtkScrolledWindow* CIscwin; T{ valid CIGtkScrolledWindow T}

A normal CIGtkScrolledWindow requests extra space for a horizontal scrollbar if the vertical scroll policy is set to GTK_POLICY_NEVER and vice versa, regardless of whether the scrollbars have to be shown or not. This function patches up this behaviour to spare the extra requested space from the outer scrolled window requisition if possible (that is, if the corresponding scrollbar is not currently visible).

CBgxk_scrolled_window_unspare_space(CIscwin); nokeep; l l l. CIGtkScrolledWindow* CIscwin; T{ valid CIGtkScrolledWindow T}

Undo the effect of a call to CBgxk_scrolled_window_spare_space().

CBgxk_signal_handler_exists(CIinstance, CIdetailed_signal, CIcallback, CIdata); nokeep; l l l. CIgpointer CIinstance; T{ object instance with signals T} CIconst gchar* CIdetailed_signal; T{ signal name T} CIGCallback CIcallback; T{ custom callback function T} CIgpointer CIdata; T{ callback data T} h'-2m'CIRETURNS: T{ whether callback is connected T}

Find out whether a specific CIcallback is connected to a specific signal on an instance, the callback may be blocked. CIdetailed_signal may be NULL to act as a wildcard. TRUE is returned if the CIcallback is found, FALSE otherwise.

CBgxk_signal_handler_pending(CIinstance, CIdetailed_signal, CIcallback, CIdata); nokeep; l l l. CIgpointer CIinstance; T{ object instance with signals T} CIconst gchar* CIdetailed_signal; T{ signal name T} CIGCallback CIcallback; T{ custom callback function T} CIgpointer CIdata; T{ callback data T} h'-2m'CIRETURNS: T{ whether callback is connected T}

Find out whether a specific CIcallback is pending (connected and unblocked) for a specific signal on an instance. CIdetailed_signal may be NULL to act as a wildcard. TRUE is returned if the CIcallback is found, FALSE otherwise.

CBgxk_size_group(CIsgmode, CI...); nokeep; l l l. CIsgmode; T{ size group mode, one of GTK_SIZE_GROUP_NONE, T} CI...; T{ NULL terminated list of widgets to group together T}

GTK_SIZE_GROUP_HORIZONTAL, GTK_SIZE_GROUP_VERTICAL or GTK_SIZE_GROUP_BOTH Group horizontal and/or vertical resizing behaviour of widgets. See CBgtk_size_group_set_mode() on the effect of the various grouping modes.

CBgxk_size_height(CIicon_size); nokeep; l l l. CIGtkIconSize CIicon_size; T{ image size id T} h'-2m'CIRETURNS: T{ image size height T}

Return the height of a specific image size.

CBgxk_size_width(CIicon_size); nokeep; l l l. CIGtkIconSize CIicon_size; T{ image size id T} h'-2m'CIRETURNS: T{ image size width T}

Return the width of a specific image size.

CBgxk_spline_copy(CIspline); nokeep; l l l. CIGxkSpline* CIspline; T{ correctly setup CIGxkSpline T} h'-2m'CIRETURNS: T{ newly allocated spline T}

Produce a copy of an already setup spline.

CBgxk_spline_dump(CIspline); nokeep; l l l. CIGxkSpline* CIspline; T{ correctly setup CIGxkSpline T}

Produce a debugging printout of CIspline on stderr.

CBgxk_spline_eval(CIspline, CIx, CIyd1); nokeep; l l l. CIconst GxkSpline* CIspline; T{ correctly setup CIGxkSpline T} CIdouble CIx; T{ x position for evaluation T} CIdouble* CIyd1; T{

T} h'-2m'CIRETURNS: T{ y of CIspline at position x T}

Evaluate the CIspline polynomial at position CIx and return the interpolated value y, as well as its first derivative.

CBgxk_spline_findx(CIspline, CIy); nokeep; l l l. CIconst GxkSpline* CIspline; T{ correctly setup CIGxkSpline T} CIdouble CIy; T{ interpolated y value T} h'-2m'CIRETURNS: T{ x position to yield y or NAN T}

Find an x position for which spline evaluation yields y. Due to round off, calling CBgxk_spline_y() on the result may produce a number equal to y only within a certain epsilon. If multiple x positions will yield y upon evaluation, any of them may be returned. If no x position can yield y, NAN is returned. Evaluation of this function may take about 10 times as long as calling its counterpart CBgxk_spline_y(), some times much longer.

CBgxk_spline_free(CIspline); nokeep; l l l. CIGxkSpline* CIspline; T{ correctly setup CIGxkSpline T}

Free a CIspline structure.

CBgxk_spline_new(CIn_points, CIpoints, CIdy_start, CIdy_end); nokeep; l l l. CIguint CIn_points; T{ number of fix points T} CIconst GxkSplinePoint* CIpoints; T{ fix points T} CIdouble CIdy_start; T{ first derivatives at point[0] T} CIdouble CIdy_end; T{ first derivatives at point[n_points - 1] T} h'-2m'CIRETURNS: T{ newly allocated spline T}

Create a not-a-knot spline based on a given set of fix points and the first derivative of the first and last point of the interpolating function.

CBgxk_spline_new_natural(CIn_points, CIpoints); nokeep; l l l. CIguint CIn_points; T{ number of fix points T} CIconst GxkSplinePoint* CIpoints; T{ fix points T} h'-2m'CIRETURNS: T{ newly allocated spline T}

Create a natural spline based on a given set of fix points.

CBgxk_spline_y(CIspline, CIx); nokeep; l l l. CIconst GxkSpline* CIspline; T{ correctly setup CIGxkSpline T} CIdouble CIx; T{ x position for evaluation T} h'-2m'CIRETURNS: T{ y of CIspline at position x T}

Evaluate the CIspline polynomial at position CIx and return the interpolated value y.

CBgxk_status_bar_create(); nokeep; l l l. h'-2m'CIRETURNS: T{ status bar container T}

Create a status bar suitable to be packed into windows with status bar support.

CBgxk_status_clear(); Clear the current status bar.

CBgxk_status_errnoprintf(CIlibc_errno, CImessage_fmt); nokeep; l l l. CIlibc_errno; T{ errno value T} CImessage_fmt; T{ printf style message to be displayed T}

Similar to CBgxk_status_printf() but figures the error status automatically from the passed in CIlibc_errno.

CBgxk_status_printf(CIpercentage, CIstatus_msg, CImessage_fmt); nokeep; l l l. CIpercentage; T{ progress percentage T} CIstatus_msg; T{ error status T} CImessage_fmt; T{ printf style message to be displayed T}

Similar to CBgxk_status_set() but supports construction of the message through a CBprintf(3) style argument list.

CBgxk_status_set(CIpercentage, CImessage, CIstatus_msg); nokeep; l l l. CIgfloat CIpercentage; T{ progress percentage T} CIconst gchar* CImessage; T{ message to be displayed T} CIconst gchar* CIstatus_msg; T{ error status T}

Set the current status bar message, progress percentage (usually 0% - 100% or one of the special values: GXK_STATUS_ERROR, GXK_STATUS_WAIT, GXK_STATUS_IDLE, GXK_STATUS_IDLE_HINT or GXK_STATUS_PROGRESS) and error status.

CBgxk_status_window_pop(); Pop the most recently pushed window from the status bar window stack.

CBgxk_status_window_push(CIwidget); nokeep; l l l. CIgpointer CIwidget; T{ status bar window T}

Push a window onto the stack of windows that have the current status bar.

CBgxk_stock_button(CIstock_id, CIlabel); nokeep; l l l. CIconst gchar* CIstock_id; T{ stock name T} CIconst gchar* CIlabel; T{ button text T} h'-2m'CIRETURNS: T{ a visible GtkButton widget T}

Create a GtkButton widget with a stock image and custom label text.

CBgxk_stock_button_child(CIstock_id, CIlabel); nokeep; l l l. CIconst gchar* CIstock_id; T{ stock name T} CIconst gchar* CIlabel; T{ button text T} h'-2m'CIRETURNS: T{ a visible widget suitable as GtkButton child T}

This function does the same as CBgxk_stock_button() except for creating the actual button. The button's child is instead returned to the caller, this might e.g. be useful if a button is created containing multiple children which are shown only selectively during runtime.

CBgxk_stock_fallback_pixbuf(CIstock_id); nokeep; l l l. CIconst gchar* CIstock_id; T{ stock name T} h'-2m'CIRETURNS: T{ this CIstock_id's pixbuf (or NULL for invalid stock ids) T}

Return the pixbuf associated with CIstock_id, the pixbuf is owned by the stock system and persists throughout runtime. To display stock icons in widgets use CBgxk_stock_image() and not this pixbuf.

CBgxk_stock_icon_window(CIstock_id); nokeep; l l l. CIconst gchar* CIstock_id; T{ a valid stock icon name T} h'-2m'CIRETURNS: T{ a window showing the stock icon T}

Create a window displaying a stock icon which is transparent according to the icon's alpha mask. Such windows are mostly useful to implement drag-and-drop operations with stock icons.

CBgxk_stock_image(CIstock_icon_id, CIicon_size); nokeep; l l l. CIconst gchar* CIstock_icon_id; T{ stock name T} CIGtkIconSize CIicon_size; T{ image size T} h'-2m'CIRETURNS: T{ a visible GtkImage widget or NULL T}

Create a GtkImage widget with a stock image of a certain size, or return NULL if the image doesn't exist. The returned image widget correctly displays the stock icon, honouring prelight and sensitivity state of the widget.

CBgxk_stock_register_icon(CIicon); nokeep; l l l. CIconst GxkStockIcon* CIicon; T{ a validly filled out GxkStockIcon T}

Register a new stock icon from an inlined pixbuf. The inlined pixbuf pixels are not copied, so the caller must make sure for the data to remain valid.

CBgxk_stock_register_icons(CIn_icons, CIicons); nokeep; l l l. CIguint CIn_icons; T{ number of icons to register T} CIconst GxkStockIcon* CIicons; T{ a validly filled out array of GxkStockIcon T}

For all CIn_icons contained in CIicons, call CBgxk_stock_register_icon().

CBgxk_stock_register_item(CIitem); nokeep; l l l. CIconst GxkStockItem* CIitem; T{ a validly filled out GxkStockItem T}

Register a new stock item. The new stock item CIitem->stock_id is registered with an item label of CIitem->label and the stock icon CIitem->stock_fallback. If CIitem->label is NULL, CIitem->stock_fallback must not be NULL, and CIitem->stock_id becomes merely an alias of CIitem->stock_fallback.

CBgxk_stock_register_items(CIn_items, CIitems); nokeep; l l l. CIguint CIn_items; T{ number of items to register T} CIconst GxkStockItem* CIitems; T{ a validly filled out array of GxkStockItem T}

For all CIn_items contained in CIitems, call CBgxk_stock_register_item().

CBgxk_text_view_cursor_to_end(CItview); nokeep; l l l. CIGtkTextView* CItview; T{ a GtkTextView object T}

Move the insertion and selection bound mark to the end of the text view's buffer and keep the cursor on screen.

CBgxk_text_view_cursor_to_start(CItview); nokeep; l l l. CIGtkTextView* CItview; T{ a GtkTextView object T}

Move the insertion and selection bound mark to the start of the text view's buffer and keep the cursor on screen.

CBgxk_text_view_enter_browse_mode(CItview); nokeep; l l l. CIGtkTextView* CItview; T{ a GtkTextView object T}

Install key press handlers on a text view which allow scrolling its contents into any direction.

CBgxk_text_view_leave_browse_mode(CItview); nokeep; l l l. CIGtkTextView* CItview; T{ a GtkTextView object T}

Deinstall key press handlers previously installed with CBgxk_text_view_enter_browse_mode().

CBgxk_toplevel_activate_default(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a widget having a toplevel T}

Activate the default widget of the toplevel of CIwidget.

CBgxk_toplevel_delete(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a widget having a toplevel T}

This function is useful to produce the an effect similar to user caused window manager triggered window deletion on the toplevel of CIwidget. Note that this function will cause window deletion despite any grabs in effect however.

CBgxk_toplevel_hide(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a widget having a toplevel T}

Hide the toplevel of CIwidget.

CBgxk_tree_model_get_iter(CItree_model, CIiter, CIpath); nokeep; l l l. CIGtkTreeModel* CItree_model; T{

T} CIGtkTreeIter* CIiter; T{

T} CIGtkTreePath* CIpath; T{

T}

This function is a replacement for CBgtk_tree_model_get_iter() for Gtk+-2.4. For sort models, CBgtk_tree_model_get_iter() can erroneously return TRUE which is corrected by calling this function instead.

CBgxk_tree_path_prev(CIpath); nokeep; l l l. CIGtkTreePath* CIpath; T{ valid CIGtkTreePath T}

Workaround for CBgtk_tree_path_prev() which corrupts memory if called on empty paths (up to version Gtk+-2.4 at least).

CBgxk_tree_selection_force_browse(CIselection, CImodel); nokeep; l l l. CIGtkTreeSelection* CIselection; T{ GtkTreeSelection to watch T} CIGtkTreeModel* CImodel; T{ tree model used with CIselection T}

Watch deletion and insertions into empty trees to ensure valid selections across these events.

CBgxk_tree_selection_select_ipath(CIselection, CI...); nokeep; l l l. CIselection; T{ GtkTreeSelection to modify T} CI...; T{ GtkTreePath indices T}

Select the row denoted by the path to be constructed from the -1 terminated indices.

CBgxk_tree_selection_select_spath(CIselection, CIstr_path); nokeep; l l l. CIGtkTreeSelection* CIselection; T{ GtkTreeSelection to modify T} CIconst gchar* CIstr_path; T{ a stringified GtkTreePath T}

Select the row denoted by CIstr_path.

CBgxk_tree_selection_unselect_ipath(CIselection, CI...); nokeep; l l l. CIselection; T{ GtkTreeSelection to modify T} CI...; T{ GtkTreePath indices T}

Select the row denoted by the path to be constructed from the -1 terminated indices.

CBgxk_tree_selection_unselect_spath(CIselection, CIstr_path); nokeep; l l l. CIGtkTreeSelection* CIselection; T{ GtkTreeSelection to modify T} CIconst gchar* CIstr_path; T{ a stringified GtkTreePath T}

Unselect the row denoted by CIstr_path.

CBgxk_tree_spath_index0(CIstrpath); nokeep; l l l. CIconst gchar* CIstrpath; T{ stringified CIGtkTreePath T}

Return index[0] of CIstrpath. Useful for paths in lists, where index[0] usually corresponds to the nth row.

CBgxk_tree_view_add_column(CItree_view, CIposition, CIcolumn, CIcell, CI...); nokeep; l l l. CItree_view; T{ valid CIGtkTreeView T} CIposition; T{ column position (or -1 to append) T} CIcolumn; T{ valid CIGtkTreeViewColumn T} CIcell; T{ valid CIGtkCellRenderer T} CI...; T{ attribute mappings T}

Appends CIcell to CIcolumn and adds CIcolumn to CItree_view at the specified CIposition. This function takes a NULL-terminated list of attribute mappings consisting of a string and a guint, mapping cell attributes to model columns as documented in CBgtk_tree_view_column_add_attribute().

CBgxk_tree_view_add_popup_column(CItree_view, CImodel_column, CIcolumn_flags, CIxalign, CItitle, CItooltip, CIedited_callback, CIpopup_callback, CIdata, CIcflags); nokeep; l l l. CIGtkTreeView* CItree_view; T{ valid CIGtkTreeView T} CIguint CImodel_column; T{ model column T} CIconst gchar* CIcolumn_flags; T{

T} CIgdouble CIxalign; T{ horizontal text alignment T} CIconst gchar* CItitle; T{ column title T} CIconst gchar* CItooltip; T{ column tooltip T} CIgpointer CIedited_callback; T{ edit notification callback T} CIgpointer CIpopup_callback; T{ popup notification callback T} CIgpointer CIdata; T{ data passed in to toggled_callback T} CIGConnectFlags CIcflags; T{ connection flags T} h'-2m'CIRETURNS: T{ a newly added CIGtkTreeViewColumn T}

Add a text column with popup facility, similar to CBgxk_tree_view_add_text_column(). This function takes an additional argument CIpopup_callback() which is called when the user clicks on the cells "popup" button.

CBgxk_tree_view_add_text_column(CItree_view, CImodel_column, CIcolumn_flags, CIxalign, CItitle, CItooltip, CIedited_callback, CIdata, CIcflags); nokeep; l l l. CIGtkTreeView* CItree_view; T{ valid CIGtkTreeView T} CIguint CImodel_column; T{ model column T} CIconst gchar* CIcolumn_flags; T{ column flags T} CIgdouble CIxalign; T{ horizontal text alignment T} CIconst gchar* CItitle; T{ column title T} CIconst gchar* CItooltip; T{ column tooltip T} CIgpointer CIedited_callback; T{ notification callback T} CIgpointer CIdata; T{ data passed in to toggled_callback T} CIGConnectFlags CIcflags; T{ connection flags T} h'-2m'CIRETURNS: T{ a newly added CIGtkTreeViewColumn T}

Add a new column with text cell to a CItree_view. The CImodel_column indicates the column number of the tree model containing the text to be displayed, the CIcolumn_flags toggle specific column characteristics (see CBgxk_tree_view_append_text_columns() for details) and CIxalign controls the horizontal cell alignment (between 0 and 1). If non-NULL, CIedited_callback(CIdata) is connected with CIcflags (see CBg_signal_connect_data()) to the "::edited" signal of the text cell and the cell is made editable.

CBgxk_tree_view_add_toggle_column(CItree_view, CImodel_column, CIcolumn_flags, CIxalign, CItitle, CItooltip, CItoggled_callback, CIdata, CIcflags); nokeep; l l l. CIGtkTreeView* CItree_view; T{ valid CIGtkTreeView T} CIguint CImodel_column; T{ model column T} CIconst gchar* CIcolumn_flags; T{

T} CIgdouble CIxalign; T{ horizontal text alignment T} CIconst gchar* CItitle; T{ column title T} CIconst gchar* CItooltip; T{ column tooltip T} CIgpointer CItoggled_callback; T{ notification callback T} CIgpointer CIdata; T{ data passed in to toggled_callback T} CIGConnectFlags CIcflags; T{ connection flags T} h'-2m'CIRETURNS: T{ a newly added CIGtkTreeViewColumn T}

Add a toggle button column, similar to CBgxk_tree_view_add_text_column(), however the model column is expected to be of type G_TYPE_BOOLEAN, and instead of an CIedited_callback(), this function has a void CItoggled_callback(CIGtkCellRendererToggle*, const gchar *strpath, CIdata) callback which is connected to the "toggled" signal of the new cell.

CBgxk_tree_view_append_text_columns(CItree_view, CIn_cols, CI...); nokeep; l l l. CItree_view; T{ valid CIGtkTreeView T} CIn_cols; T{ number of columns to append T} CI...; T{ column arguments T}

Add CIn_cols new columns with text cells to CItree_view (a short hand version for multiple calls to CBgxk_tree_view_add_text_column()). Per column, the caller needs to supply a CIguint, a string, a CIgdouble and another string. The Arguments are used as model column number (for the text to be displayed), the column specific flags, the horizontal cell alignment (between 0 and 1) and the column title respectively. The CIcolumn_flags argument is a combination of letters that are able to switch certain characteristics on or of, currently supported are:

F - column is fixed in sizing;

A - column resizes automatically;

G - columns sizing behaviour is grow only;

S - column is sortable;

s - column is unsortable;

O - column is reorderable;

o - column is not reorderable;

R - column is user-resizable;

r - column is not user-resizable;

P - add extra padding between multiple cells of the same column;

p - cancel a previous P flag;

%# - automatically popup dialogs for popup cell renderers.

CBgxk_tree_view_column_set_tip_title(CItree_column, CItitle, CItooltip); nokeep; l l l. CIGtkTreeViewColumn* CItree_column; T{ valid CIGtkTreeViewColumn T} CIconst gchar* CItitle; T{ column title T} CIconst gchar* CItooltip; T{ column tooltip T}

Set a tree view column title and its tooltip. This is a bug workaroud for missing tree view column API to set tooltips, so the column title or column title widget shouldn't be changed after calling this function.

CBgxk_tree_view_focus_row(CItree, CIrow); nokeep; l l l. CIGtkTreeView* CItree; T{ valid CIGtkTreeView T} CIgint CIrow; T{ row to focus T}

Force focus to CIrow, causes automatic selection of CIrow in browse mode.

CBgxk_tree_view_get_bin_window_pos(CItree, CIx_p, CIy_p); nokeep; l l l. CIGtkTreeView* CItree; T{ valid CIGtkTreeView T} CIgint* CIx_p; T{ x position T} CIgint* CIy_p; T{ y position T}

Retrieve the position of the bin window (row display area) of a CIGtkTreeView widget once it's realized.

CBgxk_tree_view_get_row_area(CItree, CIrow, CIy_p, CIheight_p, CIcontent_area); nokeep; l l l. CIGtkTreeView* CItree; T{ valid CIGtkTreeView T} CIgint CIrow; T{ row to retrieve area coordinates for T} CIgint* CIy_p; T{ y position of CIrow T} CIgint* CIheight_p; T{ height of CIrow T} CIgboolean CIcontent_area; T{ whether the cell background area or content area is returned T}

Retrieve the position and height of a row of a CIGtkTreeView widget within its bin window.

CBgxk_tree_view_get_row_from_coord(CItree, CIy, CIrow_p); nokeep; l l l. CIGtkTreeView* CItree; T{ valid CIGtkTreeView T} CIgint CIy; T{ bin window y coordinate T} CIgint* CIrow_p; T{ row pointed to by CIy T} h'-2m'CIRETURNS: T{ whether y lies within the visible area T}

Retrieve the row within which CIy lies. If CIy lies outside the visible area, the row is clamped to visible rows.

CBgxk_tree_view_get_selected_row(CItree); nokeep; l l l. CIGtkTreeView* CItree; T{ valid CIGtkTreeView T} h'-2m'CIRETURNS: T{ first selected row or -1 T}

Retrieve the selected row in browse mode (for other selection modes, return the first selected row if any).

CBgxk_tree_view_is_row_selected(CItree, CIrow); nokeep; l l l. CIGtkTreeView* CItree; T{ valid CIGtkTreeView T} CIgint CIrow; T{ row to test T} h'-2m'CIRETURNS: T{ whether CIrow is selected T}

Check whether CIrow in CItree is selected.

CBgxk_type_register_generated(CIn_entries, CIentries); nokeep; l l l. CIguint CIn_entries; T{ number of generated types to register T} CIconst GxkTypeGenerated* CIentries; T{ GxkTypeGenerated type descriptions T}

Register each of the generated type entries with the type system. Currently supported parent types are G_TYPE_ENUM and G_TYPE_FLAGS in which cases the CItype_data member must point to a NULL terminated array of GEnumValue or GFlagValue structures. No extra copying is performed, so the passed in structures have to persist throughout runtime.

CBgxk_ungrab_pointer_and_keyboard(CIwindow, CItime); nokeep; l l l. CIGdkWindow* CIwindow; T{ window pointer was previously grabed on T} CIguint32 CItime; T{

T}

This function releases a pointer and keyboard grab acquired through CBgxk_grab_pointer_and_keyboard(). The CIwindow is used to release grabs on the correct display, see CBgdk_display_pointer_ungrab() and CBgdk_display_keyboard_ungrab() on this.

CBgxk_vseparator_space_new(CIdraw_seperator); nokeep; l l l. CIgboolean CIdraw_seperator; T{ enable visible vertical seperator T} h'-2m'CIRETURNS: T{ visible vertical space/seperator widget T}

Create a vertical seperator widget. CIdraw_seperator indicates whether the seperator should be amount to simple space or not.

CBgxk_widget_activate_accel_group(CIwidget, CIaccel_group); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid CIGtkWidget T} CIGtkAccelGroup* CIaccel_group; T{ a valid CIGtkAccelGroup T}

Activate accelerators within accel group when CIwidget receives key press events. This function isn't pure convenience, as it works around Gtk+-2.2 not exporting _CBgtk_accel_group_activate(), _CBgtk_accel_group_attach() or _CBgtk_accel_group_detach().

CBgxk_widget_add_font_requisition(CIwidget, CIn_chars, CIn_digits); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} CIguint CIn_chars; T{ number of characters to request space for T} CIguint CIn_digits; T{ number of digits to request space for T}

This function adds up extra space to the widget size requisition. The space is an approximation of the space required by CIn_chars characters and CIn_digits digits written with the widgets font.

CBgxk_widget_add_option(CIwidget, CIoption, CIvalue); nokeep; l l l. CIgpointer CIwidget; T{ valid CIGtkWidget T} CIconst gchar* CIoption; T{ option to add to widget T} CIconst gchar* CIvalue; T{ value of CIoption (currently just "+" and "-" are supported) T}

Add/set a custom CIoption of CIwidget to a particular CIvalue. Custom options on widgets are used to attach extra information to widgets which may be useful to otherwise disjoint code portions. The actual options are implemented by means of CBg_option_concat(), CBg_option_check() and CBg_option_get().

CBgxk_widget_ancestry_viewable(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T} h'-2m'CIRETURNS: T{ whether CIwidget is visible on screen T}

Checks for CIwidget to be effectively visible on screen. This function works around a bug in Gtk+ versions <= 2.4.10, with newer Gtk+ versions, (CBgdk_window_is_viewable(widget->window) && CBGTK_WIDGET_DRAWABLE(widget)) is a suitable replacement.

CBgxk_widget_attached_hierarchy_changed(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T}

Setting or unsetting a parent on a widget leads to emission of the ::hirarchy-changed signal on the widget and any children it contains. However, popup menus which are merely attached to widgets aren't properly notified upon such hirarchy changes, for this CBgxk_widget_attached_hierarchy_changed() is provided. On menus which got attached to a widget with CBgxk_menu_attach_as_popup(), the signal ::attached-hirarchy-changed is emitted if ::hirarchy-changed is emitted on the widget, by calling CBgxk_widget_attached_hierarchy_changed() on the menu.

CBgxk_widget_check_option(CIwidget, CIoption); nokeep; l l l. CIgpointer CIwidget; T{ valid CIGtkWidget T} CIconst gchar* CIoption; T{ option to check for T} h'-2m'CIRETURNS: T{ whether CIoption is set T}

Test whether the custom CIoption is set on CIwidget.

CBgxk_widget_find_level_ordered(CItoplevel, CIname); nokeep; l l l. CIGtkWidget* CItoplevel; T{ valid CIGtkWidget T} CIconst gchar* CIname; T{ name of the widget being looked for T} h'-2m'CIRETURNS: T{ a widget named CIname or NULL T}

Search for a widget named CIname, child of CItoplevel. The search is ordered by looking at all children of a container before increasing depth. This function also considers submenus in menu items "children", as well as popup menus attached via CBgxk_menu_attach_as_popup() (not ones attached via CBgtk_menu_attach_to_widget() though, since Gtk+ doesn't store/export the neccessary information).

CBgxk_widget_force_bg_clear(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

Enforce drawing of a widget's background. Some widgets do not explicitely draw their background, but simply draw themsleves on top of their parent's background. This function forces the widget into drawing its background according to its style settings.

CBgxk_widget_get_attach_toplevel(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T}

This function returns the topmost container widget for CIwidget, much like CBgtk_widget_get_toplevel(). The only difference is that for menus, not the immediate parent is returned (the CIGtkWindow used to display a menu) but the tree walk continues on the menu item using the menu as submenu. For example, for a window containing a menubar with submenus, CBgtk_widget_get_toplevel() invoked on one of the menu items will return the CIGtkWindow widgets for the corresponding submenus, while CBgxk_widget_get_attach_toplevel() will return the actual CIGtkWindow containing the menubar.

CBgxk_widget_get_latent_tooltip(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

Retrieve the latent tooltip for CIwidget. See CBgxk_widget_set_latent_tooltip() for the purpose of latent tooltips.

CBgxk_widget_get_options(CIwidget); nokeep; l l l. CIgpointer CIwidget; T{ valid CIGtkWidget T} h'-2m'CIRETURNS: T{ custom options set on the widget T}

This function returns the set of custom options currently set on the widget.

CBgxk_widget_has_ancestor(CIwidget, CIancestor); nokeep; l l l. CIgpointer CIwidget; T{ valid CIGtkWidget T} CIgpointer CIancestor; T{ valid CIGtkWidget T} h'-2m'CIRETURNS: T{ whether CIancestor is ancestor of CIwidget T}

This function checks whether CIwidget and CIancestor are equal, or whether CIancestor is an ancestor of CIwidget, in the same way CBgtk_widget_is_ancestor() tests it.

CBgxk_widget_make_insensitive(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

This function is euqivalent to gtk_widget_set_sensitive (CIwidget, CIFALSE); It exists as a convenient signal connection callback.

CBgxk_widget_make_sensitive(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

This function is euqivalent to gtk_widget_set_sensitive (CIwidget, CITRUE); It exists as a convenient signal connection callback.

CBgxk_widget_modify_as_title(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

Modify the widget and it's style, so that it is insensitive, but doesn't quite look that way. Useful for inactive title menu items in menus (CIwidget should be the menu item's label).

CBgxk_widget_modify_base_as_bg(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

Modify the widget's base background (used by list and text widgets) to look like an ordinary widget background. This is useful if a list, text or similar widget shouldn't stand out as such, e.g. when the GtkTextView widget displaying a long non-editable text should look similar to a GtkLabel.

CBgxk_widget_modify_bg_as_active(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

Modify the widget's background to look like the background of depressed button.

CBgxk_widget_modify_bg_as_base(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

Modify the widget's background to look like the background of a text or list widget (usually white). This is useful if a hbox or similar widget is used to "simulate" a list or text widget.

CBgxk_widget_modify_normal_bg_as_base(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T}

Modify the widget's background like CBgxk_widget_modify_bg_as_base() does, as long as the widget isn't activated or selected.

CBgxk_widget_proxy_requisition(CIwidget, CIxscale, CIyscale); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} CIgdouble CIxscale; T{ fractional factor for screen width T} CIgdouble CIyscale; T{ fractional factor for screen height T}

Proxy the size requisition of CIwidget through the ::width-request and ::height-request properties. This is useful only for immediate children of a CIGtkScrolledWindow (e.g. a CIGtkViewport), to have the CIGtkScrolledWindow honour the widgets size requisition. If CIxscale or CIyscale is passed as -1, the corresponding dimension ::width-request or ::height-request is left unset. If CIxscale or CIyscale is passed a value between 0 and +1, it is interpreted as a fraction of the screen width or screen height to constrain the corresponding requested dimension.

CBgxk_widget_regulate(CIwidget, CIsensitive, CIactive); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} CIgboolean CIsensitive; T{ whether CIwidget should be sensitive T} CIgboolean CIactive; T{ whether CIwidget should be active T}

Regulate a widgets state. The CIsensitive parameter controls sensitivity like CBgtk_widget_set_sensitive() and CIactive controls whether the widget is active like CBgtk_toggle_button_set_active() or CBgtk_check_menu_item_set_active(). For menu items, the menu item is also made the active widget in its parent menu, possibly affecting option menus.

CBgxk_widget_regulate_uses_active(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} h'-2m'CIRETURNS: T{ TRUE if CBgxk_widget_regulate() uses CIactive for CIwidget T}

Check whether CBgxk_widget_regulate() will actually make use of its CIactive argument for CIwidget. If not, FALSE is returned, and CBgxk_widget_regulate() is fully equivalent to just CBgtk_widget_set_sensitive().

CBgxk_widget_request_hclient_height(CIwidget, CIclient); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} CIGtkWidget* CIclient; T{ valid CIGtkWidget T}

Request the horizontal size of CIclient as height for CIwidget.

CBgxk_widget_request_vclient_width(CIwidget, CIclient); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T} CIGtkWidget* CIclient; T{ valid CIGtkWidget T}

Request the vertical size of CIclient as width for CIwidget.

CBgxk_widget_set_latent_tooltip(CIwidget, CItooltip); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid GtkWidget T} CIconst gchar* CItooltip; T{ descriptive tooltip T}

Set the latent tooltip for this widget. A latent tooltip will not be shown on mouse over for this widget. Instead it can be querried by other widgets via CBgxk_widget_get_latent_tooltip() to be shown when appropriate. For instance, GxkMenuButton shows the latent tooltip of its currently selected menu item.

CBgxk_widget_set_tooltip(CIwidget, CItooltip); nokeep; l l l. CIgpointer CIwidget; T{ a valid CIGtkWidget T} CIconst gchar* CItooltip; T{ descriptive tooltip T}

As a convenience function, this sets the CItooltip for CIwidget on GXK_TOOLTIPS, if CIwidget is supposed to have tooltips according to the system configuration and also sets the latent tooltip.

CBgxk_widget_showraise(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ a valid widget T}

Show the widget. If the widget is a toplevel, also raise its window to top.

CBgxk_widget_viewable(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T}

RETURNS: TRUE if the widget is viewable, FALSE otherwise Check whether a widget is viewable by verifying the mapped state of the widget and all its parent widgets.

CBgxk_widget_viewable_changed(CIwidget); nokeep; l l l. CIGtkWidget* CIwidget; T{ valid CIGtkWidget T}

A widget should call this function if it changed the mapped state of one of its children (or if it is a toplevel and gets show or hidden) to emit the ::viewable-changed signal on the related sub-tree. CIGxkDialog properly emits this signal if show or hidden, containers like CIGtkNotebook need this function be explicitely connected to their ::switch-page signal, in order for their children to get properly notified.

CBgxk_window_get_menu_accel_group(CIwindow); nokeep; l l l. CIGtkWindow* CIwindow; T{ valid CIGtkWindow T} h'-2m'CIRETURNS: T{ valid CIGtkAccelGroup T}

This function hands out an accel group for CIwindow specifically targeted at holding accelerators of menu items in this window.

CBgxk_window_process_next(CIwindow, CIupdate_children); nokeep; l l l. CIGdkWindow* CIwindow; T{ valid CIGdkWindow T} CIgboolean CIupdate_children; T{ whether to also process updates for child windows T}

Cause CIwindow to be updated asyncronously as soon as possible via CBgdk_window_process_updates().

CBgxk_window_set_cursor_type(CIwindow, CIcursor); nokeep; l l l. CIGdkWindow* CIwindow; T{ valid CIGdkWindow* T} CIGdkCursorType CIcursor; T{ CIGdkCursorType cursor type T}

Set a window's cursor type. If GXK_DEFAULT_CURSOR is specified the window's cursor will be inherited from it's parent.

Document Revised: Wed May 25 23:38:23 2005