All the functions in here are marked a Non-public. We describe it anyway because it is occasionally useful to understand how the work is done.

Arguments are a way of describing a named parameter to a function. They have two important roles within gtk+:

- they describe object properties. This means that they present an interface to get and set a named-type for any type of object in a consistent way. (All the relevant functions to do this start with gtk_object_set or gtk_object_get).

- they describe signal arguments. This is a lot less often needed but still useful. Usually if you are just emitting or creating a particular signal it is more convenient to just use gtk_signal_emit() or gtk_signal_new(). However if you are writing a function to emit or create an arbitrary signal, you must use gtk_signal_emitv() or gtk_signal_newv().

#GtkObject.

Utility function to manipulate lists of named, typed arguments. Implementation of Object Properties

GtkCellRendererTextPixbuf

The #GtkData object is a very simple object intended to be used as a base class for objects which contain data (i.e. the 'Model' in the object-oriented Model/View/Controller framework).

Currently it is not very useful since all it provides is a "disconnect" signal. This signal could be emitted by a #GtkData subclass to notify any 'Views' that they should disconnect from the #GtkData (the 'Model'), possibly just before the #GtkData is destroyed.

abstract base class for objects containing data. GtkData Debugging gtkenums.sgml

# What are Signal Marshallers?

Marshals are functions which all have the same prototype: they take a #GtkObject, a #GtkSignalFunc, a #gpointer, and an array of argument values. The functions are names gtk_marshall_RETURNTYPE__PARAMTYPE1_PARAMTYPE2....

They then call a native function: the GtkObject is the first parameter passed in. The arguments are passed in the native calling convention: chars, shorts, ints, longs may be packed on the stack, or tucked in registers: it doesn't matter because the same calling convention will be generated inside the gtkmarshal code as is expected where you define your handlers.

So the function named:

    gtk_marshal_BOOL__POINTER_INT_INT_UINT(GtkObject*, GtkSignalFunc, gpointer, GtkArg*);

will call the #GtkSignalFunc assuming it was a function with signature:

    gboolean sigfunc(gpointer,gint,gint,guint);

## Writing Custom Marshals

Marshals are primarily used as arguments to gtk_signal_new(). Sometimes, you may find that a marshaller you need isn't available in the standard list. Then you have to write your own.

If you wish to define a signal with a new type of argument list. Suppose you want 2 pointers and 2 integers. You would write:

    typedef int (*GtkSignal_INT__POINTER_POINTER_INT_INT)(
    			gpointer, gpointer, gint, gint
    );

    void marshal_INT__POINTER_POINTER_INT_INT(GtkObject*    object,
    					   GtkSignalFunc func,
    					   gpointer      func_data,
                                               GtkArg*       args)
    {
    	GtkSignal_NONE__POINTER_POINTER_INT_INT rfunc;
    	gint* return_val;
    	return_val = GTK_RETLOC_INT(args[4]);
    	rfunc = (GtkSignal_INT__POINTER_POINTER_INT_INT)func;
    	*return_val = (*rfunc)(object,
                                   GTK_VALUE_POINTER(args[0]),
                                   GTK_VALUE_POINTER(args[1]),
                                   GTK_VALUE_INT(args[2]),
                                   GTK_VALUE_INT(args[3]),
                                   func_data);
    }

#GtkSignal

- The signal handling functions (of which marshallers are really an implementation detail).

Functions to adapt C structures to native calling convention. Signal Marshallers

GtkPacker Private Information

Themes

GtkModelSimple

A macro to check whether a child widget of the CList has the focus.

@clist: The #GtkCList widget to check.

@obj:

@klass:

Tests whether a #GtkObject has had a signal connected to it.

@obj: the object to examine.

Test whether a GtkObject's arguments have been prepared.

@obj: the object to examine.

Test whether a GtkObject has had gtk_object_destroy() invoked on it.

@obj: the object to examine.

Get the number of signals defined by this object.

@obj: the object to query.

Turns on certain object flags. (Private)

@obj: the object to affect. @flag: the flags to set.

Get the array of signals defined for this object.

@obj: the object to fetch the signals from.

Turns off certain object flags. (Private)

@obj: the object to affect. @flag: the flags to unset.

@obj:

@klass:

@obj:

@obj:

A macro that returns a GList that contains the selection of the root tree of @obj.

@obj: A pointer to the #GtkTree. @obj will accept any pointer, but it the pointer does not point to a #GtkTree, the results are undefined.

The first "flat" (no struct) enumerated type value.

The last "flat" (no struct) enumerated type value.

Hide the name of gtk_identifier_get_type

Combine a fundemantal type and a sequence number to create a gtk type.

@parent_t: @seqno:

No idea.

Convert a gtk type into its sequence number

@type:

The first structured enumerated type value.

The last structured enumerated type value.

Use to get the value of a GtkArg whose GtkType is GTK_TYPE_ARGS

@a:

Use to get the value of a GtkArg whose GtkType is GTK_TYPE_CALLBACK

@a:

Use to get the value of a GtkArg whose GtkType is GTK_TYPE_C_CALLBACK

