Reference

beast-gxk(3)

Gtk+ Extension Kit Function Reference Document Revised: Wed May 25 23:38:23 2005

NAME

GXK-Functions - Gtk+ Extension Kit Function Reference

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

SYNOPSIS

bst_gmask_container_create(border_width, dislodge_columns);
bst_gmask_foreach(mask, func, data);
bst_gmask_form(gmask_container, action, gpack);
bst_gmask_get_action(mask);
bst_gmask_get_aux1(mask);
bst_gmask_get_aux2(mask);
bst_gmask_get_aux3(mask);
bst_gmask_get_prompt(mask);
bst_gmask_pack(mask);
bst_gmask_quick(gmask_container, column, prompt, action, tip_text);
bst_gmask_set_aux1(mask, widget);
bst_gmask_set_aux2(mask, widget);
bst_gmask_set_aux3(mask, widget);
bst_gmask_set_column(mask, column);
bst_gmask_set_prompt(mask, widget);
bst_gmask_set_tip(mask, tip_text);
g_object_get_double(object, name);
g_object_get_long(object, name);
g_object_set_double(object, name, v_double);
g_object_set_long(object, name, v_long);
gnome_canvas_set_zoom(canvas, pixels_per_unit);
gnome_canvas_text_set_zoom_size(item, pixels);
gtk_box_get_nth_child(box, pos);
gtk_notebook_current_widget(notebook);
gxk_cell_editable_canceled(ecell);
gxk_cell_editable_is_focus_handler(ecell);
gxk_cell_renderer_popup_get_type();
gxk_color_alloc(colormap, color);
gxk_dialog_action*(dialog, action, callback, data);
gxk_dialog_add_flags(dialog, flags);
gxk_dialog_clear_flags(dialog, flags);
gxk_dialog_get_child(dialog);
gxk_dialog_get_status_window();
gxk_dialog_new(pointer_loc, alive_object, flags, title, child);
gxk_dialog_remove_actions(dialog);
gxk_dialog_set_child(dialog, child);
gxk_dialog_set_default(self, default_widget);
gxk_dialog_set_focus(self, focus_widget);
gxk_dialog_set_sizes(dialog, min_width, min_height, default_width, default_height);
gxk_dialog_set_title(dialog, title);
gxk_expander_connect_to_widget(expander, widget);
gxk_file_selection_heal(fs);
gxk_grab_pointer_and_keyboard(window, owner_events, event_mask, confine_to, cursor, time);
gxk_idle_show_widget(widget);
gxk_idle_showraise(widget);
gxk_idle_unrealize_widget(widget);
gxk_item_factory_get_item(ifactory, path);
gxk_item_factory_get_widget(ifactory, path);
gxk_item_factory_sensitize(ifactory, path, sensitive);
gxk_label_set_attributes:(label, ...);
gxk_led_new(color);
gxk_led_set_color(self, color);
gxk_menu_attach_as_popup(menu, widget);
gxk_menu_attach_as_popup_with_func(menu, widget, mdfunc);
gxk_menu_attach_as_submenu(menu, menu_item);
gxk_menu_check_sensitive(menu);
gxk_menu_set_active(menu, child);
gxk_notebook_append(notebook, child, tab_text, fillexpand);
gxk_notebook_descendant_get_page(widget);
gxk_notebook_descendant_get_tab(widget);
gxk_notebook_set_current_page_widget(notebook, page);
gxk_option_menu_set_menu(option_menu, menu);
gxk_polygon_new(polygon_graph);
gxk_polygon_set_arcs(self, n_arcs, arcs);
gxk_polygon_set_graph(self, polygon_graph);
gxk_polygon_set_length(self, length);
gxk_polygon_set_lines(self, n_lines, lines);
gxk_proxy_editable_get_type();
gxk_proxy_editable_set_cell_editable(self, ecell);
gxk_scroll_text_advance(sctext, uri);
gxk_scroll_text_append(sctext, string);
gxk_scroll_text_append_file(sctext, file_name);
gxk_scroll_text_append_file_tsm(sctext, file_name);
gxk_scroll_text_append_tsm(sctext, string);
gxk_scroll_text_aprintf(sctext, text_fmt);
gxk_scroll_text_clear(sctext);
gxk_scroll_text_create(flags, string);
gxk_scroll_text_display(sctext, uri);
gxk_scroll_text_enter(sctext, uri);
gxk_scroll_text_get_text_view(sctext);
gxk_scroll_text_pop_indent(sctext);
gxk_scroll_text_push_indent(sctext);
gxk_scroll_text_rewind(sctext);
gxk_scroll_text_set(sctext, string);
gxk_scroll_text_set_index(sctext, uri);
gxk_scroll_text_set_tsm(sctext, string);
gxk_scrolled_window_create(child, shadow_type, xrequest, yrequest);
gxk_scrolled_window_spare_space(scwin);
gxk_scrolled_window_unspare_space(scwin);
gxk_signal_handler_exists(instance, detailed_signal, callback, data);
gxk_signal_handler_pending(instance, detailed_signal, callback, data);
gxk_size_group(sgmode, ...);
gxk_size_height(icon_size);
gxk_size_width(icon_size);
gxk_spline_copy(spline);
gxk_spline_dump(spline);
gxk_spline_eval(spline, x, yd1);
gxk_spline_findx(spline, y);
gxk_spline_free(spline);
gxk_spline_new(n_points, points, dy_start, dy_end);
gxk_spline_new_natural(n_points, points);
gxk_spline_y(spline, x);
gxk_status_bar_create();
gxk_status_clear();
gxk_status_errnoprintf(libc_errno, message_fmt);
gxk_status_printf(percentage, status_msg, message_fmt);
gxk_status_set(percentage, message, status_msg);
gxk_status_window_pop();
gxk_status_window_push(widget);
gxk_stock_button(stock_id, label);
gxk_stock_button_child(stock_id, label);
gxk_stock_fallback_pixbuf(stock_id);
gxk_stock_icon_window(stock_id);
gxk_stock_image(stock_icon_id, icon_size);
gxk_stock_register_icon(icon);
gxk_stock_register_icons(n_icons, icons);
gxk_stock_register_item(item);
gxk_stock_register_items(n_items, items);
gxk_text_view_cursor_to_end(tview);
gxk_text_view_cursor_to_start(tview);
gxk_text_view_enter_browse_mode(tview);
gxk_text_view_leave_browse_mode(tview);
gxk_toplevel_activate_default(widget);
gxk_toplevel_delete(widget);
gxk_toplevel_hide(widget);
gxk_tree_model_get_iter(tree_model, iter, path);
gxk_tree_path_prev(path);
gxk_tree_selection_force_browse(selection, model);
gxk_tree_selection_select_ipath(selection, ...);
gxk_tree_selection_select_spath(selection, str_path);
gxk_tree_selection_unselect_ipath(selection, ...);
gxk_tree_selection_unselect_spath(selection, str_path);
gxk_tree_spath_index0(strpath);
gxk_tree_view_add_column(tree_view, position, column, cell, ...);
gxk_tree_view_add_popup_column(tree_view, model_column, column_flags, xalign, title, tooltip, edited_callback, popup_callback, data, cflags);
gxk_tree_view_add_text_column(tree_view, model_column, column_flags, xalign, title, tooltip, edited_callback, data, cflags);
gxk_tree_view_add_toggle_column(tree_view, model_column, column_flags, xalign, title, tooltip, toggled_callback, data, cflags);
gxk_tree_view_append_text_columns(tree_view, n_cols, ...);
gxk_tree_view_column_set_tip_title(tree_column, title, tooltip);
gxk_tree_view_focus_row(tree, row);
gxk_tree_view_get_bin_window_pos(tree, x_p, y_p);
gxk_tree_view_get_row_area(tree, row, y_p, height_p, content_area);
gxk_tree_view_get_row_from_coord(tree, y, row_p);
gxk_tree_view_get_selected_row(tree);
gxk_tree_view_is_row_selected(tree, row);
gxk_type_register_generated(n_entries, entries);
gxk_ungrab_pointer_and_keyboard(window, time);
gxk_vseparator_space_new(draw_seperator);
gxk_widget_activate_accel_group(widget, accel_group);
gxk_widget_add_font_requisition(widget, n_chars, n_digits);
gxk_widget_add_option(widget, option, value);
gxk_widget_ancestry_viewable(widget);
gxk_widget_attached_hierarchy_changed(widget);
gxk_widget_check_option(widget, option);
gxk_widget_find_level_ordered(toplevel, name);
gxk_widget_force_bg_clear(widget);
gxk_widget_get_attach_toplevel(widget);
gxk_widget_get_latent_tooltip(widget);
gxk_widget_get_options(widget);
gxk_widget_has_ancestor(widget, ancestor);
gxk_widget_make_insensitive(widget);
gxk_widget_make_sensitive(widget);
gxk_widget_modify_as_title(widget);
gxk_widget_modify_base_as_bg(widget);
gxk_widget_modify_bg_as_active(widget);
gxk_widget_modify_bg_as_base(widget);
gxk_widget_modify_normal_bg_as_base(widget);
gxk_widget_proxy_requisition(widget, xscale, yscale);
gxk_widget_regulate(widget, sensitive, active);
gxk_widget_regulate_uses_active(widget);
gxk_widget_request_hclient_height(widget, client);
gxk_widget_request_vclient_width(widget, client);
gxk_widget_set_latent_tooltip(widget, tooltip);
gxk_widget_set_tooltip(widget, tooltip);
gxk_widget_showraise(widget);
gxk_widget_viewable(widget);
gxk_widget_viewable_changed(widget);
gxk_window_get_menu_accel_group(window);
gxk_window_process_next(window, update_children);
gxk_window_set_cursor_type(window, cursor);

DESCRIPTION

bst_gmask_container_create(border_width, dislodge_columns);
guint border_width; Border width of this GUI mask
gboolean dislodge_columns; Provide expandable space between columns
RETURNS: GUI field mask container

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

bst_gmask_foreach(mask, func, data);
BstGMask*mask; valid BstGMask
gpointer func; foreach function as: void func(GtkWidget*, gpointer data);
gpointer data; data passed in to func

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

bst_gmask_form(gmask_container, action, gpack);
GtkWidget*gmask_container; container created with bst_gmask_container_create()
GtkWidget*action; valid GtkWidget
BstGMaskPack gpack; BstGMaskPack packing type
RETURNS: a new GUI field mask

Create a new GUI field mask with action 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 GtkEntry input widget. Also, most field masks have a prompt widget, usually a GtkLabel, 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 gpack 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.

bst_gmask_get_action(mask);
BstGMask*mask; valid BstGMask
RETURNS: the requested GtkWidget or NULL

Retrieve the action widget of this GUI field mask.

bst_gmask_get_aux1(mask);
BstGMask*mask; valid BstGMask
RETURNS: the requested GtkWidget or NULL

Retrieve the first auxillary widget of this GUI field mask.

bst_gmask_get_aux2(mask);
BstGMask*mask; valid BstGMask
RETURNS: the requested GtkWidget or NULL

Retrieve the second auxillary widget of this GUI field mask.

bst_gmask_get_aux3(mask);
BstGMask*mask; valid BstGMask
RETURNS: the requested GtkWidget or NULL

Retrieve the third auxillary widget of this GUI field mask.

bst_gmask_get_prompt(mask);
BstGMask*mask; valid BstGMask
RETURNS: the requested GtkWidget or NULL

Retrieve the prompt widget of this GUI field mask.

bst_gmask_pack(mask);
BstGMask*mask; valid BstGMask

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.

bst_gmask_quick(gmask_container, column, prompt, action, tip_text);
GtkWidget*gmask_container; container created with bst_gmask_container_create()
guint column; column number for bst_gmask_set_column()
const gchar*prompt; valid GtkWidget for bst_gmask_set_prompt()
gpointer action; valid GtkWidget as with bst_gmask_form()
const gchar*tip_text; text for bst_gmask_set_tip()
RETURNS: an already packed GUI field mask

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

bst_gmask_set_aux1(mask, widget);
BstGMask*mask; valid BstGMask
gpointer widget; valid GtkWidget

Set the first auxillary widget of this GUI field mask.

bst_gmask_set_aux2(mask, widget);
BstGMask*mask; valid BstGMask
gpointer widget; valid GtkWidget

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

bst_gmask_set_aux3(mask, widget);
BstGMask*mask; valid BstGMask
gpointer widget; valid GtkWidget

Set the third auxillary widget of this GUI field mask.

bst_gmask_set_column(mask, column);
BstGMask*mask; valid BstGMask
guint column; column number

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

bst_gmask_set_prompt(mask, widget);
BstGMask*mask; valid BstGMask
gpointer widget; valid GtkWidget

Set the prompt widget of this GUI field mask.

bst_gmask_set_tip(mask, tip_text);
BstGMask*mask; valid BstGMask
const gchar*tip_text; tooltip text

Set the tooltip text of this GUI field mask.

g_object_get_double(object, name);
gpointer object; a valid GObject
const gchar*name; name of the double value to retrieve
RETURNS: the actual value

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

g_object_get_long(object, name);
gpointer object; a valid GObject
const gchar*name; name of the long value to retrieve
RETURNS: the actual value

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

g_object_set_double(object, name, v_double);
gpointer object; a valid GObject
const gchar*name; name of the double value to set
gdouble v_double; the actual value

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

g_object_set_long(object, name, v_long);
gpointer object; a valid GObject
const gchar*name; name of the long value to set
glong v_long; the actual value

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

gnome_canvas_set_zoom(canvas, pixels_per_unit);
GnomeCanvas*canvas; valid GnomeCanvas
gdouble pixels_per_unit; zoom factor (defaults to 1.0)

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

gnome_canvas_text_set_zoom_size(item, pixels);
GnomeCanvasText*item; canvas text item
gdouble pixels; default font size

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

gtk_box_get_nth_child(box, pos);
GtkBox*box; a valid GtkBox
gint pos; position of the requested child
RETURNS: a child of box or NULL

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

gtk_notebook_current_widget(notebook);
GtkNotebook*notebook; valid GtkNotebook
RETURNS: the widget corresponding to the current page

This function is essentially a shortcut for gtk_notebook_get_current_page() and gtk_notebook_get_nth_page().

gxk_cell_editable_canceled(ecell);
GtkCellEditable*ecell; valid GtkCellEditable
RETURNS: whether editing got aborted

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

gxk_cell_editable_is_focus_handler(ecell);
GtkCellEditable*ecell; valid GtkCellEditable
RETURNS: returns FALSE

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

gxk_cell_renderer_popup_get_type();
RETURNS:GXK_TYPE_CELL_RENDERER_POPUP

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

gxk_color_alloc(colormap, color);
GdkColormap*colormap; valid GdkColormap
GdkColor*color; valid GdkColor

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

gxk_dialog_action*(dialog, action, callback, data);
dialog; valid GxkDialog
action; button label or stock ID
callback; callback function for button activation
data; callback data

Add a new (stock) button to a dialog.

gxk_dialog_add_flags(dialog, flags);
GxkDialog*dialog; valid GxkDialog
GxkDialogFlags flags; additional flags to set on the dialog.

Alter dialog flags, see gxk_dialog_new().

gxk_dialog_clear_flags(dialog, flags);
GxkDialog*dialog; valid GxkDialog
GxkDialogFlags flags; flags to unset on the dialog.

Alter dialog flags, see gxk_dialog_new().

gxk_dialog_get_child(dialog);
GxkDialog*dialog; valid GxkDialog

Retrieve the primary child of the dialog.

gxk_dialog_get_status_window();
RETURNS: a valid GxkDialog or NULL

Retrieve the most recently entered GxkDialog if any.

gxk_dialog_new(pointer_loc, alive_object, flags, title, child);
gpointer pointer_loc; pointer to nullify upon dialog destruction
GtkObject*alive_object; object which upon destruction, takes the dialog with it
GxkDialogFlags flags; dialog flags
const gchar*title; window title for the dialog
GtkWidget*child; child to pack into the dialog

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.

gxk_dialog_remove_actions(dialog);
GxkDialog*dialog; valid GxkDialog

Remove all action buttons setup for this dialog.

gxk_dialog_set_child(dialog, child);
GxkDialog*dialog; valid GxkDialog
GtkWidget*child; new child

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

gxk_dialog_set_default(self, default_widget);
GxkDialog*self;
GtkWidget*default_widget; valid GtkWidget

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

gxk_dialog_set_focus(self, focus_widget);
GxkDialog*self;
GtkWidget*focus_widget; valid GtkWidget

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

gxk_dialog_set_sizes(dialog, min_width, min_height, default_width, default_height);
GxkDialog*dialog; valid GxkDialog
gint min_width; minimum dialog width or -1
gint min_height; minimum dialog height or -1
gint default_width; default dialog width or -1
gint default_height; default dialog height or -1

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

gxk_dialog_set_title(dialog, title);
GxkDialog*dialog; valid GxkDialog
const gchar*title; dialog window manager title

Change the dialog's window manager title and role.

gxk_expander_connect_to_widget(expander, widget);
GtkWidget*expander; valid GtkWidget with boolean ::expanded property
GtkWidget*widget; valid GtkWidget

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

gxk_file_selection_heal(fs);
GtkFileSelection*fs; valid GtkFileSelection
RETURNS: new toplevel VBox of the file selection

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 GtkVBox, enabling removal of the GtkVBox from it's parent and thus using the file selection widgets in a custom GtkWindow.

gxk_grab_pointer_and_keyboard(window, owner_events, event_mask, confine_to, cursor, time);
GdkWindow*window; the window receiving the grab
gboolean owner_events; if TRUE, events will be reported relative to window
GdkEventMask event_mask; mask of interesting events
GdkWindow*confine_to; limits the pointer to the specified window
GdkCursor*cursor; cursor to use for the duration of the grab
guint32 time; event time when grab is requested
RETURNS:TRUE if pointer and keyboard could successfully be grabbed

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.

gxk_idle_show_widget(widget);
GtkWidget*widget; a valid GtkWidget

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.

gxk_idle_showraise(widget);
GtkWidget*widget; a valid GtkWidget

Defers showing and raising this widget like gxk_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.

gxk_idle_unrealize_widget(widget);
GtkWidget*widget; a valid GtkWindow

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.

gxk_item_factory_get_item(ifactory, path);
GtkItemFactory*ifactory; valid GtkItemFactory
const gchar*path; item factory path
RETURNS: menu item according to path

This function strips unescaped underlines ('_') from path and then calls gtk_item_factory_get_item().

gxk_item_factory_get_widget(ifactory, path);
GtkItemFactory*ifactory; valid GtkItemFactory
const gchar*path; item factory path
RETURNS: widget according to path

This function strips unescaped underlines ('_') from path and then calls gtk_item_factory_get_widget().

gxk_item_factory_sensitize(ifactory, path, sensitive);
GtkItemFactory*ifactory; valid GtkItemFactory
const gchar*path; item factory path
gboolean sensitive; whether menu item should be sensitive
RETURNS: menu item according to path

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

gxk_label_set_attributes:(label, ...);
label; a GtkLabel
...; a list of PangoAttrType and value pairs terminated by -1.

Sets Pango attributes on a GtkLabel in a more convenient way than gtk_label_set_attributes(). This function is useful if you want to change the font attributes of a GtkLabel. 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 gimp_label_set_attributes().

gxk_led_new(color);
guint color; rgb color

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

gxk_led_set_color(self, color);
GxkLed*self; valid GxkLed
guint color; color as RGB byte triple

Set the current led color as 24bit RGB values.

gxk_menu_attach_as_popup(menu, widget);
GtkMenu*menu; valid GtkMenu
GtkWidget*widget;

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

gxk_menu_attach_as_popup_with_func(menu, widget, mdfunc);
GtkMenu*menu; valid GtkMenu
GtkWidget*widget;
GtkMenuDetachFunc mdfunc; a GtkMenuDetachFunc func as in gtk_menu_attach_to_widget()

Variant of gxk_menu_attach_as_popup() which preserves the GtkMenuDetachFunc.

gxk_menu_attach_as_submenu(menu, menu_item);
GtkMenu*menu; valid GtkMenu
GtkMenuItem*menu_item; valid GtkMenuItem

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

gxk_menu_check_sensitive(menu);
GtkMenu*menu; valid GtkMenu
RETURNS: TRUE if menu contains selectable items

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

gxk_menu_set_active(menu, child);
GtkMenu*menu; valid GtkMenu
GtkWidget*child; an immediate child of menu

This function replaces gtk_menu_set_active(). The child 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.

gxk_notebook_append(notebook, child, tab_text, fillexpand);
GtkNotebook*notebook; a valid notebook
GtkWidget*child; a valid parent-less widget
const gchar*tab_text;
gboolean fillexpand; whether the tab label should expand

Add a new page containing child to notebook, naming the page label.

gxk_notebook_descendant_get_page(widget);
GtkWidget*widget; valid GtkWidget
RETURNS: notebook page widget or NULL

Find the innermost notebook page widget that contains widget.

gxk_notebook_descendant_get_tab(widget);
GtkWidget*widget; valid GtkWidget
RETURNS: notebook page tab widget or NULL

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

gxk_notebook_set_current_page_widget(notebook, page);
GtkNotebook*notebook; valid GtkNotebook
GtkWidget*page; notebook page widget

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

gxk_option_menu_set_menu(option_menu, menu);
GtkOptionMenu*option_menu; valid GtkOptionMenu
GtkMenu*menu; valid GtkMenu

This function is a replacement for gtk_option_menu_set_menu(). Similar to gxk_menu_attach_as_submenu(), it sets up a propagation mechanism, so menu and submenus thereof automatically fetch their accelerator groups via gxk_window_get_menu_accel_group() from the toplevel window.

gxk_polygon_new(polygon_graph);
GxkPolygonGraph*polygon_graph; set of lines and arcs

Create a new polygon widget.

gxk_polygon_set_arcs(self, n_arcs, arcs);
GxkPolygon*self; valid GxkPolygon
guint n_arcs; number of arcs
GxkPolygonArc*arcs; array of arcs

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

gxk_polygon_set_graph(self, polygon_graph);
GxkPolygon*self; valid GxkPolygon
GxkPolygonGraph*polygon_graph; set of lines and arcs

Set the lines and arcs for this polygon, see gxk_polygon_set_lines() and gxk_polygon_set_arcs().

gxk_polygon_set_length(self, length);
GxkPolygon*self; valid GxkPolygon
guint length; set of lines and arcs

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

gxk_polygon_set_lines(self, n_lines, lines);
GxkPolygon*self; valid GxkPolygon
guint n_lines; number of lines
GxkPolygonLine*lines; array of lines

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

gxk_proxy_editable_get_type();
RETURNS:GXK_TYPE_PROXY_EDITABLE

GxkProxyEditable is a GtkEventBox which proxies the GtkCellEditable interface onto a backend widget which also implements the GtkCellEditable interface.

gxk_proxy_editable_set_cell_editable(self, ecell);
GxkProxyEditable*self; valid GxkProxyEditable
GtkCellEditable*ecell; valid GtkCellEditable

Set the backend ecell onto which GtkCellEditable methods issued on self are to be forwarded. This function may only be called once per GxkProxyEditable.

gxk_scroll_text_advance(sctext, uri);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*uri; resource locator

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

gxk_scroll_text_append(sctext, string);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*string; the text to be displayed

Append string to the textual contents of this sctext.

gxk_scroll_text_append_file(sctext, file_name);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*file_name; file holding the text to be displayed

Append the contents of file_name to the textual contents of this sctext.

gxk_scroll_text_append_file_tsm(sctext, file_name);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*file_name; file holding the text to be displayed in tag-span-markup

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

gxk_scroll_text_append_tsm(sctext, string);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*string; the text to be displayed in tag-span-markup

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

gxk_scroll_text_aprintf(sctext, text_fmt);
sctext; a scroll text widget as returned from gxk_scroll_text_create()
text_fmt; printf(3) style format string

Append text_fmt to the textual contents of this sctext.

gxk_scroll_text_clear(sctext);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()

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

gxk_scroll_text_create(flags, string);
GxkScrollTextFlags flags;
const gchar*string; default contents

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 string;
GXK_SCROLL_TEXT_CENTER - center string;
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 GtkLabel, which amounts to using a sans serif font, normal widget background and allowing word wrapping.

gxk_scroll_text_display(sctext, uri);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*uri; resource locator

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

gxk_scroll_text_enter(sctext, uri);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*uri; resource locator

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

gxk_scroll_text_get_text_view(sctext);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
RETURNS: a GtkTextView widget

Return the internally used GtkTextView of this sctext.

gxk_scroll_text_pop_indent(sctext);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()

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

gxk_scroll_text_push_indent(sctext);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()

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

gxk_scroll_text_rewind(sctext);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()

Go back in navigation history as far as possible.

gxk_scroll_text_set(sctext, string);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*string; the new text to be displayed

Replace the textual contents of this sctext with string.

gxk_scroll_text_set_index(sctext, uri);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*uri; resource locator

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

gxk_scroll_text_set_tsm(sctext, string);
GtkWidget*sctext; a scroll text widget as returned from gxk_scroll_text_create()
const gchar*string; the new text to be displayed in tag-span-markup

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

gxk_scrolled_window_create(child, shadow_type, xrequest, yrequest);
GtkWidget*child; valid GtkWidget
GtkShadowType shadow_type; shadow around the GtkViewport
gdouble xrequest; fractional factor for screen width
gdouble yrequest; fractional factor for screen height
RETURNS: the newly created GtkScrolledWindow

Create a GtkScrolledWindow with a GtkViewport as parent of child. The xrequest and yrequest arguments are passed on to gxk_widget_proxy_requisition().

gxk_scrolled_window_spare_space(scwin);
GtkScrolledWindow*scwin; valid GtkScrolledWindow

A normal GtkScrolledWindow 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).

gxk_scrolled_window_unspare_space(scwin);
GtkScrolledWindow*scwin; valid GtkScrolledWindow

Undo the effect of a call to gxk_scrolled_window_spare_space().

gxk_signal_handler_exists(instance, detailed_signal, callback, data);
gpointer instance; object instance with signals
const gchar*detailed_signal; signal name
GCallback callback; custom callback function
gpointer data; callback data
RETURNS: whether callback is connected

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

gxk_signal_handler_pending(instance, detailed_signal, callback, data);
gpointer instance; object instance with signals
const gchar*detailed_signal; signal name
GCallback callback; custom callback function
gpointer data; callback data
RETURNS: whether callback is connected

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

gxk_size_group(sgmode, ...);
sgmode; size group mode, one of GTK_SIZE_GROUP_NONE,
...; NULL terminated list of widgets to group together

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

gxk_size_height(icon_size);
GtkIconSize icon_size; image size id
RETURNS: image size height

Return the height of a specific image size.

gxk_size_width(icon_size);
GtkIconSize icon_size; image size id
RETURNS: image size width

Return the width of a specific image size.

gxk_spline_copy(spline);
GxkSpline*spline; correctly setup GxkSpline
RETURNS: newly allocated spline

Produce a copy of an already setup spline.

gxk_spline_dump(spline);
GxkSpline*spline; correctly setup GxkSpline

Produce a debugging printout of spline on stderr.

gxk_spline_eval(spline, x, yd1);
const GxkSpline*spline; correctly setup GxkSpline
double x; x position for evaluation
double*yd1;
RETURNS: y of spline at position x

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

gxk_spline_findx(spline, y);
const GxkSpline*spline; correctly setup GxkSpline
double y; interpolated y value
RETURNS: x position to yield y or NAN

Find an x position for which spline evaluation yields y. Due to round off, calling gxk_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 gxk_spline_y(), some times much longer.

gxk_spline_free(spline);
GxkSpline*spline; correctly setup GxkSpline

Free a spline structure.

gxk_spline_new(n_points, points, dy_start, dy_end);
guint n_points; number of fix points
const GxkSplinePoint*points; fix points
double dy_start; first derivatives at point[0]
double dy_end; first derivatives at point[n_points - 1]
RETURNS: newly allocated spline

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.

gxk_spline_new_natural(n_points, points);
guint n_points; number of fix points
const GxkSplinePoint*points; fix points
RETURNS: newly allocated spline

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

gxk_spline_y(spline, x);
const GxkSpline*spline; correctly setup GxkSpline
double x; x position for evaluation
RETURNS: y of spline at position x

Evaluate the spline polynomial at position x and return the interpolated value y.

gxk_status_bar_create();
RETURNS: status bar container

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

gxk_status_clear();

Clear the current status bar.

gxk_status_errnoprintf(libc_errno, message_fmt);
libc_errno; errno value
message_fmt; printf style message to be displayed

Similar to gxk_status_printf() but figures the error status automatically from the passed in libc_errno.

gxk_status_printf(percentage, status_msg, message_fmt);
percentage; progress percentage
status_msg; error status
message_fmt; printf style message to be displayed

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

gxk_status_set(percentage, message, status_msg);
gfloat percentage; progress percentage
const gchar*message; message to be displayed
const gchar*status_msg; error status

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.

gxk_status_window_pop();

Pop the most recently pushed window from the status bar window stack.

gxk_status_window_push(widget);
gpointer widget; status bar window

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

gxk_stock_button(stock_id, label);
const gchar*stock_id; stock name
const gchar*label; button text
RETURNS: a visible GtkButton widget

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

gxk_stock_button_child(stock_id, label);
const gchar*stock_id; stock name
const gchar*label; button text
RETURNS: a visible widget suitable as GtkButton child

This function does the same as gxk_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.

gxk_stock_fallback_pixbuf(stock_id);
const gchar*stock_id; stock name
RETURNS: this stock_id's pixbuf (or NULL for invalid stock ids)

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

gxk_stock_icon_window(stock_id);
const gchar*stock_id; a valid stock icon name
RETURNS: a window showing the stock icon

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.

gxk_stock_image(stock_icon_id, icon_size);
const gchar*stock_icon_id; stock name
GtkIconSize icon_size; image size
RETURNS: a visible GtkImage widget or NULL

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.

gxk_stock_register_icon(icon);
const GxkStockIcon*icon; a validly filled out GxkStockIcon

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.

gxk_stock_register_icons(n_icons, icons);
guint n_icons; number of icons to register
const GxkStockIcon*icons; a validly filled out array of GxkStockIcon

For all n_icons contained in icons, call gxk_stock_register_icon().

gxk_stock_register_item(item);
const GxkStockItem*item; a validly filled out GxkStockItem

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

gxk_stock_register_items(n_items, items);
guint n_items; number of items to register
const GxkStockItem*items; a validly filled out array of GxkStockItem

For all n_items contained in items, call gxk_stock_register_item().

gxk_text_view_cursor_to_end(tview);
GtkTextView*tview; a GtkTextView object

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

gxk_text_view_cursor_to_start(tview);
GtkTextView*tview; a GtkTextView object

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

gxk_text_view_enter_browse_mode(tview);
GtkTextView*tview; a GtkTextView object

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

gxk_text_view_leave_browse_mode(tview);
GtkTextView*tview; a GtkTextView object

Deinstall key press handlers previously installed with gxk_text_view_enter_browse_mode().

gxk_toplevel_activate_default(widget);
GtkWidget*widget; a widget having a toplevel

Activate the default widget of the toplevel of widget.

gxk_toplevel_delete(widget);
GtkWidget*widget; a widget having a toplevel

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

gxk_toplevel_hide(widget);
GtkWidget*widget; a widget having a toplevel

Hide the toplevel of widget.

gxk_tree_model_get_iter(tree_model, iter, path);
GtkTreeModel*tree_model;
GtkTreeIter*iter;
GtkTreePath*path;

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

gxk_tree_path_prev(path);
GtkTreePath*path; valid GtkTreePath

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

gxk_tree_selection_force_browse(selection, model);
GtkTreeSelection*selection; GtkTreeSelection to watch
GtkTreeModel*model; tree model used with selection

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

gxk_tree_selection_select_ipath(selection, ...);
selection; GtkTreeSelection to modify
...; GtkTreePath indices

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

gxk_tree_selection_select_spath(selection, str_path);
GtkTreeSelection*selection; GtkTreeSelection to modify
const gchar*str_path; a stringified GtkTreePath

Select the row denoted by str_path.

gxk_tree_selection_unselect_ipath(selection, ...);
selection; GtkTreeSelection to modify
...; GtkTreePath indices

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

gxk_tree_selection_unselect_spath(selection, str_path);
GtkTreeSelection*selection; GtkTreeSelection to modify
const gchar*str_path; a stringified GtkTreePath

Unselect the row denoted by str_path.

gxk_tree_spath_index0(strpath);
const gchar*strpath; stringified GtkTreePath

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

gxk_tree_view_add_column(tree_view, position, column, cell, ...);
tree_view; valid GtkTreeView
position; column position (or -1 to append)
column; valid GtkTreeViewColumn
cell; valid GtkCellRenderer
...; attribute mappings

Appends cell to column and adds column to tree_view at the specified position. 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 gtk_tree_view_column_add_attribute().

gxk_tree_view_add_popup_column(tree_view, model_column, column_flags, xalign, title, tooltip, edited_callback, popup_callback, data, cflags);
GtkTreeView*tree_view; valid GtkTreeView
guint model_column; model column
const gchar*column_flags;
gdouble xalign; horizontal text alignment
const gchar*title; column title
const gchar*tooltip; column tooltip
gpointer edited_callback; edit notification callback
gpointer popup_callback; popup notification callback
gpointer data; data passed in to toggled_callback
GConnectFlags cflags; connection flags
RETURNS: a newly added GtkTreeViewColumn

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

gxk_tree_view_add_text_column(tree_view, model_column, column_flags, xalign, title, tooltip, edited_callback, data, cflags);
GtkTreeView*tree_view; valid GtkTreeView
guint model_column; model column
const gchar*column_flags; column flags
gdouble xalign; horizontal text alignment
const gchar*title; column title
const gchar*tooltip; column tooltip
gpointer edited_callback; notification callback
gpointer data; data passed in to toggled_callback
GConnectFlags cflags; connection flags
RETURNS: a newly added GtkTreeViewColumn

Add a new column with text cell to a tree_view. The model_column indicates the column number of the tree model containing the text to be displayed, the column_flags toggle specific column characteristics (see gxk_tree_view_append_text_columns() for details) and xalign controls the horizontal cell alignment (between 0 and 1). If non-NULL, edited_callback(data) is connected with cflags (see g_signal_connect_data()) to the "::edited" signal of the text cell and the cell is made editable.

gxk_tree_view_add_toggle_column(tree_view, model_column, column_flags, xalign, title, tooltip, toggled_callback, data, cflags);
GtkTreeView*tree_view; valid GtkTreeView
guint model_column; model column
const gchar*column_flags;
gdouble xalign; horizontal text alignment
const gchar*title; column title
const gchar*tooltip; column tooltip
gpointer toggled_callback; notification callback
gpointer data; data passed in to toggled_callback
GConnectFlags cflags; connection flags
RETURNS: a newly added GtkTreeViewColumn

Add a toggle button column, similar to gxk_tree_view_add_text_column(), however the model column is expected to be of type G_TYPE_BOOLEAN, and instead of an edited_callback(), this function has a void toggled_callback(GtkCellRendererToggle*, const gchar *strpath, data) callback which is connected to the "toggled" signal of the new cell.

gxk_tree_view_append_text_columns(tree_view, n_cols, ...);
tree_view; valid GtkTreeView
n_cols; number of columns to append
...; column arguments

Add n_cols new columns with text cells to tree_view (a short hand version for multiple calls to gxk_tree_view_add_text_column()). Per column, the caller needs to supply a guint, a string, a gdouble 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 column_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.

gxk_tree_view_column_set_tip_title(tree_column, title, tooltip);
GtkTreeViewColumn*tree_column; valid GtkTreeViewColumn
const gchar*title; column title
const gchar*tooltip; column tooltip

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.

gxk_tree_view_focus_row(tree, row);
GtkTreeView*tree; valid GtkTreeView
gint row; row to focus

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

gxk_tree_view_get_bin_window_pos(tree, x_p, y_p);
GtkTreeView*tree; valid GtkTreeView
gint*x_p; x position
gint*y_p; y position

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

gxk_tree_view_get_row_area(tree, row, y_p, height_p, content_area);
GtkTreeView*tree; valid GtkTreeView
gint row; row to retrieve area coordinates for
gint*y_p; y position of row
gint*height_p; height of row
gboolean content_area; whether the cell background area or content area is returned

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

gxk_tree_view_get_row_from_coord(tree, y, row_p);
GtkTreeView*tree; valid GtkTreeView
gint y; bin window y coordinate
gint*row_p; row pointed to by y
RETURNS: whether y lies within the visible area

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

gxk_tree_view_get_selected_row(tree);
GtkTreeView*tree; valid GtkTreeView
RETURNS: first selected row or -1

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

gxk_tree_view_is_row_selected(tree, row);
GtkTreeView*tree; valid GtkTreeView
gint row; row to test
RETURNS: whether row is selected

Check whether row in tree is selected.

gxk_type_register_generated(n_entries, entries);
guint n_entries; number of generated types to register
const GxkTypeGenerated*entries; GxkTypeGenerated type descriptions

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 type_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.

gxk_ungrab_pointer_and_keyboard(window, time);
GdkWindow*window; window pointer was previously grabed on
guint32 time;

This function releases a pointer and keyboard grab acquired through gxk_grab_pointer_and_keyboard(). The window is used to release grabs on the correct display, see gdk_display_pointer_ungrab() and gdk_display_keyboard_ungrab() on this.

gxk_vseparator_space_new(draw_seperator);
gboolean draw_seperator; enable visible vertical seperator
RETURNS: visible vertical space/seperator widget

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

gxk_widget_activate_accel_group(widget, accel_group);
GtkWidget*widget; a valid GtkWidget
GtkAccelGroup*accel_group; a valid GtkAccelGroup

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

gxk_widget_add_font_requisition(widget, n_chars, n_digits);
GtkWidget*widget; valid GtkWidget
guint n_chars; number of characters to request space for
guint n_digits; number of digits to request space for

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

gxk_widget_add_option(widget, option, value);
gpointer widget; valid GtkWidget
const gchar*option; option to add to widget
const gchar*value; value of option (currently just "+" and "-" are supported)

Add/set a custom option of widget to a particular value. 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 g_option_concat(), g_option_check() and g_option_get().

gxk_widget_ancestry_viewable(widget);
GtkWidget*widget; a valid GtkWidget
RETURNS: whether widget is visible on screen

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

gxk_widget_attached_hierarchy_changed(widget);
GtkWidget*widget; valid GtkWidget

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 gxk_widget_attached_hierarchy_changed() is provided. On menus which got attached to a widget with gxk_menu_attach_as_popup(), the signal ::attached-hirarchy-changed is emitted if ::hirarchy-changed is emitted on the widget, by calling gxk_widget_attached_hierarchy_changed() on the menu.

gxk_widget_check_option(widget, option);
gpointer widget; valid GtkWidget
const gchar*option; option to check for
RETURNS: whether option is set

Test whether the custom option is set on widget.

gxk_widget_find_level_ordered(toplevel, name);
GtkWidget*toplevel; valid GtkWidget
const gchar*name; name of the widget being looked for
RETURNS: a widget named name or NULL

Search for a widget named name, child of toplevel. 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 gxk_menu_attach_as_popup() (not ones attached via gtk_menu_attach_to_widget() though, since Gtk+ doesn't store/export the neccessary information).

gxk_widget_force_bg_clear(widget);
GtkWidget*widget; a valid GtkWidget

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.

gxk_widget_get_attach_toplevel(widget);
GtkWidget*widget; valid GtkWidget

This function returns the topmost container widget for widget, much like gtk_widget_get_toplevel(). The only difference is that for menus, not the immediate parent is returned (the GtkWindow 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, gtk_widget_get_toplevel() invoked on one of the menu items will return the GtkWindow widgets for the corresponding submenus, while gxk_widget_get_attach_toplevel() will return the actual GtkWindow containing the menubar.

gxk_widget_get_latent_tooltip(widget);
GtkWidget*widget; a valid GtkWidget

Retrieve the latent tooltip for widget. See gxk_widget_set_latent_tooltip() for the purpose of latent tooltips.

gxk_widget_get_options(widget);
gpointer widget; valid GtkWidget
RETURNS: custom options set on the widget

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

gxk_widget_has_ancestor(widget, ancestor);
gpointer widget; valid GtkWidget
gpointer ancestor; valid GtkWidget
RETURNS: whether ancestor is ancestor of widget

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

gxk_widget_make_insensitive(widget);
GtkWidget*widget; a valid GtkWidget

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

gxk_widget_make_sensitive(widget);
GtkWidget*widget; a valid GtkWidget

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

gxk_widget_modify_as_title(widget);
GtkWidget*widget; a valid GtkWidget

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 (widget should be the menu item's label).

gxk_widget_modify_base_as_bg(widget);
GtkWidget*widget; a valid GtkWidget

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.

gxk_widget_modify_bg_as_active(widget);
GtkWidget*widget; a valid GtkWidget

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

gxk_widget_modify_bg_as_base(widget);
GtkWidget*widget; a valid GtkWidget

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.

gxk_widget_modify_normal_bg_as_base(widget);
GtkWidget*widget; a valid GtkWidget

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

gxk_widget_proxy_requisition(widget, xscale, yscale);
GtkWidget*widget; valid GtkWidget
gdouble xscale; fractional factor for screen width
gdouble yscale; fractional factor for screen height

Proxy the size requisition of widget through the ::width-request and ::height-request properties. This is useful only for immediate children of a GtkScrolledWindow (e.g. a GtkViewport), to have the GtkScrolledWindow honour the widgets size requisition. If xscale or yscale is passed as -1, the corresponding dimension ::width-request or ::height-request is left unset. If xscale or yscale 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.

gxk_widget_regulate(widget, sensitive, active);
GtkWidget*widget; valid GtkWidget
gboolean sensitive; whether widget should be sensitive
gboolean active; whether widget should be active

Regulate a widgets state. The sensitive parameter controls sensitivity like gtk_widget_set_sensitive() and active controls whether the widget is active like gtk_toggle_button_set_active() or gtk_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.

gxk_widget_regulate_uses_active(widget);
GtkWidget*widget; valid GtkWidget
RETURNS:TRUE if gxk_widget_regulate() uses active for widget

Check whether gxk_widget_regulate() will actually make use of its active argument for widget. If not, FALSE is returned, and gxk_widget_regulate() is fully equivalent to just gtk_widget_set_sensitive().

gxk_widget_request_hclient_height(widget, client);
GtkWidget*widget; valid GtkWidget
GtkWidget*client; valid GtkWidget

Request the horizontal size of client as height for widget.

gxk_widget_request_vclient_width(widget, client);
GtkWidget*widget; valid GtkWidget
GtkWidget*client; valid GtkWidget

Request the vertical size of client as width for widget.

gxk_widget_set_latent_tooltip(widget, tooltip);
GtkWidget*widget; a valid GtkWidget
const gchar*tooltip; descriptive tooltip

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 gxk_widget_get_latent_tooltip() to be shown when appropriate. For instance, GxkMenuButton shows the latent tooltip of its currently selected menu item.

gxk_widget_set_tooltip(widget, tooltip);
gpointer widget; a valid GtkWidget
const gchar*tooltip; descriptive tooltip

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

gxk_widget_showraise(widget);
GtkWidget*widget; a valid widget

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

gxk_widget_viewable(widget);
GtkWidget*widget; valid GtkWidget

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.

gxk_widget_viewable_changed(widget);
GtkWidget*widget; valid GtkWidget

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. GxkDialog properly emits this signal if show or hidden, containers like GtkNotebook need this function be explicitely connected to their ::switch-page signal, in order for their children to get properly notified.

gxk_window_get_menu_accel_group(window);
GtkWindow*window; valid GtkWindow
RETURNS: valid GtkAccelGroup

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

gxk_window_process_next(window, update_children);
GdkWindow*window; valid GdkWindow
gboolean update_children; whether to also process updates for child windows

Cause window to be updated asyncronously as soon as possible via gdk_window_process_updates().

gxk_window_set_cursor_type(window, cursor);
GdkWindow*window; valid GdkWindow*
GdkCursorType cursor; GdkCursorType cursor type

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

History