gxk-functions(3)

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 expand

able 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 us

ing 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 cre

ated 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, label

ing 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 wid

get 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 mul

tiple 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 cre

ated 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 oc

cours.

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 re

trieve 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 re

trieve 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 ad

dition 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 correspond

ing 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 sup

ported by GtkEntry and triggered by pressing Escape during edit

ing).

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 ren

derer 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 auto

mated error checking.

gxk_dialog_action*(dialog, action, callback, data);

dialog; valid GxkDialog
action; button label or stock ID
callback; callback function for button ac

tivation
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 nul

lify 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 de

stroy 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 visi

ble;
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. De

stroys 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 ev

erytime 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, con

strained 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 fo

cus 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 re

ceiving the grab
gboolean owner_events; if TRUE, events

will be reported relative to window
GdkEventMask event_mask; mask of interest

ing events
GdkWindow* confine_to; limits the point

er 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 simul

taneously. This is recommended over plain pointer grabs, to re

duce the risk of other applications (for instance the window man

ager) 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 han

dler 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 re

maining 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 accord

ing 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 con

venient 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 at

tributes 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 accelera

tor groups via gxk_window_get_menu_accel_group() from the toplev

el 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 pre

serves 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 re

sponse to children being deleted or added to the menu. The ratio

nale behind this is to avoid empty submenus popups. Also, a prop

agation mechanism is set up, so menu and submenus thereof auto

matically 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 se

lectable items

This function tests whether a menu contains se

lectable 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 la

bel 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 con

tains 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 con

tains 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 accelera

tor groups via gxk_window_get_menu_accel_group() from the toplev

el 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 imple

ments 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 on

ly 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 apper

ance 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 al

tering 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 pre

vious 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 af

fects 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 dis

played

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 dis

played 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 corre

sponding 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 call

back 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 re

turned 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 call

back 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 re

turned 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 eval

uation
double* yd1;

RETURNS: y of spline at posi

tion 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 deriva

tives at point[0]
double dy_end; first deriva

tives at point[n_points - 1]

RETURNS: newly allo

cated 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 allo

cated 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 eval

uation

RETURNS: y of spline at posi

tion 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 win

dows 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 er

ror 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 construc

tion 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 dis

played
const gchar* status_msg; error status

Set the current status bar message, progress per

centage (usually 0% - 100% or one of the special values: GXK_STA

TUS_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 suit

able as GtkButton child

This function does the same as gxk_stock_button()

except for creating the actual button. The button's child is in

stead returned to the caller, this might e.g. be useful if a but

ton 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 run

time. 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 GtkIm

age 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 re

turned 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 al

low 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 construct

ed 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 construct

ed 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 ap

pend)
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 notifi

cation callback
gpointer popup_callback; popup notifi

cation 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 addition

al 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 con

taining the text to be displayed, the column_flags toggle specif

ic column characteristics (see

gxk_tree_view_append_text_columns() for details) and xalign con

trols 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 ex

pected 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 Argu

ments are used as model column number (for the text to be dis

played), 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 dis

play 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; GxkType

Generated 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 struc

tures. 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 previ

ously 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 ver

tical 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 conve

nience, 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 re

quest space for

This function adds up extra space to the widget

size requisition. The space is an approximation of the space re

quired 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 (cur

rently just "+" and "-" are supported)

Add/set a custom option of widget to a particular

value. Custom options on widgets are used to attach extra infor

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

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 at

tached to widgets aren't properly notified upon such hirarchy

changes, for this gxk_widget_attached_hierarchy_changed() is pro

vided. 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 wid

get, 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 be

ing 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/ex

port the neccessary information).

gxk_widget_force_bg_clear(widget);

GtkWidget* widget; a valid GtkWidget

Enforce drawing of a widget's background. Some wid

gets 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 differ

ence 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 win

dow containing a menubar with submenus, gtk_widget_get_toplevel()

invoked on one of the menu items will return the GtkWindow wid

gets 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 an

cestor 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_sen

sitive (widget, FALSE); It exists as a convenient signal connec

tion callback.

gxk_widget_make_sensitive(widget);

GtkWidget* widget; a valid GtkWidget

This function is euqivalent to gtk_widget_set_sen

sitive (widget, TRUE); It exists as a convenient signal connec

tion callback.

gxk_widget_modify_as_title(widget);

GtkWidget* widget; a valid GtkWidget

Modify the widget and it's style, so that it is in

sensitive, but doesn't quite look that way. Useful for inactive

title menu items in menus (widget should be the menu item's la

bel).

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 use

ful 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 corre

sponding 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 af

fecting 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 re

turned, 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 oth

erwise 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 par

ent.

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

BEAST-0.6.6-rc1 25 May 2005

GXK-Functions(3)