@a:

Use to get the value of a GtkArg whose GtkType is GTK_TYPE_C_FOREIGN

@a:

@a: @b: @Returns:

This is a private struct used by GTK+ internally, don't worry about it.

@accel_group: @accelerator_key: @accelerator_mods: @accel_flags: @object: @signal_id:

@data: @accel_path_quark: @accel_key: @accel_mods: @accel_group: @old_accel_key: @old_accel_mods:

@action: the object which received the signal. @widget:

@action: the object which received the signal. @widget:

Define a function pointer. Deprecated.

@object: @arg: @arg_id:

A structure containing information about the argument. Returned by gtk_arg_get_info().

@class_type: if the argument is an object, this is the object class type. @name: the name of the argument. @type: the type of the argument; it may be an object's type or a fundamental type. @arg_flags: flags applicable to the argument (i.e. readable, writable, and whether it needs to be constructed). @full_name: the object name and argument name separated by ::, e.g. "GtkObject::user_data" or "GtkButton::label". @arg_id: the unique argument identified. @seq_id: ???

Define a function pointer. Deprecated.

@object: @arg: @arg_id:

@get_type_from_name: Looks up a type by name. The default implementation applies heuristics to map type names to `_get_type` function names, e.g. GtkHBox to gtk_hbox_get_type(). This virtual function is provided to allow language bindings to intercept the type resolution process.

@parent:

@combobox: the object which received the signal.

@combobox: the object which received the signal.

@container: the object which received the signal. @direction: @Returns:

The #GtkData-struct struct contains no public fields.

Emitted to notify any views on the #GtkData object to disconnect from it, possibly because the #GtkData object is about to be destroyed.

@data: the object which received the signal.

Indicates that the user has activated the widget in some fashion. Generally, this will be done with a keystroke. (The default binding for this action is Return for #GtkEntry and Control-Return for #GtkText.)

@editable: the object which received the signal.

An action signal. Causes the characters in the current selection to be copied to the clipboard.

@editable: the object which received the signal.

An action signal. Causes the characters in the current selection to be copied to the clipboard and then deleted from the widget.

@editable: the object which received the signal.

An action signal. Delete a single character.

@editable: the object which received the signal. @direction: the direction in which to delete. Positive indicates forward deletion, negative, backwards deletion.

An action signal. Delete a single line.

@editable: the object which received the signal. @direction: the direction in which to delete. Positive indicates forward deletion, negative, backwards deletion.

An action signal. Delete a single word.

@editable: the object which received the signal. @direction: the direction in which to delete. Positive indicates forward deletion, negative, backwards deletion.

An action signal. Move the cursor position.

@editable: the object which received the signal. @x: horizontal distance to move the cursor. @y: vertical distance to move the cursor.

An action signal. Move the cursor by pages.

@editable: the object which received the signal. @x: Number of pages to move the cursor horizontally. @y: Number of pages to move the cursor vertically.

An action signal. Move the cursor to the given column.

@editable: the object which received the signal. @column: the column to move to. (A negative value indicates the last column)

An action signal. Move the cursor to the given row.

@editable: the object which received the signal. @row: the row to move to. (A negative value indicates the last row)

An action signal. Move the cursor by words.

@editable: the object which received the signal. @num_words: The number of words to move the cursor. (Can be negative).

An action signal. Causes the contents of the clipboard to be pasted into the editable widget at the current cursor position.

@editable: the object which received the signal.

Determines if the user can edit the text in the editable widget or not. This is meant to be overriden by child classes and should not generally useful to applications.

@editable: the object which received the signal. @is_editable: %TRUE if the user is allowed to edit the text in the widget.

A boolean indicating whether the widget is editable by the user.

The position of the cursor.

A simple function pointer to get invoked when the signal is emitted. This allows you tie a hook to the signal type, so that it will trap all emissions of that signal, from any object.

You may not attach these to signals created with the #GTK_RUN_NO_HOOKS flag.

@object: @signal_id: @n_params: @params: @data: @Returns:

@entry: the object which received the signal.

@entry: the object which received the signal. @arg1: @arg2:

@entry: the object which received the signal. @arg1: @event:

@entry: the object which received the signal. @arg1: @event:

@entry: the object which received the signal. @arg1: @arg2: @arg3:

@parent_class: @inserted_text: @deleted_text: @get_text: @get_length: @insert_text: @delete_text: @_gtk_reserved0: @_gtk_reserved1: @_gtk_reserved2: @_gtk_reserved3: @_gtk_reserved4: @_gtk_reserved5:

The #GtkFixedChild-struct struct contains the following fields. (These fields should be considered read-only. They should never be set by an application.)

#GtkWidget *widget; | the child #GtkWidget.
#gint x; | the horizontal position of the widget within the #GtkFixed container.
#gint y; | the vertical position of the widget within the #GtkFixed container.

@widget: @x: @y:

A set of bit flags used to specify the filter being set when calling gtk_font_selection_dialog_set_filter() or gtk_font_selection_set_filter().

@GTK_FONT_FILTER_BASE: the base filter, which can't be changed by the user. @GTK_FONT_FILTER_USER: the user filter, which can be changed from within the 'Filter' page of the #GtkFontSelection widget.

A set of bit flags used to specify the type of fonts shown when calling gtk_font_selection_dialog_set_filter() or gtk_font_selection_set_filter().

@GTK_FONT_BITMAP: bitmap fonts. @GTK_FONT_SCALABLE: scalable fonts. @GTK_FONT_SCALABLE_BITMAP: scaled bitmap fonts. @GTK_FONT_ALL: a bitwise combination of all of the above.

the #GtkAdjustment which sets the range of the scale.

A GtkImageLoader is used to load a filename found in a RC file.

@window: the window for creating image @colormap: the colormap for this image @mask: a pointer to the location to store the mask @transparent_color: the transparent color for the image @filename: filename to load @Returns: a #GtkPixmap representing @filename

@menubar: the object which received the signal. @arg1:

@notebook: the object which received the signal. @arg1: @arg2:

@notebook: the object which received the signal. @arg1: @arg2:

@notebook: the object which received the signal. @arg1: @arg2:

Setting this with a GtkType of GTK_TYPE_SIGNAL connects the signal to the object, so that the user data and objects and swapped when the signal handler is invoked.

This is useful for handlers that are primarily notifying other objects and could just invoke an already existing function if the parameters were swapped. See gtk_signal_connect_object() for more details.

Setting this with a GtkType of GTK_TYPE_SIGNAL connects the signal to the object, so that the user data and objects and swapped when the signal handler is invoked, and so that the handler is invoked after all others.

See gtk_signal_connect_object_after() for more details.

Setting this with a GtkType of GTK_TYPE_SIGNAL connects the signal to the object.

Setting this with a GtkType of GTK_TYPE_SIGNAL connects the signal to the object, so that the signal is always run after other user handlers and the default handler.

@oldeditable: the object which received the signal.

@oldeditable: the object which received the signal. @arg1: @arg2:

@oldeditable: the object which received the signal. @arg1: @arg2: @arg3:

@parent: @children: @spacing: @default_border_width: @default_pad_x: @default_pad_y: @default_i_pad_x: @default_i_pad_y:

@widget: @anchor: @side: @options: @use_default: @border_width: @pad_x: @pad_y: @i_pad_x: @i_pad_y:

@GTK_PACK_EXPAND: @GTK_FILL_X: @GTK_FILL_Y:

@match_type: @pattern_length: @pattern: @pattern_reversed: @user_data: @seq_id:

@PRIVATE_GTK_USER_STYLE: @PRIVATE_GTK_RESIZE_PENDING: @PRIVATE_GTK_RESIZE_NEEDED: @PRIVATE_GTK_LEAVE_PENDING: @PRIVATE_GTK_HAS_SHAPE_MASK: @PRIVATE_GTK_IN_REPARENT: @PRIVATE_GTK_DIRECTION_SET: @PRIVATE_GTK_DIRECTION_LTR:

A function which you can use to clean up when the signal handler is destroyed.

For example, if your handler requires a few variables that you made into a struct and allocated (using g_new() or something), then you will probably want to free it as soon as the hook is destroyed. This will allow you to do that. (For this in particular it is convenient to pass g_free() as a #GtkSignalDestroy function).

@data: The user data associated with the hook that is being destroyed.

This is currently a hack left in for a scheme wrapper library. It may be removed.

Don't use it.

@object: The object which emits the signal. @data: The user data associated with the hook. @nparams: The number of parameters to the function. @args: The actual values of the arguments. @arg_types: The types of the arguments. @return_type: The type of the return value from the function or #GTK_TYPE_NONE for no return value.

This structure contains all the information about a particular signal: its name, the type it affects, the signature of the handlers, and its unique identifying integer.

@object_type: @signal_id: @signal_name: @is_user_signal: @signal_flags: @return_val: @nparams: @params:

Holds the data for a statusbar message. text holds the actual text string. context_id is the context that this message is associated with, and message_id is this particular message's identifier. However, these fields should not be modified directly.

@text: @context_id: @message_id:

@parent_class: @realize: @unrealize: @copy: @clone: @init_from_rc: @set_background: @render_icon: @draw_hline: @draw_vline: @draw_shadow: @draw_polygon: @draw_arrow: @draw_diamond: @draw_string: @draw_box: @draw_flat_box: @draw_check: @draw_option: @draw_tab: @draw_shadow_gap: @draw_box_gap: @draw_extension: @draw_focus: @draw_slider: @draw_handle: @draw_expander: @draw_layout: @draw_resize_grip: @_gtk_reserved1: @_gtk_reserved2: @_gtk_reserved3: @_gtk_reserved4: @_gtk_reserved5: @_gtk_reserved6: @_gtk_reserved7: @_gtk_reserved8: @_gtk_reserved9: @_gtk_reserved10: @_gtk_reserved11: @_gtk_reserved12:

The widget field is a pointer to the widget that this %GtkTableChild structure is keeping track of. The left_attach, right_attach, top_attach, and bottom_attach fields specify the row and column numbers which make up the invisible rectangle that the child widget is packed into.

xpadding and ypadding specify the space between this widget and the surrounding table cells.

@widget: @left_attach: @right_attach: @top_attach: @bottom_attach: @xpadding: @ypadding: @xexpand: @yexpand: @xshrink: @yshrink: @xfill: @yfill:

These fields should be considered read-only and not be modified directly.

@requisition: @allocation: @spacing: @need_expand: @need_shrink: @expand: @shrink: @empty:

A #GtkJustification for the text. This is only used when the tag is applied to the first character in a paragraph.

Pixel width of the left margin of the text for lines after the first line in a wrapped paragraph.

Pixels to offset the text horizontally or vertically, useful to produce superscript and subscript.

@textview: the object which received the signal. @arg1:

@toolbar: the object which received the signal. @arg1: @Returns:

@GTK_TREE_SELECTION_SINGLE: @GTK_TREE_SELECTION_MULTI:

@treeview: the object which received the signal.

@tree_view: @context: @path: @user_data: @Returns:

@tree_view: @context: @path: @pos: @user_data: @Returns:

@uimanager: the object which received the signal.

the #GtkAdjustment which sets the range of the scale.

@widget: the object which received the signal. @arg1: @Returns:

@widget: the object which received the signal. @accel_signal_id: @accel_group: @accel_key: @accel_mods: @accel_flags:

@widget: the object which received the signal. @message:

@widget: the object which received the signal. @area:

@widget: the object which received the signal.

@widget: the object which received the signal.

@widget: the object which received the signal. @accel_group: @accel_key: @accel_mods:

@window: the object which received the signal.

@window: the object which received the signal. @arg1:

If the window shrinks automatically when widgets within it shrink.

@accel_group: @path: @accel_key: @accel_mods: @accel_flags: @object: @accel_signal:

@accel_group: @object:

@class_type: @signal_flags: @handler_offset: @Returns:

@class_type: @signal_flags: @handler_offset: @Returns:

@accel_group: @object:

@object: @Returns:

@Returns:

@accel_group: @accel_key: @accel_mods: @Returns:

@Returns:

@object: @accel_signal_id: @accel_group: @accel_key: @accel_mods: @accel_flags:

@object: @accel_group: @accel_key: @accel_mods:

@accel_group: @accel_key: @accel_mods:

@accel_group: @accel_key: @accel_mods: @object:

@accel_group: @accel_key: @accel_mods:

@accel_label: @Returns:

@accel_label: @accel_object:

@accel_path: @notify_data: @notify_func: @accel_group:

@accel_path: @notify_data: @notify_func:

It will either copy data into an existing argument or allocate a new argument and copy the data. Strings are duplicated. All other pointers and values are copied (shallowly-- that is the pointers themselves are copied, not the data they point to.)

You should call gtk_arg_reset() on dest_arg before calling this if the argument may contain string data that you want freed.

@src_arg: the argument to duplicate. @dest_arg: the argument to copy over (or NULL to create a new #GtkArg). @Returns: the new #GtkArg (or dest_arg, if it was not NULL).

Frees the argument, and optionally its contents.

@arg: the argument to free. @free_contents: whether to free the string, if it is a string.

Private: get information about an argument.

@object_type: the type of object. @arg_info_hash_table: the hashtable of #GtkArgInfos. @arg_name: the name of the argument to lookup. @info_p: the argument info. @Returns: an error message on failure, or NULL otherwise.

A #GCompareFunc for hashing #GtkArgInfos.

@arg_info_1: a #GtkArgInfo. @arg_info_2: a #GtkArgInfo. @Returns: whether the arguments are the same.

A #GHashFunc for hashing #GtkArgInfos.

@arg_info: a #GtkArgInfo. @Returns: a hash value for that #GtkArgInfo.

Given a fully qualified argument name (e.g. "GtkButton::label") it returns just the argument name (e.g. "label") unless the argument name was invalid, in which case it returns NULL.

@arg_name: the fully-qualified argument name. @Returns: the base argument name.

Creates a new argument of a certain type, set to 0 or NULL.

@arg_type: the type of the argument. @Returns: the newly created #GtkArg.

@arg:

@arg: @value_pointer:

Create a new argument registered with a class.

@base_class_type: the basic type having the arguments, almost alway GTK_TYPE_OBJECT, except if your defining a different type argument that gets a different namespace. #GtkContainer does this to define per-child arguments of the container. @arg_name: name of the argument to create. (must be a static constant string) @class_n_args_offset: offset into the base class structure that tells the number of arguments. @arg_info_hash_table: hashtable of #GtkArgInfos. @arg_type: type of the argument. @arg_flags: flags of the argument. @arg_id: ??? @Returns: the new #GtkArgInfo.

@arg1: @arg2: @Returns:

Private: given a hashtable of argument information it takes a vararg list and parses it into arguments (in the form of lists of #GtkArgs and lists of #GtkArgInfos.

The list of arguments starts with first_arg_name then the first argument's value. Followed by any number of additional name/argument pairs, terminated with NULL.

@object_type: the type of object we are collecting arguments for. @arg_info_hash_table: a hashtable mapping from names of arguments to their #GtkArgInfos. @arg_list_p: a returned list of arguments obtained from parsing the varargs. @info_list_p: a returned list of the #GtkArgInfos. @first_arg_name: the name of the first argument. @var_args: a va_list containing the value of the first argument, followed by name/value pairs, followed by NULL. @Returns: an error message on failure, or NULL otherwise.

Private: erase lists of arguments returned from gtk_args_collect().

@arg_list: arg_list_p returned from gtk_args_collect(). @info_list: info_list_p returned from gtk_args_collect().

Private: from a class type and its arginfo hashtable, get an array of #GtkArgs that this object accepts.

@class_type: the class type. @arg_info_hash_table: the hashtable of #GtkArgInfos. @arg_flags: returned array of argument flags. @n_args_p: the number of arguments this object accepts. @Returns: the array of arguments (or NULL on error).

This is an internally used function and should never be called from an application.

@widget: @nvis_children: @width: @height:

The internal padding of a button is the amount of space between the outside of the button and the widget it contains. This function gets the default amount of horizontal and vertical padding, placing the results in @ipad_x and @ipad_y, respectively.

@ipad_x: the default horizontal internal button padding. @ipad_y: the default vertical internal button padding.

Retrieves the default minimum width and height for all button boxes, and places the values in @min_width and @min_height, respectively.

@min_width: the default minimum width of a child widget. @min_height: the default minimum height of a child widget.

Sets the default number of pixels that pad each button in every button box.

@ipad_x: new default horizontal padding. @ipad_y: new default vertical padding.

Sets the default size of child buttons.

@min_width: minimum default width for child buttons. @min_height: minimum default height for child buttons.

@uline_label: @accel_group: @Returns:

@stock_id: @accel_group: @Returns:

@cell: @event: @widget: @path: @background_area: @cell_area: @flags: @Returns:

@Returns:

@cell_view: @Returns:

@cell_view: @cellview:

@cell_view: @use_fg:

Initializes a previously allocated #GtkCList widget for use. This should not normally be used to create a #GtkCList widget. Use gtk_clist_new() instead.

@clist: A pointer to an uninitialized #GtkCList widget. @columns: The number of columns the #GtkCList should have. @titles: An array of strings that should be used as the titles i of the columns. There should be enough strings in the array for the number of columns specified.

@colorsel: @color:

@colorsel: @Returns:

@colorsel: @Returns:

@colorsel: @color:

Controls whether opacity can be set with the #GtkColorSelection. If this functionality is enabled, the necessary additional widgets are added to the #GtkColorSelection and the opacity value can be retrieved via the fourth value in the color array returned by the gtk_color_selection_get_color() function.

@colorsel: a #GtkColorSelection. @use_opacity: a boolean indicating whether the opacity selection is enabled.

@colorsel: @use_opacity:

@colorsel: @use_palette:

@combo_box: @Returns:

@combo_box: @column:

@arg_name: @arg_type: @arg_flags: @arg_id:

@container: @widget: @first_arg_name: @Varargs:

@container: @widget: @n_args: @args:

@container: @child: @arg: @info:

@container: @child: @arg: @info:

@object_type: @arg_name: @info_p: @Returns:

@object_type: @arg_list_p: @info_list_p: @first_arg_name: @args: @Returns:

@container: @child: @n_args: @args:

@container: @child: @n_args: @args:

@container:

@container: @direction: @Returns:

@class_type: @arg_flags: @nargs: @Returns:

This function is not usually used by users.

@ctree: @columns: @tree_column: @titles:

@window:

@window:

@window: @x: @y: @width: @height:

@window: @title:

Internal function.

@toplevel: @event:

Internal function.

@widget: @event:

Causes the "changed" signal to be emitted.

@editable: a #GtkEditable widget.

Claim or disclaim ownership of the PRIMARY X selection.

@editable: a #GtkEditable widget. @claim: if %TRUE, claim the selection, otherwise, disclaim it. @time: the timestamp for claiming the selection.

@entry: @icon_pos: @Returns:

@entry: @icon_pos: @Returns:

@entry: @icon_pos: @Returns:

@entry: @icon_pos: @Returns:

@Returns:

@chooser: @Returns:

@chooser: @folder_mode:

Sets one of the two font filters, to limit the fonts shown.

@fsd: a #GtkFontSelectionDialog. @filter_type: which of the two font filters to set, either #GTK_FONT_FILTER_BASE or #GTK_FONT_FILTER_USER. The user filter can be changed by the user, but the base filter is permanent. @font_type: the types of font to be shown. This is a bitwise combination of #GTK_FONT_BITMAP, #GTK_FONT_SCALABLE and #GTK_FONT_SCALABLE_BITMAP, or #GTK_FONT_ALL to show all three font types. @foundries: a NULL-terminated array of strings containing foundry names which will be shown, or NULL to show all foundries. @weights: a NULL-terminated array of strings containing weight names which will be shown, or NULL to show all weights. @slants: a NULL-terminated array of strings containing slant names which will be shown, or NULL to show all slants. @setwidths: a NULL-terminated array of strings containing setwidth names which will be shown, or NULL to show all setwidths. @spacings: a NULL-terminated array of strings containing spacings which will be shown, or NULL to show all spacings. @charsets: a NULL-terminated array of strings containing charset names which will be shown, or NULL to show all charsets.

@fontsel: @Returns:

@fontsel: @Returns:

Sets one of the two font filters, to limit the fonts shown.

@fontsel: a #GtkFontSelection. @filter_type: which of the two font filters to set, either #GTK_FONT_FILTER_BASE or #GTK_FONT_FILTER_USER. The user filter can be changed by the user, but the base filter is permanent. @font_type: the types of font to be shown. This is a bitwise combination of #GTK_FONT_BITMAP, #GTK_FONT_SCALABLE and #GTK_FONT_SCALABLE_BITMAP, or #GTK_FONT_ALL to show all three font types. @foundries: a NULL-terminated array of strings containing foundry names which will be shown, or NULL to show all foundries. @weights: a NULL-terminated array of strings containing weight names which will be shown, or NULL to show all weights. @slants: a NULL-terminated array of strings containing slant names which will be shown, or NULL to show all slants. @setwidths: a NULL-terminated array of strings containing setwidth names which will be shown, or NULL to show all setwidths. @spacings: a NULL-terminated array of strings containing spacings which will be shown, or NULL to show all spacings. @charsets: a NULL-terminated array of strings containing charset names which will be shown, or NULL to show all charsets.

@Returns:

Get the type of GtkIdentifier.

@Returns: GtkType -- the enumerated type of something.

@image_menu_item: @child:

@Returns:

@path_pspec: @modified_only: @print_func: @func_data:

@file_name: @path_pspec: @modified_only:

@file_name:

@scanner:

@rc_string:

@FILE_pointer: @string:

@label: @str: @Returns:

@store: @iter: @position:

@n_columns: @Varargs: @Returns:

@store: @iter: @column: @value:

@store: @column: @type:

@store: @n_columns:

@menu: @Returns:

@menu: @Returns:

Sets whether the menu item should show a submenu indicator, which is a right arrow.

@menu_item: the menu item @show_toggle_indicator: unused @show_submenu_indicator: whether to show the arrow or not

Specifies the placement of the submenu around the menu item. The placement is usually #GTK_LEFT_RIGHT for menu items in a popup menu and #GTK_TOP_BOTTOM in menu bars.

This function is useless in usual applications.

@menu_item: the menu item @placement: the submenu placement

Private function to get an argument and argument info from an object.

@object: the object whose argument should be retrieved. @arg: the argument, for the name on input, the rest is filled on output. @info: a #GtkArgInfo structure to optionally fill in.

Query information about an argument type.

@object_type: type of object to query about. @arg_name: name of the argument. @info_p: pointer to be filled in with a pointer to the GtkArgInfo. @Returns: an error message, or NULL on success. It is the caller's responsibility to call g_free() in the event of error.

Private function to set an argument and argument info to an object.

@object: the object whose argument should be set. @arg: the argument. @info: infomation about this type of argument in general.

Private: Gets an array of #GtkArgs from a va_list C structure.

@object_type: the type of object to collect arguments for. @arg_list_p: pointer to be filled in with a list of parsed arguments. @info_list_p: optional pointer for a returned list #GtkArgInfos. @first_arg_name: name of first argument. @var_args: value of first argument, followed by more key/value pairs, terminated by NULL. @Returns: an error message, or NULL on success. It is the caller's responsibility to call g_free() in the event of error.

Add an array of signals to a #GtkObjectClass. Usually this is called when registering a new type of object.

@klass: the object class to append signals to. @signals: the signals to append. @nsignals: the number of signals being appended.

Define a signal-handler for a new signal on an already defined object.

See the signal documentation for more general information.

@klass: the object class to define the signal for. @name: the name of the signal. @signal_flags: the default emission behavior for the signal. See gtk_signal_new(). @marshaller: a function that will take an array of GtkArgs and invoke the appropriate handler with the normal calling conventions. @return_val: specify the return-value type for the signal (or GTK_TYPE_NONE for no return-value). @nparams: specify the number of parameters the signal receives from the caller of gtk_signal_emit(). @Varargs: list of nparams #GtkTypes to pass to the signal handlers. @Returns: the signal id. (See #GtkSignals)

Define a signal-handler for a new signal on an already defined object.

@klass: the object class to define the signal for. @name: the name of the signal. @signal_flags: the default emission behavior for the signal. See gtk_signal_new(). @marshaller: takes a GtkObject, a #GtkSignalFunc, and an array of arguments, and invokes the function using the appropriate calling conventions. Usually just select a function out of gtkmarshal.h. @return_val: specify the return-value type for the signal (possibly #GTK_TYPE_NONE). @nparams: specify the number of parameters the signal receives from the caller of gtk_signal_emit(). @params: array of #GtkTypes the signal handlers for this signal should have in their prototype (of length nparams). @Returns: the signal id. (See #GtkSignals)

Mark an allocated object as constructed. This is used for situations that require precise control of the construction process.

This is done when gtk_object_default_construct() is inadequate. In #GtkCList the need arises because #GtkCList does construction work that must happen after its derivers. This work cannot be done in an initializer function, so an alternate constructor is mandatory. It calls gtk_object_constructed() to indicate it has done its job, so that no other constructor will be invoked.

Normally this function is just automatically run from gtk_object_default_construct().

@object: object which has been constructed. This is usually done automatically by gtk_object_new() and gtk_object_newv().

This function is called to construct arguments that haven't been initialized but have the #GTK_ARG_CONSTRUCT flag set.

All number arguments are set to 0. All pointers and strings are set to NULL.

Normally invoked by gtk_object_new() automatically; gtk_type_new() can be used to bypass it.

@object: the object to initialize.

Gets an array of argument values from an object.

@object: the object to get arguments from. @n_args: the number of arguments to query. @args: the arguments to fill in.

Construct an object with an array of arguments.

@object_type: the type of the object to create. @n_args: the number of arguments to set. @args: an array of n_args arguments (which are name and value pairs). @Returns: the new GtkObject.

Get all the arguments that may be used for a given type.

In Java, this type of mechanism is called introspection. It is used by applications like Glade, that have to determine what can be done to an object at run-time.

@class_type: the GtkType of the ObjectClass (returned from GTK_OBJECT_CLASS(class)->type for example). @arg_flags: if non-NULL, obtains the #GtkArgFlags that apply to each argument. You must g_free() this if you request it. @n_args: the number of arguments is returned in this field. @Returns: an array of arguments, that you must deallocate with g_free().

Set an array of arguments.

@object: the object whose arguments should be set. @n_args: the number of arguments to set. @args: the desired values, as an array of #GtkArgs (which contain the names, types, and values of the arguments).

@packer: @child: @side: @anchor: @options: @border_width: @pad_x: @pad_y: @i_pad_x: @i_pad_y:

@packer: @child: @side: @anchor: @options:

@Returns:

@packer: @child: @position:

@packer: @child: @side: @anchor: @options: @border_width: @pad_x: @pad_y: @i_pad_x: @i_pad_y:

@packer: @border:

@packer: @i_pad_x: @i_pad_y:

@packer: @pad_x: @pad_y:

@packer: @spacing:

Internal function used by #GtkHPaned and #GtkVPaned

@paned: @allocation: @child1_req: @child2_req:

Old name for gtk_paned_set_handle_size().

Set the the handle size to @size x @size pixels.

@paned: a paned widget @size: the size in pixels

@pspec: @string_length: @string: @string_reversed: @Returns:

@pattern: @string: @Returns:

@pspec: @string: @Returns:

@pspec:

@pspec: @pattern:

@context: @Returns:

@context: @Returns:

@context: @Returns:

@context: @Returns:

@op: @n_pages:

@settings: @Returns:

@settings: @Returns:

@settings: @num_copies:

@settings: @print_to_file:

Internal function.

Internal function. Loads an image using the current image loader.

@colormap: the colormap to use for the image @transparent_color: the transparent color for the image @filename: the filename of the image file @Returns: a #GtkPixmap representing @filename

Sets the function that GTK+ will use to load images

@loader: the #GtkImageLoader to use

@ruler: the gtkruler

@ruler: the gtkruler

Internal function.

@window: @event: @Returns:

Internal function.

@widget: @event: @Returns:

Internal function.

@widget: @event: @Returns:

Internal function.

@widget: @event: @Returns:

@Returns:

Add an emission hook for a type of signal, for any object.

@signal_id: the type of signal to hook for. @hook_func: the function to invoke to handle the emission hook. @data: the user data passed in to hook_func. @Returns: the id (that you may pass as a parameter to gtk_signal_remove_emission_hook()). @i: @h: @d:

Add an emission hook for a type of signal, for any object. (with control of what happens when the hook is destroyed).

@signal_id: the type of signal add the hook for. @hook_func: the function to invoke to handle the hook. @data: the user data passed in to hook_func. @destroy: a function to invoke when the hook is destroyed, to clean up any allocation done just for this signal handler. @Returns: the id (that you may pass as a parameter to gtk_signal_remove_emission_hook()).

Returns whether a connection id is valid (and optionally not blocked).

@object: the object to search for the desired handler. @handler_id: the connection id. @may_be_blocked: whether it is acceptable to return a blocked handler. @Returns: TRUE if the signal exists and wasn't blocked, unless #may_be_blocked was specified. FALSE otherwise.

Destroy all the signal handlers connected to an object. This is done automatically when the object is destroyed.

This function is labeled private.

@object: the object whose signal handlers should be destroyed.

Find out the recursion depth of emissions for a particular type of signal and object. (So it will always return 0 or 1 if #GTK_RUN_NO_RECURSE is specified) This is a way to avoid recursion: you can see if you are currently running in that signal handler and emit it only if you are.

Another way to look at it is that this number increases by one when #gtk_signal_emit(), et al, are called, and decreases by one when #gtk_signal_emit() returns.

@object: the object with the signal handler. @signal_id: the signal id. @Returns: the recursion depth of emissions of this signal for this object.

Find out the recursion depth of emissions for a particular type of signal and object. Just like gtk_signal_n_emissions() except it will lookup the signal id for you.

@object: the object with the signal handler. @name: the signal name. @Returns: the recursion depth of emissions of this signal for this object.

Obtain information about a signal.

@signal_id: the signal type identifier. @Returns: a pointer to a GtkSignalQuery structure which contains all the information, or NULL. The pointer is allocated just for you: you must g_free() it.

Delete an emission hook. (see gtk_signal_add_emission_hook())

@signal_id: the id of the signal type. @hook_id: the id of the emission handler, returned by add_emission_hook(). @i: @h:

These set default functions to call when the user didn't supply a function when connecting. (These are rarely used, and probably only for language bindings)

By default, there are no such functions.

@marshal_func: the function to invoke on every handlers for which there isn't a function pointer. May be NULL. @destroy_func: the function to invoke when each hook is destroyed. May be NULL.

Creates a border around the arrows of a #GtkSpinButton. The type of border is determined by @shadow_type.

@spin_button: a #GtkSpinButton @shadow_type: the new border type.

@Returns:

@display: @style: @Returns:

@style: @widget_type: @property_name: @value:

@buffer: @override_location: @default_editable:

@first: @second:

@iter: @desc:

@text_view: @width: @height:

@Returns:

@tool_item: @Returns:

@tool_item: @pack_end:

Private: print debugging information while doing a gtk_object_ref() or a gtk_object_unref().

@object: object to reference or unreference. @func: name of caller's function to print (used within macros). @dummy: unused. @line: line number (used within macros). @do_ref: whether to reference or unreference.

@tree_model: @iter:

@tree_model_sort: @sort_iter: @child_iter:

@tree_model_sort: @child_path: @Returns: @path:

@Returns:

@tree_model_sort: @func:

@tree_model_sort: @child_model: @model:

@tree_model_sort: @sort_col:

@tree_model: @iter:

@tree_store: @iter: @position:

@n_columns: @Varargs: @Returns:

@tree_store: @iter: @column: @value:

@tree_store: @column: @type: @store:

@tree_store: @n_columns:

@tree_column: @event: @path_string: @background_area: @cell_area: @flags: @Returns:

@tree_column: @tree_model: @iter:

@tree_column: @cell:

@tree_column: @width: @size:

@tree_view: @targets: @n_targets: @actions: @location_droppable_func: @user_data:

@tree_view: @start_button_mask: @targets: @n_targets: @actions: @row_draggable_func: @user_data:

Given a GtkTypeClass pointer @klass, and a GtkType @cast_type, make sure that it's okay to cast something of that @klass into a @cast_type.

@klass: GtkTypeClass* @cast_type: GtkType @Returns: Always return @klass.

Given a pointer to a GtkTypeObject @type_object, and a GtkType @cast_type, make sure that it's okay to cast @type_object into a @cast_type.

@type_object: GtkTypeObject* @cast_type: GtkType @Returns: the same GtkTypeObject* as @type_object

Return the pointer to the type's children's types.

@type: GtkType @Returns: pointer to a GList

Print the types @type inherits from.

@type: GtkType

Given a @type, describe all of its children, and their children. Only show the size if @show_size is true.

@type: GtkType @show_size: gboolean

Given the type of an object and a pointer to it, the object is freed.

@type: GtkType @mem: gpointer to the object

Get the varargs type associated with @foreign_type

@foreign_type: GtkType @Returns: GtkType

Return the class of the parent. Initialize the class if necessary. Return NULL if anything goes wrong.

@type: GtkType @Returns: gpointer to the klass.

Given a type, return various interesting parameters of the type.

@type: GtkType @Returns: GtkTypeQuery*

Register a new set of enum @values and give them the name in @type_name.

@type_name: must not be null. @values: GtkEnumValue* @Returns:

Register a new set of flags @values and give them the name in @type_name.

@type_name: must not be null. @values: GtkFlagValue* @Returns:

Set the mem_chunk size so it will hold @n_chunks of the objects of that @type.

@type: There must be an unlocked TypeNode associated with this type otherwise nothing happens. @n_chunks:

Set the varargs type for a fundamental type @foreign_type.

@foreign_type: Must be a GtkType with a sequence number of zero. Must not be a fundamental type. @varargs_type: Must be a GtkType which is either structured or flag, or NONE.

@widget: @accel_group: @accel_key: @accel_mods: @Returns:

@widget: @Returns:

@widget: @group_cycling: @Returns:

@widget: @width: @height:

@widget:

@widget: @x: @y:

@style:

@widget: @accel_signal: @visible_only:

@style:

@widget:

@window: @keyval: @modifier: @Returns:

@window: @Returns:

@window: @Returns:

@window: @Returns:

@window: @decorations:

@window: @functions:

@window: @setting: @resizeable: