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 g_signal_emit() or g_signal_new().
However if you are writing a function to emit or create an arbitrary
signal, you must use g_signal_emitv() or g_signal_newv().
#GtkObject.
Utility function to manipulate lists of named, typed arguments.
Implementation of Object Properties
GtkCellRendererTextPixbuf
The #GtkCList widget is a very useful multi-columned scrolling list.
It can display data in nicely aligned vertical columns, with titles
at the top of the list.
GtkCList has been deprecated since GTK+ 2.0 and should not be used
in newly written code. Use #GtkTreeView instead.
A multi-columned scrolling list widget
GtkCList
The #GtkCombo widget consists of a single-line text entry field and a drop-down
list. The drop-down list is displayed when the user clicks on a small arrow
button to the right of the entry field.
The drop-down list is a #GtkList widget and can be accessed using the
list member of the #GtkCombo-struct.
List elements can contain arbitrary widgets, but if an element is not a
plain label, then you must use the gtk_list_set_item_string() function.
This sets the string which will be placed in the text entry field when the
item is selected.
By default, the user can step through the items in the list using the
arrow (cursor) keys, though this behaviour can be turned off with
gtk_combo_set_use_arrows().
As of GTK+ 2.4, #GtkCombo has been deprecated in favor of #GtkComboBoxEntry.
Creating a <structname>GtkCombo</structname> widget with simple text
items.
GtkWidget *combo;
GList *items = NULL;
items = g_list_append (items, "First Item");
items = g_list_append (items, "Second Item");
items = g_list_append (items, "Third Item");
items = g_list_append (items, "Fourth Item");
items = g_list_append (items, "Fifth Item");
combo = gtk_combo_new ();
gtk_combo_set_popdown_strings (GTK_COMBO (combo), items);
Creating a <structname>GtkCombo</structname> widget with a complex item.
GtkWidget *combo, *item, *hbox, *arrow, *label;
combo = gtk_combo_new ();
item = gtk_list_item_new ();
gtk_widget_show (item);
/* You can put almost anything into the GtkListItem widget. Here we will use
a horizontal box with an arrow and a label in it. */
hbox = gtk_hbox_new (FALSE, 3);
gtk_container_add (GTK_CONTAINER (item), hbox);
gtk_widget_show (hbox);
arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_widget_show (arrow);
gtk_box_pack_start (GTK_BOX (hbox), arrow, FALSE, FALSE, 0);
label = gtk_label_new ("First Item");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
/* You must set the string to display in the entry field when the item is
selected. */
gtk_combo_set_item_string (GTK_COMBO (combo), GTK_ITEM (item), "1st Item");
/* Now we simply add the item to the combo's list. */
gtk_container_add (GTK_CONTAINER (GTK_COMBO (combo)->list), item);
A text entry field with a dropdown list
GtkCombo
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
#GtkFileSelection has been superseded by the newer #GtkFileChooser family
of widgets.
#GtkFileSelection should be used to retrieve file or directory names from
the user. It will create a new dialog window containing a directory list,
and a file list corresponding to the current working directory. The filesystem
can be navigated using the directory list or the drop-down history menu.
Alternatively, the TAB key can be used to navigate using filename
completion - common in text based editors such as emacs and jed.
File selection dialogs are created with a call to gtk_file_selection_new().
The default filename can be set using gtk_file_selection_set_filename() and the selected filename retrieved using gtk_file_selection_get_filename().
Use gtk_file_selection_complete() to display files and directories
that match a given pattern. This can be used for example, to show only
*.txt files, or only files beginning with gtk*.
Simple file operations; create directory, delete file, and rename file, are available from buttons at the top of the dialog. These can be hidden using gtk_file_selection_hide_fileop_buttons() and shown again using gtk_file_selection_show_fileop_buttons().
Getting a filename from the user.
/* The file selection widget and the string to store the chosen filename */
void store_filename (GtkWidget *widget, gpointer user_data) {
GtkWidget *file_selector = GTK_WIDGET (user_data);
const gchar *selected_filename;
selected_filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_selector));
g_print ("Selected filename: %s\n", selected_filename);
}
void create_file_selection (void) {
GtkWidget *file_selector;
/* Create the selector */
file_selector = gtk_file_selection_new ("Please select a file for editing.");
g_signal_connect (GTK_FILE_SELECTION (file_selector)->ok_button,
"clicked",
G_CALLBACK (store_filename),
file_selector);
/* Ensure that the dialog box is destroyed when the user clicks a button. */
g_signal_connect_swapped (GTK_FILE_SELECTION (file_selector)->ok_button,
"clicked",
G_CALLBACK (gtk_widget_destroy),
file_selector);
g_signal_connect_swapped (GTK_FILE_SELECTION (file_selector)->cancel_button,
"clicked",
G_CALLBACK (gtk_widget_destroy),
file_selector);
/* Display that dialog */
gtk_widget_show (file_selector);
}
#GtkDialogAdd your own widgets into the #GtkFileSelection.
Prompt the user for a file or directory name
GtkFileSelection
As of GTK+ 2.4, #GtkItemFactory has been deprecated in favour of #GtkUIManager.
A factory for menus
GtkItemFactory
The #GtkList widget is a container whose children are displayed
vertically in order, and can be selected.
The list has many selection modes, which are programmer selective and
depend on how many elements are able to be selected at the same time.
GtkList has been deprecated since GTK+ 2.0 and should not be used
in newly written code. Use #GtkTreeView instead.
#GtkContainerFor functions that apply to every #GtkContainer
(like #GtkList).#GtkListitemChildren of a #GtkList widget must be of this
type.
Widget for packing a list of selectable items
GtkList
The #GtkListItem widget is used for each item in a #GtkList.
GtkList has has been deprecated since GTK+ 2.0 and should not be used
in newly written code. Use #GtkTreeView instead.
#GtkListthe parent list widget.
An item in a GtkList
GtkListItem
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 g_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);
}
#GtkSignalThe signal handling functions (of which marshallers are
really an implementation detail).
Functions to adapt C structures to native calling convention.
Signal Marshallers
GtkPacker
The #GtkPreview widget provides a simple interface
used to display images as RGB or grayscale data.
It's deprecated; just use a #GdkPixbuf displayed by a #GtkImage, or
perhaps a #GtkDrawingArea. #GtkPreview has no advantage over those
approaches.
#GdkRGBthe backend used by #GtkPreview.
A widget to display RGB or grayscale data
GtkPreview
Private Information
Themes
The #GtkTipsQuery widget is a subclass of #GtkLabel which is used to display
help about widgets in a user interface.
A query is started with a call to gtk_tips_query_start_query(), usually
when some kind of 'Help' button is pressed. The #GtkTipsQuery then grabs all
events, stopping the user interface from functioning normally.
Then as the user moves the mouse over the widgets, the #GtkTipsQuery displays
each widget's tooltip text.
By connecting to the "widget-entered" or "widget-selected" signals, it is
possible to customize the #GtkTipsQuery to perform other actions when widgets
are entered or selected. For example, a help browser could be opened with
documentation on the widget selected.
At some point a call to gtk_tips_query_stop_query() must be made in order to
stop the query and return the interface to its normal state.
The gtk_tips_query_set_caller() function can be used to specify a widget
which the user can select to stop the query (often the same button used to
start the query).
#GtkTooltipsthe object which handles tooltips.
Displays help about widgets in the user interface
GtkTipsQuery
GtkModelSimple
A macro to cast a generic #GtkCList cell item to a GtkCellPixmap pointer.
@cell: The #GtkCList cell item to convert.
A macro to cast a generic #GtkCList cell item to a GtkCellPixText pointer.
@cell: The #GtkCList cell item to convert.
A macro to cast a generic #GtkCList cell item to a GtkCellText pointer.
@cell: The #GtkCList cell item to convert.
A macro to cast a generic #GtkCList cell item to a GtkCellWidget pointer.
@cell: The #GtkCList cell item to convert.
Casts the object in @tobj into @cast. If %G_DISABLE_CAST_CHECKS is
defined, just cast it. Otherwise, check to see if we can cast @tobj
into a @cast.
Casts the object in @tobj into @cast. If %G_DISABLE_CAST_CHECKS is
defined, just cast it. Otherwise, check to see if we can cast @tobj
into a @cast.
@tclass: a #GtkClassInitFunc
@cast_type: a GTK+ type.
@cast: a C type
Determines whether @type_class is a type of @otype.
@type_class: a #GtkTypeClass class.
Gets the class of @tobj.
@tobj: a #GtkObject.
Determines whether @type_object is a type of @otype.
@type_object: a #GtkTypeObject object
Returns the type name of @class.
@class: a #GtkTypeClass.
@Deprecated: Use g_type_name() and G_TYPE_FROM_CLASS() instead.
Returns the type of @class.
@class: a #GtkTypeClass.
@Deprecated: Use G_TYPE_FROM_CLASS() instead.
A macro to test whether the CList is in "add mode."
@clist: The #GtkCList widget to check.
A macro to check if automatic resizing of columns is blocked.
@clist: The #GtkCList widget to check.
A macro to test whether the CList has automatic sorting
switched on.
@clist: The #GtkCList widget to check.
A macro to check whether a child widget of the CList
has the focus.
@clist: The #GtkCList widget to check.
A macro to check if the DRAW_DRAG_LINE property is enabled.
@clist: The #GtkCList widget to check.
A macro to check if the DRAW_DRAG_RECT property is enabled.
@clist: The #GtkCList widget to check.
Reads the current flags of the specified CList.
@clist: The #GtkCList widget from which to get the flags
A macro to check whether the #GtkCList is in "drag mode."
@clist: The #GtkCList to check.
A macro to test if the CList's columns are re-orderable
@clist: The #GtkCList widget to check.
A macro to cast a GList element to a CListRow pointer.
@_glist_: The GList element to convert.
A macro to check whether the #GtkCList's row height is set.
@clist: The #GtkCList to check.
A macro to set a particular flag for the specified CList.
@clist: The #GtkCList widget to affect.
@flag: A single #GtkCList flag to set. NOTE: Do not add the GTK_ prefix.
A macro to check whether the flag for showing the
widget's column titles is set.
@clist: The #GtkCList widget to check.
A macro to clear a particular flag for the specified CList.
@clist: The #GtkCList widget to affect.
@flag: A single #GtkCList flag to clear. NOTE: Do not add the GTK_ prefix.
A macro to check if the USE_DRAG_ICONS property is enabled.
@clist: The #GtkCList widget to check.
Converts a GTK+ type into a fundamental type.
@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.
Evaluates to %TRUE if the object still has its floating reference count.
See the overview documentation for #GtkObject.
@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.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_BOOL.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_BOXED.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_CHAR.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_DOUBLE.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_ENUM.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_FLAGS.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_FLOAT.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_INT.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_LONG.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_OBJECT.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_POINTER.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_STRING.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_UCHAR.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_UINT.
@a: a #GtkArg.
If the #GtkArg contains a pointer to the value, this macro will be a pointer to a %GTK_TYPE_ULONG.
@a: a #GtkArg.
Just a macroized cast into a #GtkSignalFunc.
@f:
Use in place of offsetof(), which is used if it exists.
@Deprecated: Use G_STRUCT_OFFSET() instead.
@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.
The highest-numbered structured or flat enumerated type value.
@Deprecated: Use #G_TYPE_LAST_RESERVED_FUNDAMENTAL - 1 instead.
The maximum fundamental enumerated type value.
@Deprecated: Use #G_TYPE_FUNDAMENTAL_MAX instead.
Hide the name of gtk_identifier_get_type
Returns %TRUE if @type is a %GTK_TYPE_OBJECT.
@type: a #GtkType.
@Deprecated: Use G_TYPE_IS_OBJECT() instead.
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:
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_BOOL.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_BOXED.
@a: a #GtkArg.
Use to get the value of a GtkArg whose GtkType is GTK_TYPE_CALLBACK
@a:
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_CHAR.
@a: a #GtkArg.
Use to get the value of a GtkArg whose GtkType is GTK_TYPE_C_CALLBACK
@a:
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_DOUBLE.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_ENUM.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_FLAGS.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_FLOAT.
@a: a #GtkArg.
Use to get the value of a GtkArg whose GtkType is GTK_TYPE_C_FOREIGN
@a:
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_INT.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_LONG.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_OBJECT.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_POINTER.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_SIGNAL.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_STRING.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_UCHAR.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_UINT.
@a: a #GtkArg.
Gets the value of a #GtkArg whose #GtkType is %GTK_TYPE_ULONG.
@a: a #GtkArg.
@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:
Possible flags indicating how an argument should be treated.
@GTK_ARG_READABLE: the argument is readable. (i.e. can be queried)
@GTK_ARG_WRITABLE: the argument is writable. (i.e. settable)
@GTK_ARG_CONSTRUCT: the argument needs construction.
@GTK_ARG_CONSTRUCT_ONLY: the argument needs construction (and will
be set once during object creation), but is otherwise cannot be
set. Hence this flag is not allowed with #GTK_ARG_WRITABLE,
and is redundant with #GTK_ARG_CONSTRUCT.
@GTK_ARG_CHILD_ARG: an argument type that applies to (and may be different for)
each child. Used by #GtkContainer.
@Deprecated: Use corresponding #GParamSpec features instead
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.
Values for specifying what mouse button events a CList will
react to.
@GTK_BUTTON_IGNORED:
@GTK_BUTTON_SELECTS:
@GTK_BUTTON_DRAGS:
@GTK_BUTTON_EXPANDS:
This is the embodiment of the #GtkCList widget. This structure contains
only private data, and should be accessed only via the CList API.
This signal is emitted when a column resize is aborted.
@clist: the object which received the signal.
This signal is emitted when a column title is clicked.
@clist: The object which received the signal.
@column: The number of the column.
This signal is emitted when a selection ends in a
multiple selection CList.
@clist: the object which received the signal.
This signal is emitted when the selection is extended.
@clist: the object which received the signal.
@scroll_type: A #GtkScrollType value of any scrolling operation the
occured during the selection.
@position: A value between 0.0 and 1.0.
@auto_start_selection: %TRUE or %FALSE.
This signal is emitted when a column is resized.
@clist: The object which received the signal.
@column: The number of the column
@width: The new width of the column.
This signal is emitted when a row is moved.
@clist: The object which received the signal.
@arg1: The source position of the row.
@arg2: The destination position of the row.
This signal is emitted when the CList is scrolled horizontally.
@clist: the object which received the signal.
@scroll_type: A #GtkScrollType value of how the scroll operation occured.
@position: a value between 0.0 and 1.0.
This signal is emitted when the CList is scrolled vertically.
@clist: the object which received the signal.
@scroll_type: A #GtkScrollType value of how the scroll operation occured.
@position: A value between 0.0 and 1.0.
This signal is emitted when all the rows are selected in a CList.
@clist: the object which received the signal.
This signal is emitted when the user selects a row in the list.
It is emitted for every row that is selected in a multi-selection or
by calling gtk_clist_select_all().
@clist: The object which received the signal.
@row: The row selected.
@column: The column where the selection occured.
@event: A #GdkEvent structure for the selection.
@clist: the object which received the signal.
@arg1:
@arg2:
This signal is emitted when a drag-selection is started in
a multiple-selection CList.
@clist: the object which received the signal.
This signal is emitted when "add mode" is toggled.
@clist: the object which received the signal.
@clist: The object which received the signal.
This signal is emitted when an undo selection occurs in the CList,
probably via calling gtk_clist_undo_selection().
@clist: the object which received the signal.
This signal is emitted when all rows are unselected in a CList.
@clist: the object which received the signal.
This signal is emitted when the user unselects a row in the list.
It is emitted for every row that is unselected in a multi-selection or
by calling gtk_clist_unselect_all(). It is also emitted for the
previously selected row in a "single" or "browse" mode CList.
@clist: The object which received the signal.
@row: The selected row
@column: The column where the selection occured.
@event:
An integer value for a column.
A boolean value for determining if the user can re-order the CList's
columns.
An integer value representing the height of a row in pixels.
Sets the type of selection mode for the CList.
Sets the shadowing for the CList.
A boolean value for setting whether the column titles can be
clicked.
A boolean value for setting whether to use icons during drag
operations.
A simple structure that the #GtkCList widget uses to keep track
of the location of a cell.
@row:
@column:
A structure that the #GtkCList widget uses to keep track of information
about its columns.
@title:
@area:
@button:
@window:
@width:
@min_width:
@max_width:
@justification:
@visible:
@width_set:
@resizeable:
@auto_resize:
@button_passive:
Function prototype for the compare function callback.
@clist: The #GtkCList that is affected.
@ptr1: A #gconstpointer to the first node to compare.
@ptr2: A #gconstpointer to the second node to compare.
@Returns: 0 if the nodes are equal, less than 0 if the first node should
come before the second, and greater than 1 if the second come before the
first.
A simple structure that the #GtkCList widget uses to track
a cell for a drag operation.
@cell:
@insert_pos:
An enumeration for drag operations.
@GTK_CLIST_DRAG_NONE:
@GTK_CLIST_DRAG_BEFORE:
@GTK_CLIST_DRAG_INTO:
@GTK_CLIST_DRAG_AFTER:
A structure that the #GtkCList widget uses to keep track of information
about its rows.
@cell:
@state:
@foreground:
@background:
@style:
@data:
@destroy:
@fg_set:
@bg_set:
@selectable:
A generic structure that the #GtkCList widget uses to keep track of the
contents of each of its cells.
@type:
@vertical:
@horizontal:
@style:
@widget:
A structure that the #GtkCList widget uses to keep track of #GtkCList cells
that contain a combination of text and a GdkPixmap.
@type:
@vertical:
@horizontal:
@style:
@text:
@spacing:
@pixmap:
@mask:
A structure that the #GtkCList widget uses to keep track of #GtkCList cells
that contain a GdkPixmap.
@type:
@vertical:
@horizontal:
@style:
@pixmap:
@mask:
@parent:
A structure that the #GtkCList widget uses to keep track of #GtkCList cells
that contain text.
@type:
@vertical:
@horizontal:
@style:
@text:
Identifies the type of element in the current cell of the CList. Cells can
contain text, pixmaps, or both. Unfortunately support for %GTK_CELL_WIDGET
was never completed.
@GTK_CELL_EMPTY:
@GTK_CELL_TEXT:
@GTK_CELL_PIXMAP:
@GTK_CELL_PIXTEXT:
@GTK_CELL_WIDGET:
A structure that the #GtkCList widget uses to keep track of #GtkCList cells
that contain another widget.
@type:
@vertical:
@horizontal:
@style:
@widget:
Defines a function pointer.
The #GtkCombo-struct struct contains the following fields.
(These fields should be considered read-only. They should never be set by
an application.)
@entry: the text entry field.
@list: the list shown in the drop-down window.
@Deprecated: 2.4: Use #GtkComboBox instead.
@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.
Defines a function pointer.
@data: #gpointer
This union not used in GTK+.
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:
A structure which contains a single enum value, and its name, and its
nickname.
The #GtkFileSelection struct contains the following #GtkWidget fields:
@dir_list:
@file_list:
@selection_entry:
@selection_text:
@main_vbox:
@ok_button:
@cancel_button: the two main buttons that signals should be connected
to in order to perform an action when the user hits either OK or
Cancel.
@help_button:
@history_pulldown: the #GtkOptionMenu used to create the drop-down
directory history.
@history_menu:
@history_list:
@fileop_dialog: the dialog box used to display the #GtkFileSelection.
It can be customized by adding/removing widgets from it using the
standard #GtkDialog functions.
@fileop_entry:
@fileop_file:
@cmpl_state:
@fileop_c_dir:
@fileop_del_file:
@fileop_ren_file: the buttons that appear at the top of the file
selection dialog. These "operation buttons" can be hidden and
redisplayed with gtk_file_selection_hide_fileop_buttons() and
gtk_file_selection_show_fileop_buttons() respectively.
@button_area:
@action_area:
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.
#GtkFundamentalType is an enumerated type which lists all the possible
fundamental types (e.g. char, uchar, int,
long, float, etc).
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
@callback_data:
@callback_action:
@widget:
@widget:
@callback_data:
@callback_action:
@path:
@accelerator:
@callback:
@callback_action:
@item_type:
@extra_data:
@path:
@widgets:
The child @widget has just been selected.
@list: the object which received the signal.
@widget: the newly selected child.
The selection of the widget has just changed.
@list: the object which received the signal.
The child @widget has just been unselected.
@list: the object which received the signal.
@widget: the newly unselected child.
The #GtkListItem struct contains private data only, and should
only be accessed using the functions below.
@listitem: the object which received the signal.
@listitem: the object which received the signal.
@scroll_type:
@position:
@auto_start_selection:
@listitem: the object which received the signal.
@scroll_type:
@position:
@listitem: the object which received the signal.
@scroll_type:
@position:
@listitem: the object which received the signal.
@listitem: the object which received the signal.
@listitem: the object which received the signal.
@listitem: the object which received the signal.
@listitem: the object which received the signal.
@listitem: the object which received the signal.
@GTK_MATCH_ALL:
@GTK_MATCH_ALL_TAIL:
@GTK_MATCH_HEAD:
@GTK_MATCH_TAIL:
@GTK_MATCH_EXACT:
@GTK_MATCH_LAST:
@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 g_signal_connect_swapped() 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 g_signal_connect_data() 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.
Defines a function pointer.
@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:
The #GtkPreview-struct struct contains private data only, and
should be accessed using the functions below.
Contains information about global properties
of preview widgets.
The #GtkPreviewInfo struct contains the following fields.
(These fields should be considered read-only. They should never be set by
an application.)
#GdkVisual *visual;the visual used by all previews.#GdkColormap *cmap;the colormap used by all previews.gdouble gamma;the gamma correction value used by all previews (See gtk_preview_set_gamma()).
@lookup:
@gamma:
An enumeration which describes whether a preview
contains grayscale or red-green-blue data.
@GTK_PREVIEW_COLOR: the preview contains red-green-blue data.
@GTK_PREVIEW_GRAYSCALE: The preview contains grayscale data.
@func_data:
@str:
@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:
@GTK_SIDE_TOP:
@GTK_SIDE_BOTTOM:
@GTK_SIDE_LEFT:
@GTK_SIDE_RIGHT:
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.
Defines a function pointer.
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.
Defines a function pointer.
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:
The #GtkTipsQuery-struct struct contains private data only, and
should be accessed using the functions below.
Emitted when the query is started.
@tipsquery: the object which received the signal.
Emitted when the query is stopped.
@tipsquery: the object which received the signal.
Emitted when a widget is entered by the pointer while the query is in effect.
@tipsquery: the object which received the signal.
@widget: the widget that was entered by the pointer.
@tip_text: the widget's tooltip.
@tip_private: the widget's private tooltip (see gtk_tooltips_set_tip()).
Emitted when a widget is selected during a query.
@tipsquery: the object which received the signal.
@widget: the widget that was selected.
@tip_text: the widget's tooltip.
@tip_private: the widget's private tooltip (see gtk_tooltips_set_tip()).
@event: the button press or button release event.
@Returns: %TRUE if the query should be stopped.
The widget that starts the tips query, usually a button.
If it is selected while the query is in effect the query is automatically
stopped.
%TRUE if the widget-entered and widget-selected signals are emitted even when
the widget has no tooltip set.
The text to display in the #GtkTipsQuery widget when the query is not in
effect.
The text to display in the #GtkTipsQuery widget when the query is running
and the widget that the pointer is over has no tooltip.
@toolitem: the object which received the signal.
@arg1:
@arg2:
@arg3:
@Returns:
@toolbar: the object which received the signal.
@arg1:
@Returns:
The function used to translate messages in e.g. #GtkIconFactory
and #GtkActionGroup.
@path: The id of the message. In #GtkItemFactory this will be a path
from a #GtkItemFactoryEntry, in #GtkActionGroup, it will be a label
or tooltip from a #GtkActionEntry.
@func_data: user data passed in when registering the function
@Returns: the translated message
@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:
#GtkType is unique integer identifying the type. The guts of the
information about the type is held in a private struct named
#GtkTypeNode.
The base structure for a GTK+ type. Every type inherits this as a base structure.
Holds information about the type. gtk_type_name() returns the name.
@object_size is somehow set to the number of bytes that an instance of
the object will occupy. @class_init_func holds the type's
initialization function. @object_init_func holds the initialization
function for an instance of the object. @reserved_1 is used for
#GtkEnumValue to hold the enumerated values.
@type_name:
@object_size:
@class_size:
@class_init_func:
@object_init_func:
@reserved_1:
@reserved_2:
@base_class_init_func:
A #GtkTypeObject defines the minimum structure requirements
for type instances. Type instances returned from gtk_type_new ()
and initialized through a #GtkObjectInitFunc need to directly inherit
from this structure or at least copy its fields one by one.
@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).
@binding_set:
@keyval:
@modifiers:
@scanner:
@Returns:
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:
@calendar:
@flags:
@calendar:
@calendar:
@cell:
@event:
@widget:
@path:
@background_area:
@cell_area:
@flags:
@Returns:
@Returns:
@cell_view:
@Returns:
@cell_view:
@Returns:
@cell_view:
@cellview:
@cell_view:
@use_fg:
Adds a row to the CList at the bottom.
@clist: The #GtkCList to affect.
@text: An array of strings to add.
@Returns: The number of the row added.
Removes all the CList's rows.
@clist: The #GtkCList to affect.
Sets the specified column in the #GtkCList to become selectable. You can
then respond to events from the user clicking on a title button, and take
appropriate action.
@clist: The #GtkCList to affect.
@column: The column to make active, counting from 0.
Causes the specified column title button to become passive, i.e., does
not respond to events, such as the user clicking on it.
@clist: The #GtkCList to affect.
@column: The column to make passive, counting from 0.
Causes all column title buttons to become active. This is the same
as calling gtk_clist_column_title_active() for each column.
@clist: The #GtkCList to affect.
Causes the #GtkCList to hide its column titles, if they are currently
showing.
@clist: The #GtkCList to affect.
Causes all column title buttons to become passive. This is the same
as calling gtk_clist_column_title_passive() for each column.
@clist: The #GtkCList to affect.
This function causes the #GtkCList to show its column titles, if
they are not already showing.
@clist: The #GtkCList to affect.
Auto-sizes all columns in the CList and returns the total width of the CList.
@clist: The #GtkCList to affect.
@Returns: The total width of the CList.
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.
Searches the CList for the row with the specified data.
@clist: The #GtkCList to search.
@data: The data to search for a match.
@Returns: The number of the matching row, or -1 if no match could be found.
Causes the #GtkCList to stop updating its visuals until a matching call to
gtk_clist_thaw() is made. This function is useful if a lot of changes
will be made to the widget that may cause a lot of visual updating to
occur. Note that calls to gtk_clist_freeze() can be nested.
@clist: The #GtkCList to freeze.
Gets the current style of the specified cell.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@Returns: A #GtkStyle object.
Checks the type of cell at the location specified.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@Returns: A #GtkCellType value describing the cell.
Gets the current title of the specified column
@clist: The #GtkCList to affect.
@column: The column to query.
@Returns: The title of the column.
Gets the widget in the column header for the specified column.
@clist: The #GtkCList to affect.
@column: The column to query.
@Returns: Pointer to a #GtkWidget for the column header.
Gets the #GtkAdjustment currently being used for the horizontal
aspect.
@clist: The #GtkCList to check.
@Returns: A #GtkAdjustment object, or NULL if none is currently
being used.
Gets the pixmap and bitmap mask of the specified cell. The returned mask value can be NULL.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@pixmap: A pointer to a pointer to store the cell's #GdkPixmap.
@mask: A pointer to a pointer to store the cell's #GdkBitmap mask.
@Returns: 1 if the cell's pixmap could be retrieved, 0 otherwise.
Gets the text, pixmap and bitmap mask for the specified cell.
@clist: The #GtkCList to affect.
@row: The row to query.
@column: The column to query.
@text: A pointer to a pointer to store the text.
@spacing: A pointer to a #guint8 to store the spacing.
@pixmap: A pointer to a #GdkPixmap pointer to store the cell's pixmap.
@mask: A pointer to a #GdkBitmap pointer to store the cell's bitmap mask.
@Returns: 1 if the retrieval was successful, 0 otherwise.
Gets the currently set data for the specified row.
@clist: The #GtkCList to affect.
@row: The row to query.
@Returns: The data set for the row.
Gets the style set for the specified row.
@clist: The #GtkCList to affect.
@row: The row to query.
@Returns: The #GtkStyle of the row.
Gets whether the specified row is selectable or not.
@clist: The #GtkCList to affect.
@row: The row to query.
@Returns: A #gboolean value.
Gets the row and column at the specified pixel position in the CList.
@clist: The #GtkCList to affect.
@x: The horizontal pixel position to check.
@y: The vertical pixel position to check..
@row: Pointer to a #gint to store the row value.
@column: Pointer to a #gint to store the column value.
@Returns: 1 if row/column is returned and in range, 0 otherwise.
Gets the text for the specified cell.
@clist: The #GtkCList to affect.
@row: The row to query.
@column: The column to query.
@text: A pointer to a pointer to store the text.
@Returns: 1 if the cell's text could be retrieved, 0 otherwise.
Gets the #GtkAdjustment currently being used for the vertical
aspect.
@clist: The #GtkCList to check.
@Returns: A #GtkAdjustment object, or NULL if none is currently
being used.
Adds a row of text to the CList at the specified position.
@clist: The #GtkCList to affect.
@row: The row where the text should be inserted.
@text: An array of string to add.
@Returns: The number of the row added.
Tells the CList widget to visually move to the specified
row and column.
@clist: The #GtkCList to affect.
@row: The row to which to move.
@column: The column to which to move.
@row_align: A value between 0 and 1 that describes the positioning of
the row in relation to the viewable area of the CList's contents.
@col_align: A value between 0 and 1 that describes the positioning of
the column in relation to the viewable area of the CList's contents.
Creates a new #GtkCList widget for use.
@columns: The number of columns the #GtkCList should have.
@Returns: A pointer to a new GtkCList object.
Creates a new #GtkCList widget with column titles for use.
@columns: The number of columns the #GtkCList should have.
@titles: A string array of titles for the widget. There should be
enough strings in the array for the specified number of columns.
@Returns: A pointer to a new GtkCList object.
Gets the required width in pixels that is needed to show
everything in the specified column.
@clist: The #GtkCList to check.
@column: The column to check.
@Returns: The required width in pixels for the column.
Adds a row to the CList at the top.
@clist: The #GtkCList to affect.
@text: An array of strings to add.
@Returns: The number of the row added.
Removes the specified row from the CList.
@clist: The #GtkCList to affect.
@row: The row to remove.
Checks how the specified row is visible.
@clist: The #GtkCList to affect.
@row: The row to query.
@Returns: A #GtkVisibility value that tells you how the row is visible.
Allows you to move a row from one position to another in the
list.
@clist: The #GtkCList to affect.
@source_row: The original position of the row to move.
@dest_row: The position to which the row should be moved.
Selects all rows in the CList. This function has no affect for a
CList in "single" or "browse" selection mode.
@clist: The #GtkCList to affect.
Selects the specified row. Causes the "select-row" signal to be emitted for the specified row and column.
@clist: The #GtkCList to affect.
@row: The row to select.
@column: The column to select.
Turns on or off auto sort of the #GtkCList. If auto sort is on, then the CList will be resorted when a row is inserted into the CList.
@clist: The #GtkCList to affect.
@auto_sort: whether auto sort should be on or off
Sets the background color for the specified row.
@clist: The #GtkCList to affect.
@row: The row to affect.
@color: A pointer to a #GdkColor structure.
Sets the action(s) that the specified mouse button will have
on the CList.
@clist: The #GtkCList to affect.
@button: The mouse button to set. The values here, unlike in the
rest of GTK+ start from 0. For instance, the right mouse
button, which is 3 elsewhere, should be given as 2 here.
@button_actions: A logically OR'd value of #GtkButtonAction values
for the button.
Sets the style for the specified cell.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@style: A pointer to a #GtkStyle structure.
Lets you specify whether a column should be automatically resized
by the widget when data is added or removed. Enabling auto-resize
on a column explicity disallows user-resizing of the column.
@clist: The #GtkCList to affect.
@column: The column on which to set auto-resizing.
@auto_resize: %TRUE or %FALSE.
Sets the justification to be used for all text in the specified
column.
@clist: The #GtkCList to affect.
@column: The column which should be affected.
@justification: A GtkJustification value for the column.
Causes the column specified to have a maximum width, preventing
the user from resizing it larger than that specified.
@clist: The #GtkCList to affect.
@column: The column to set the maximum width.
@max_width: The width, in pixels.
Causes the column specified to have a minimum width, preventing
the user from resizing it smaller than that specified.
@clist: The #GtkCList to affect.
@column: The column to set the minimum width.
@min_width: The width, in pixels.
Lets you specify whether a specified column should be resizeable
by the user. Note that turning on resizeability for the column will
automatically shut off auto-resizing, but turning off resizeability
will NOT turn on auto-resizing. This must be done manually via a
call to gtk_clist_set_column_auto_resize().
@clist: The #GtkCList to affect.
@column: The column on which to set resizeability.
@resizeable: %TRUE or %FALSE.
Sets the title for the specified column.
@clist: The #GtkCList to affect.
@column: The column whose title should be changed.
@title: A string to be the column's title.
Allows you to set whether a specified column in the #GtkCList should
be hidden or shown. Note that at least one column must always be
showing, so attempting to hide the last visible column will be
ignored.
@clist: The #GtkCList to affect.
@column: The column to set visibility.
@visible: %TRUE or %FALSE.
Sets a widget to be used as the specified column's title. This
can be used to place a pixmap or something else as the column
title, instead of the standard text.
@clist: The #GtkCList to affect.
@column: The column whose title should be a widget.
@widget: A pointer to a previously create widget.
Causes the column specified for the #GtkCList to be set to
a specified width.
@clist: The #GtkCList to affect.
@column: The column to set the width.
@width: The width, in pixels.
Sets the compare function of the #GtkClist to @cmp_func. If @cmp_func is NULL,
then the default compare function is used. The default compare function sorts
ascending or with the type set by gtk_clist_set_sort_type() by the column set
by gtk_clist_set_sort_column().
@clist: The #GtkCList to affect.
@cmp_func: The #GtkCompareFunction to use.
Sets the foreground color for the specified row.
@clist: The #GtkCList to affect.
@row: The row to affect.
@color: A pointer to a #GdkColor structure.
Allows you to set the #GtkAdjustment to be used for the horizontal
aspect of the #GtkCList widget.
@clist: The #GtkCList to affect.
@adjustment: A pointer to a #GtkAdjustment widget, or NULL.
Sets a pixmap for the specified cell.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@pixmap: A pointer to a #GdkPixmap to place in the cell.
@mask: A pointer to a #GdkBitmap mask for the cell.
Sets text and a pixmap/bitmap on the specified cell.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@text: The text to set in the cell.
@spacing: The spacing between the cell's text and pixmap.
@pixmap: A pointer to a #GdkPixmap for the cell.
@mask: A pointer to a #GdkBitmap mask for the cell.
Sets whether the CList's rows are re-orderable using drag-and-drop.
@clist: The #GtkCList to affect.
@reorderable: %TRUE or %FALSE.
Sets data for the specified row. This is the same as calling gtk_clist_set_row_data_full(clist, row, data, NULL).
@clist: The #GtkCList to affect.
@row: The row to affect.
@data: The data to set for the row.
Sets the data for specified row, with a callback when the row is destroyed.
@clist: The #GtkCList to affect.
@row: The row to affect.
@data: The data to set for the row.
@destroy: A #GtkDestroyNotify function to be called when the row is destroyed.
Causes the #GtkCList to have a specified height for its
rows. Setting the row height to 0 allows the #GtkCList to adjust
automatically to data in the row.
@clist: The #GtkCList to affect.
@height: The height, in pixels.
Sets the style for all cells in the specified row.
@clist: The #GtkCList to affect.
@row: The row to affect.
@style: A pointer to a #GtkStyle to set.
Sets whether the specified row is selectable or not.
@clist: The #GtkCList to affect.
@row: The row to affect.
@selectable: %TRUE or %FALSE.
Sets the selection mode for the specified CList. This allows you to
set whether only one or more than one item can be selected at a time
in the widget. Note that setting the widget's selection mode to one
of GTK_SELECTION_BROWSE or GTK_SELECTION_SINGLE will cause all the
items in the #GtkCList to become deselected.
@clist: The #GtkCList to affect.
@mode: The GtkSelectionMode type to set for this CList.
Sets the shadow type for the specified CList. Changing this value
will cause the #GtkCList to update its visuals.
@clist: The #GtkCList to affect.
@type: The GtkShadowType desired.
Sets the vertical and horizontal shift of the specified cell.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@vertical: The value to set for the vertical shift.
@horizontal: The value to set for the vertical shift.
Sets the sort column of the clist. The sort column is used by the
default compare function to determine which column to sort by.
@clist: The #GtkCList to affect.
@column: The column to sort by
Sets the sort type of the #GtkClist. This is either GTK_SORT_ASCENDING for
ascening sort or GTK_SORT_DESCENDING for descending sort.
@clist: The #GtkCList to affect.
@sort_type: the #GtkSortType to use
Sets the displayed text in the specified cell.
@clist: The #GtkCList to affect.
@row: The row of the cell.
@column: The column of the cell.
@text: The text to set in the cell.
Determines whether the #GtkClist should use icons when
doing drag-and-drop operations.
@clist: The #GtkCList to affect.
@use_icons: %TRUE or %FALSE.
Allows you to set the #GtkAdjustment to be used for the vertical
aspect of the #GtkCList widget.
@clist: The #GtkCList to affect.
@adjustment: A pointer to a #GtkAdjustment widget, or NULL.
Sorts the #GtkClist according to the current compare function, which
can be set with the gtk_clist_set_compare_func() function.
@clist: The #GtkCList to sort.
Swaps the two specified rows with each other.
@clist: The #GtkCList to affect.
@row1: Number of the first row.
@row2: Number of the second row.
Causes the specified #GtkCList to allow visual updates.
@clist: The #GtkCList to thaw.
Undoes the last selection for an "extended selection mode" CList.
@clist: The #GtkCList to affect.
Unselects all rows in the CList.
@clist: The #GtkCList to affect.
Unselects the specified row. Causes the "unselect-row" signal to be emitted for the specified row and column.
@clist: The #GtkCList to affect.
@row: The row to select.
@column: The column to select.
@colorsel:
@color:
@colorsel:
@color:
@colorsel:
@Returns:
@colorsel:
@Returns:
@func:
@Returns:
@colorsel:
@color:
@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:
Stops the #GtkCombo widget from showing the popup list when the #GtkEntry
emits the "activate" signal, i.e. when the Return key is pressed.
This may be useful if, for example, you want the Return key to close a dialog
instead.
@combo: a #GtkCombo.
@Deprecated: 2.4: Use #GtkComboBox instead.
Creates a new #GtkCombo.
@Returns: a new #GtkCombo.
@Deprecated: 2.4: Use #GtkComboBox instead.
Specifies whether the text entered into the #GtkEntry field and the text in
the list items is case sensitive.
This may be useful, for example, when you have called
gtk_combo_set_value_in_list() to limit the values entered, but you are not
worried about differences in case.
@combo: a #GtkCombo.
@val: %TRUE if the text in the list items is case sensitive.
@Deprecated: 2.4: Use #GtkComboBox instead.
Sets the string to place in the #GtkEntry field when a particular list item is
selected. This is needed if the list item is not a simple label.
@combo: a #GtkCombo.
@item: a #GtkItem.
@item_value: the string to place in the #GtkEntry when @item is selected.
@Deprecated: 2.4: Use #GtkComboBox instead.
Convenience function to set all of the items in the popup list.
(See the example above.)
@combo: a #GtkCombo.
@strings: a list of strings, or %NULL to clear the popup list
@Deprecated: 2.4: Use #GtkComboBox instead.
Specifies if the arrow (cursor) keys can be used to step through the items in
the list. This is on by default.
@combo: a #GtkCombo.
@val: %TRUE if the arrow keys can be used to step through the items in
the list.
@Deprecated: 2.4: Use #GtkComboBox instead.
Obsolete function, does nothing.
@combo: a #GtkCombo.
@val: unused
@Deprecated: 2.4: Use #GtkComboBox instead.
Specifies whether the value entered in the text entry field must match one of
the values in the list. If this is set then the user will not be able to
perform any other action until a valid value has been entered.
If an empty field is acceptable, the @ok_if_empty parameter should be %TRUE.
@combo: a #GtkCombo.
@val: %TRUE if the value entered must match one of the values in the list.
@ok_if_empty: %TRUE if an empty value is considered valid.
@Deprecated: 2.4: Use #GtkComboBox instead.
@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:
@window:
@window:
@window:
@x:
@y:
@width:
@height:
@window:
@title:
Internal function.
@toplevel:
@event:
@colormap:
@pixmap:
@mask:
@hot_x:
@hot_y:
Internal function.
@widget:
@event:
Sets the size that the drawing area will request
in response to a "size_request" signal. The
drawing area may actually be allocated a size
larger than this depending on how it is packed
within the enclosing containers.
@darea: a #GtkDrawingArea
@width: the width to request
@height: the height to request
@Deprecated: Use gtk_widget_set_size_request() instead.
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:
@title:
@parent:
@action:
@backend:
@first_button_text:
@Varargs:
@Returns:
@Returns:
@chooser:
@Returns:
@chooser:
@folder_mode:
@action:
@backend:
@Returns:
Will attempt to match @pattern to a valid filenames or subdirectories in the current directory. If a match can be made, the matched filename will appear in the text entry field of the file selection dialog.
If a partial match can be made, the "Files" list will contain those
file names which have been partially matched, and the "Folders"
list those directories which have been partially matched.
@filesel: a #GtkFileSelection.
@pattern: a string of characters which may or may not match any filenames in the current directory.
@filesel:
@Returns:
@filesel:
@Returns:
@filesel:
@Returns:
Hides the file operation buttons that normally appear at the top of the dialog. Useful if you wish to create a custom file selector, based on #GtkFileSelection.
@filesel: a #GtkFileSelection.
Creates a new file selection dialog box. By default it will contain a #GtkTreeView of the application's current working directory, and a file listing. Operation buttons that allow the user to create a directory, delete files and rename files, are also present.
@title: a message that will be placed in the file requestor's titlebar.
@Returns: the new file selection.
@Deprecated: Use gtk_file_chooser_dialog_new() instead
@filesel:
@filename:
@filesel:
@select_multiple:
Shows the file operation buttons, if they have previously been hidden. The rest of the widgets in the dialog will be resized accordingly.
@filesel: a #GtkFileSelection.
@fsd:
@Returns:
@fsd:
@Returns:
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:
@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:
@ifactory_path:
@path:
@accel_widget:
@full_path:
@accel_group:
@keyval:
@modifiers:
@ifactory:
@container_type:
@path:
@accel_group:
@ifactory:
@entry:
@callback_data:
@callback_type:
@ifactory:
@n_entries:
@entries:
@callback_data:
@ifactory:
@n_entries:
@entries:
@callback_data:
@callback_type:
@n_entries:
@entries:
@ifactory:
@n_entries:
@entries:
@ifactory:
@entry:
@ifactory:
@path:
@path_pspec:
@modified_only:
@print_func:
@func_data:
@file_name:
@path_pspec:
@modified_only:
@path:
@Returns:
@widget:
@Returns:
@ifactory:
@path:
@Returns:
@ifactory:
@action:
@Returns:
@ifactory:
@path:
@Returns:
@ifactory:
@action:
@Returns:
@container_type:
@path:
@accel_group:
@Returns:
@file_name:
@scanner:
@rc_string:
@widget:
@Returns:
@ifactory:
@x:
@y:
@mouse_button:
@time_:
@ifactory:
@Returns:
@widget:
@Returns:
@ifactory:
@popup_data:
@destroy:
@x:
@y:
@mouse_button:
@time_:
@FILE_pointer:
@string:
@ifactory:
@func:
@data:
@notify:
Gets the current string of text within the #GtkLabel and writes it to
the given @str argument. It does not make a copy of this string so you
must not write to it.
@label: The #GtkLabel widget you want to get the text from.
@str: The reference to the pointer you want to point to the text.
@Deprecated: Use gtk_label_get_text() instead.
Sets the text within the GtkLabel widget.
@Deprecated: Use gtk_label_set_text() instead.
@label:
@str:
@Returns:
@layout:
@layout:
Adds @items to the end of the @list.
@list: the list widget.
@items: the items.
Searches the children of @list for the index of @child.
@list: the list widget.
@child: the child to look for.
@Returns: the index of the child, -1 if not found.
Removes the items between index @start (included) and @end (excluded)
from the @list. If @end is negative, or greater than the number of
children of @list, it's assumed to be exactly the number of
elements. If @start is greater than or equal to @end, nothing is
done.
@list: the list widget.
@start: the index of the first item to remove.
@end: the index of the lest item to remove plus one.
Stops the drag selection mode and ungrabs the pointer. This has no
effect if a drag selection is not active.
@list: the list widget.
Ends the selection. Used with gtk_list_extend_selection() and
gtk_list_start_selection(). Only in #GTK_SELECTION_EXTENDED mode.
@list: the list widget.
Extends the selection by moving the anchor according to @scroll_type. Only
in #GTK_SELECTION_EXTENDED.
@list: the list widget.
@scroll_type: the direction and length.
@position: the position if @scroll_type is #GTK_SCROLL_JUMP.
@auto_start_selection: if %TRUE, gtk_list_start_selection() is automatically
carried out before extending the selection.
Inserts @items into the @list at the position @position. The #GList items
must not be freed after.
@list: the list widget.
@items: the items.
@position: the position to insert @items, starting at 0.
Deselects the item, by emitting the item's "deselect" signal.
@list_item: a #GtkListItem.
Creates a new #GtkListitem.
@Returns: a new #GtkListItem.
Creates a new #GtkListItem with a child label containing the given string.
@label: the string to use for the child label.
@Returns: a new #GtkListItem with a child #GtkLabel with the text set to
@label.
Selects the item, by emitting the item's "select" signal.
Depending on the selection mode of the list, this may cause other items to
be deselected.
@list_item: a #GtkListItem.
Creates a new #GtkList.
@Returns: the newly-created #GtkList
Inserts @items at the beginning of the @list.
@list: the list widget.
@items: the items.
Removes the @items from the @list.
@list: the list widget.
@items: the items to remove.
Removes the @items from the @list, without unreferencing them. It
may be useful if you want to move the items from one list to another.
@list: the list widget.
@items: the items.
Scrolls @list horizontaly. This supposes that the list is packed into a
scrolled window or something similar, and adjustments are well
set. Step and page increment are those from the horizontal adjustment
of @list. Backward means to the left, and forward to the
right. Out of bounds values are truncated.
@scroll_type may be any valid #GtkScrollType. If @scroll_type is
#GTK_SCROLL_NONE, nothing is done. If it's #GTK_SCROLL_JUMP, the list
scrolls to the ratio @position: 0 is full left, 1 is full right.
@list: the list widget.
@scroll_type: the scrolling type.
@position: the position if @scroll_type is #GTK_SCROLL_JUMP
Scrolls @list vertically. This supposes that the list is packed into a
scrolled window or something similar, and adjustments are well
set. Step and page increment are those from the vertical adjustment
of @list. Backward means up, and forward down. Out of bounds values are
truncated.
@scroll_type may be any valid #GtkScrollType. If @scroll_type is
#GTK_SCROLL_NONE, nothing is done. If it's #GTK_SCROLL_JUMP, the list
scrolls to the ratio @position: 0 is top, 1 is bottom.
@list: the list widget.
@scroll_type: the scrolling type.
@position: the position if @scroll_type is #GTK_SCROLL_JUMP
Selects all children of @list. A signal will be emitted for each
newly selected child.
@list: the list widget.
Selects the given @child. The signal GtkList::select-child will be
emitted.
@list: the list widget
@child: the child to select.
Selects the child number @item of the @list. Nothing happens if @item
is out of bounds. The signal GtkList::select-child will be emitted.
@list: the list widget.
@item: the index of the child to select.
Set the list selection mode. The selection mode can be any value in
#GtkSelectionMode:
#GTK_SELECTION_SINGLE
Zero or one element may be selected.
#GTK_SELECTION_BROWSE
Exactly one element is always selected (this can be false after you have
changed the selection mode).
#GTK_SELECTION_MULTIPLE
Any number of elements may be selected. Clicks toggle the state of an
item.
#GTK_SELECTION_EXTENDED
Any number of elements may be selected. Click-drag selects a range of
elements; the Ctrl key may be used to enlarge the selection, and
Shift key to select between the focus and the child pointed to.
@list: the list widget.
@mode: the new selection mode.
Starts a selection (or part of selection) at the focused child. Only in
#GTK_SELECTION_EXTENDED mode.
@list: the list widget.
@store:
@iter:
@position:
@n_columns:
@Varargs:
@Returns:
@store:
@iter:
@column:
@value:
@store:
@column:
@type:
@store:
@n_columns:
Toggles between adding to the selection and beginning a new selection. Only
in #GTK_SELECTION_EXTENDED. Useful with gtk_list_extend_selection().
@list: the list widget.
Toggles the focus row. If the focus row is selected, it's
unselected. If the focus row is unselected, it's selected. If the
selection mode of @list is #GTK_SELECTION_BROWSE, this has no effect,
as the selection is always at the focus row.
@list: the list widget.
Toggles the child @item of list. If the selection mode of @list is
#GTK_SELECTION_BROWSE, the item is selected, and the others are
unselected.
@list: the list widget.
@item: the child to toggle.
Restores the selection in the last state, only if selection mode is
#GTK_SELECTION_EXTENDED. If this function is called twice, the selection is
cleared. This function sometimes gives stranges "last states".
@list: the list widget.
Unselects all children of @list. A signal will be emitted for each
newly unselected child.
@list: the list widget.
Unselects the given @child. The signal GtkList::unselect-child will be
emitted.
@list: the list widget.
@child: the child to unselect.
Unselects the child number @item of the @list. Nothing happens if
@item is out of bounds. The signal GtkList::unselect-child will be
emitted.
@list: the list widget.
@item: the index of the child to unselect.
Adds a new #GtkMenuItem to the end of the GtkMenuBar
@menu: a #GtkMenuBar
@child: the #GtkMenuItem to add
@Deprecated: Use gtk_menu_shell_append() instead.
Adds a new #GtkMenuItem to the GtkMenuBar at the position defined by @position
@menu: a #GtkMenuBar
@child: the #GtkMenuItem to add
@pos: the position in the item list where the @child is added.
@Deprecated: Use gtk_menu_shell_insert() instead.
Adds a new #GtkMenuItem to the beginning of the GtkMenuBar
@menu: a #GtkMenuBar
@child: the #GtkMenuItem to add
@Deprecated: Use gtk_menu_shell_prepend() instead.
@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
@menu_item:
Sets the menu item to be right-justified. Only useful for menu bars.
@menu_item: the menu item
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
@button:
@tooltips:
@tip_text:
@tip_private:
Deprecated compatibility macro.
@Deprecated: Use gtk_notebook_get_current_page() instead.
@notebook:
@Returns:
@notebook:
@group_id:
@notebook:
@homogeneous:
Deprecated compatibility macro.
@Deprecated: Use gtk_notebook_set_current_page() instead.
@notebook:
@border_width:
@notebook:
@tab_hborder:
@notebook:
@tab_vborder:
Deprecated in favor of the #GObject property system including #GParamSpec.
Add a new type of argument to an object class.
Usually this is called when registering a new type of object.
@arg_name: fully qualify object name, for example GtkObject::user_data.
@arg_type: type of the argument.
@arg_flags: bitwise-OR of the #GtkArgFlags enum. (Whether the argument is
settable or gettable, whether it is set when the object is constructed.)
@arg_id: an internal number, passed in from here to the "set_arg" and
"get_arg" handlers of the object.
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 g_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 g_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 g_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 g_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().
Useless deprecated macro. Ignore it.
Useless deprecated macro. Ignore it.
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 properties of an object.
@object: a #GtkObject.
@first_property_name: name of first property to get the value for.
@Varargs: %NULL-terminated list of name-return location pairs.
@Deprecated: Use g_object_get() instead.
Get a named field from the object's table of associations (the object_data).
@object: the object maintaining the associations.
@key: name of the key for that association.
@Returns: the data if found, or %NULL if no such data exists.
@Deprecated: Use g_object_get_data() instead.
Just like gtk_object_get_data() except that it takes
a #GQuark instead of a string, so it is slightly faster.
Use gtk_object_data_try_key() and gtk_object_data_force_id()
to get an id from a string.
@object: object containing the associations.
@data_id: quark of the key.
@Returns: the data if found, or %NULL if no such data exists.
@Deprecated: Use g_object_get_qdata() instead.
Get the object's user data pointer.
This is intended to be a pointer for your convenience in
writing applications.
@object: the object.
@Returns: the user data field for object.
@Deprecated: Use g_object_get_data() instead.
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.
Constructs an object given its arguments, enumerated in the call to the
function.
@type: the type identifying this object. Returned by gtk_type_unique()
(although for a properly-written object it should be accessible through
a #GTK_TYPE_FOO macro.)
@first_property_name: name of the first property to set when constructing
the object.
@Varargs: the first argument's value, followed by any number of
name/argument-value pairs, terminated with %NULL.
@Returns: the new #GtkObject.
@Deprecated: Use g_object_new() instead.
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().
Increases the reference count of the object.
@object: the object to reference.
@Returns: @object.
@Deprecated: Use g_object_ref() instead.
Removes a specified datum from the object's data associations (the object_data).
Subsequent calls to gtk_object_get_data() will return %NULL.
If you specified a destroy handler with gtk_object_set_data_full(),
it will be invoked.
@object: the object maintaining the association.
@key: name of the key for that association.
@Deprecated: Use g_object_set_data() to set the object data to %NULL instead.
Just like gtk_object_remove_data() except that it takes
a #GQuark instead of a string, so it is slightly faster.
Remove a specified datum from the object's data associations.
Subsequent calls to gtk_object_get_data() will return %NULL.
Use gtk_object_data_try_key() and gtk_object_data_force_id()
to get an id from a string.
@object: object containing the associations.
@data_id: quark of the key.
@Deprecated: Use g_object_set_qdata() with data of %NULL instead.
Remove a specified datum from the object's data associations (the object_data),
without invoking the association's destroy handler.
Just like gtk_object_remove_data() except that any destroy handler
will be ignored.
Therefore this only affects data set using gtk_object_set_data_full().
@object: the object maintaining the association.
@key: name of the key for that association.
@Deprecated: Use g_object_steal_data() instead.
Just like gtk_object_remove_no_notify() except that it takes
a #GQuark instead of a string, so it is slightly faster.
Use gtk_object_data_try_key() and gtk_object_data_force_id()
to get an id from a string.
@object: object containing the associations.
@key_id: quark of the key.
@Deprecated: Use g_object_steal_qdata() instead.
Sets properties on an object.
void set_box_properties (GtkBox* box)
{
gtk_object_set (GTK_OBJECT (box), "homogeneous", TRUE,
"spacing", 8,
NULL);
}
@object: a #GtkObject.
@first_property_name: name of the first property to set
@Varargs: the value of the first argument, followed optionally
by more name/value pairs, followed by %NULL.
@Deprecated: Use g_object_set() instead.
Each object carries around a table of associations from
strings to pointers. This function lets you set an association.
If the object already had an association with that name,
the old association will be destroyed.
@object: object containing the associations.
@key: name of the key.
@data: data to associate with that key.
@Deprecated: Use g_object_set_data() instead.
Just like gtk_object_set_data() except that it takes
a #GQuark instead of a string, so it is slightly faster.
Use gtk_object_data_try_key() and gtk_object_data_force_id()
to get an id from a string.
@object: object containing the associations.
@data_id: quark of the key.
@data: data to associate with that key.
@Deprecated: Use g_object_set_qdata() instead.
Just like gtk_object_set_data_full() except that it takes
a #GQuark instead of a string, so it is slightly faster.
Use gtk_object_data_try_key() and gtk_object_data_force_id()
to get an id from a string.
@object: object containing the associations.
@data_id: quark of the key.
@data: data to associate with that key.
@destroy: function to call when the association is destroyed.
@Deprecated: Use g_object_set_qdata_full() instead.
Like gtk_object_set_data() except it adds notification
for when the association is destroyed, either by
gtk_object_remove_data() or when the object is destroyed.
@object: object containing the associations.
@key: name of the key.
@data: data to associate with that key.
@destroy: function to call when the association is destroyed.
@Deprecated: Use g_object_set_data_full() instead.
For convenience, every object offers a generic user data
pointer. This function sets it.
@object: the object whose user data should be set.
@data: the new value for the user data.
@Deprecated: Use g_object_set_data() instead.
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).
Removes the floating reference from a #GtkObject, if it exists;
otherwise does nothing. See the #GtkObject overview documentation at
the top of the page.
@object: the object to sink.
@Deprecated: 2.10: Use g_object_ref_sink() instead
Decreases the reference count of an object. When its reference count drops
to 0, the object is finalized (i.e. its memory is freed).
@object: the object to dereference.
@Deprecated: Use g_object_unref() instead.
Adds a weak reference callback to an object. Weak references are used for notification when an object is
finalized. They are called "weak references" because they allow you to safely
hold a pointer to an object without calling g_object_ref() (g_object_ref() adds
a strong reference, that is, forces the object to stay alive).
@object: object to weakly reference.
@notify: callback to invoke before the object is freed.
@data: extra data to pass to #notify.
@Deprecated: Use g_object_weak_ref() instead.
Removes a weak reference callback to an object.
@object: object stop weakly referencing.
@notify: callback to search for.
@data: data to search for.
@Deprecated: Use g_object_weak_unref() instead.
@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:
@style:
@window:
@state_type:
@area:
@widget:
@detail:
@x:
@y:
@string:
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:
Sets the data for a portion of a row.
@preview: a #GtkPreview.
@data: the new data for the portion. It should contain
@w bytes of data if the preview is of type
GTK_TYPE_GRAYSCALE, and 3*@w bytes of data
if the preview is of type GTK_TYPE_COLOR.
@x: the starting value on the row to set.
@y: the row to change.
@w: the number of pixels in the row to change.
Returns the colormap used by preview widgets. This
function is deprecated, and you should use
gdk_rgb_get_cmap() instead.
@Returns: the colormap for previews.
Return a #GtkPreviewInfo structure containing
global information about preview widgets.
@Returns: a #GtkPreviewInfo structure. The return
value belongs to GTK+ and must not be modified
or freed.
Returns the visual used by preview widgets. This
function is deprecated, and you should use
gdk_rgb_get_visual() instead.
@Returns: the visual for previews.
Create a new preview widget.
@type: the type data contained by the widget.
(Grayscale or RGB)
@Returns: a new #GtkPreview
Takes a portion of the contents of a preview widget
and draws it onto the given drawable, @window.
@preview: a #GtkPreview.
@window: a window or pixmap.
@gc: The graphics context for the operation. Only the
clip mask for this GC matters.
@srcx: the x coordinate of the upper left corner in the source image.
@srcy: the y coordinate of the upper left corner in the source image.
@destx: the x coordinate of the upper left corner in the destination image.
@desty: the y coordinate of the upper left corner in the destination image.
@width: the width of the rectangular portion to draw.
@height: the height of the rectangular portion to draw.
This function is deprecated and does nothing. It was
once used for changing the colormap and visual on the fly.
This function is deprecated and does nothing. GdkRGB
automatically picks an optimium color cube for the
display.
@nred_shades: ignored
@ngreen_shades: ignored
@nblue_shades: ignored
@ngray_shades: ignored
Set the dithering mode for the display.
@preview: a #GtkPreview.
@dither: the dithering mode.
Determines the way that the the preview widget behaves
when the size it is allocated is larger than the requested
size. If @expand is %FALSE, then the preview's window
and buffer will be no larger than the size set with
gtk_preview_size(), and the data set will be centered
in the allocation if it is larger. If @expand is %TRUE
then the window and buffer will expand with the allocation;
the application is responsible for catching
the "size_allocate" signal and providing the data
appropriate for this size.
@preview: a #GtkPreview.
@expand: whether the preview's window should expand or not.
Set the gamma-correction value for all preview widgets.
(This function will eventually be replaced with a
function that sets a per-preview-widget gamma value).
The resulting intensity is given by:
destination_value * pow (source_value/255, 1/gamma).
The gamma value is applied when the data is
set with gtk_preview_draw_row() so changing this
value will not affect existing data in preview
widgets.
@gamma_: the new gamma value.
This function is deprecated
and does nothing. GdkRGB will automatically pick
a private colormap if it cannot allocate sufficient
colors.
@install_cmap: ignored.
This function is deprecated and does nothing.
@nreserved: ignored.
Set the size that the preview widget will request
in response to a "size_request" signal. The
drawing area may actually be allocated a size
larger than this depending on how it is packed
within the enclosing containers. The effect
of this is determined by whether the preview
is set to expand or not (see gtk_preview_expand())
@preview: a #GtkPreview.
@width: the new width.
@height: the new height.
This function is deprecated and does nothing.
@context:
@Returns:
@context:
@Returns:
@context:
@Returns:
@context:
@Returns:
@op:
@n_pages:
@settings:
@Returns:
@settings:
@Returns:
@settings:
@num_copies:
@settings:
@print_to_file:
@adjustment:
@Returns:
Sets the number of blocks used when the progress bar is in activity
mode. Larger numbers make the visible block smaller.
@pbar: a #GtkProgressBar.
@blocks: number of blocks which can fit within the progress bar area.
Sets the step value used when the progress bar is in activity
mode. The step is the amount by which the progress is incremented
each iteration.
@pbar: a #GtkProgressBar.
@step: the amount which the progress is incremented in activity
mode.
Sets the style of the #GtkProgressBar. The default style is
%GTK_PROGRESS_CONTINUOUS.
@pbar: a #GtkProgressBar.
@style: a #GtkProgressBarStyle value indicating the desired style.
Sets the number of blocks that the progress bar is divided into
when the style is %GTK_PROGRESS_DISCRETE.
@pbar: a #GtkProgressBar.
@blocks: number of individual blocks making up the bar.
This function is deprecated. Please use gtk_progress_set_value() or
gtk_progress_set_percentage() instead.
@pbar: a #GtkProgressBar.
@percentage: the new percent complete value.
Deprecated compatibility macro. Use gtk_radio_menu_item_get_group() instead.
Adds a #GtkRcStyle that will be looked up by a matching against
the class hierarchy of the widget. This is equivalent to a:
class PATTERN style STYLE
statement in a RC file.
@rc_style: the #GtkRcStyle to use for widgets deriving from @pattern
@pattern: the pattern
@Deprecated: Use gtk_rc_parse_string() with a suitable string instead.
Adds a #GtkRcStyle that will be looked up by a match against
the widget's class pathname. This is equivalent to a:
widget_class PATTERN style STYLE
statement in a RC file.
@rc_style: the #GtkRcStyle to use for widgets matching @pattern
@pattern: the pattern
@Deprecated: Use gtk_rc_parse_string() with a suitable string instead.
Adds a #GtkRcStyle that will be looked up by a match against
the widget's pathname. This is equivalent to a:
widget PATTERN style STYLE
statement in a RC file.
@rc_style: the #GtkRcStyle to use for widgets matching @pattern
@pattern: the pattern
@Deprecated: Use gtk_rc_parse_string() with a suitable string instead.
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
Increments the reference count of a #GtkRcStyle.
@rc_style: a #GtkRcStyle
@Deprecated: Use g_object_ref() instead
Decrements the reference count of a #GtkRcStyle and
frees if the result is 0.
@rc_style: a #GtkRcStyle
@Deprecated: Use g_object_unref() instead
@chooser:
@Returns:
@chooser:
@show_numbers:
@screen:
@Returns:
@manager:
@screen:
@ruler: the gtkruler
@ruler: the gtkruler
@button:
@Returns:
@button:
@orientation:
@widget:
@event:
@Returns:
Internal function.
@window:
@event:
@Returns:
Internal function.
@widget:
@event:
@Returns:
Internal function.
@widget:
@event:
@Returns:
Internal function.
@widget:
@event:
@Returns:
@Returns:
Gets the value in the @spin_button.
@Returns: the value of @spin_button
@Deprecated: Use gtk_spin_button_get_value() instead.
@spin_button: a #GtkSpinButton
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.
@status_icon:
@tooltip_text:
@Returns:
Does the same as gtk_style_apply_default_background().
@s:
@gw:
@st:
@a:
@x:
@y:
@w:
@h:
@Deprecated: Use gtk_style_apply_default_background() instead.
@style:
@Returns:
@display:
@style:
@Returns:
@style:
@widget_type:
@property_name:
@value:
@style:
@stock_id:
@Returns:
@style:
@Returns:
@style:
@font:
@style:
@buffer:
@override_location:
@default_editable:
@first:
@second:
@iter:
@desc:
@text_view:
@width:
@height:
@Returns:
Creates a new #GtkTipsQuery.
@Returns: a new #GtkTipsQuery.
Sets the widget which initiates the query, usually a button.
If the @caller is selected while the query is running, the query is
automatically stopped.
@tips_query: a #GtkTipsQuery.
@caller: the widget which initiates the query.
Sets the text to display when the query is not in effect,
and the text to display when the query is in effect but the widget beneath
the pointer has no tooltip.
@tips_query: a #GtkTipsQuery.
@label_inactive: the text to display when the query is not running.
@label_no_tip: the text to display when the query is running but the widget
beneath the pointer has no tooltip.
Starts a query.
The #GtkTipsQuery widget will take control of the mouse and as the mouse
moves it will display the tooltip of the widget beneath the mouse.
@tips_query: a #GtkTipsQuery.
Stops a query.
@tips_query: a #GtkTipsQuery.
@tool_item:
@Returns:
@tool_item:
@pack_end:
@toolbar:
@type:
@widget:
@text:
@tooltip_text:
@tooltip_private_text:
@icon:
@callback:
@user_data:
@Returns:
@toolbar:
@text:
@tooltip_text:
@tooltip_private_text:
@icon:
@callback:
@user_data:
@Returns:
@toolbar:
@toolbar:
@widget:
@tooltip_text:
@tooltip_private_text:
@toolbar:
@Returns:
@toolbar:
@Returns:
@toolbar:
@type:
@widget:
@text:
@tooltip_text:
@tooltip_private_text:
@icon:
@callback:
@user_data:
@position:
@Returns:
@toolbar:
@text:
@tooltip_text:
@tooltip_private_text:
@icon:
@callback:
@user_data:
@position:
@Returns:
@toolbar:
@position:
@toolbar:
@stock_id:
@tooltip_text:
@tooltip_private_text:
@callback:
@user_data:
@position:
@Returns:
@toolbar:
@widget:
@tooltip_text:
@tooltip_private_text:
@position:
@toolbar:
@type:
@widget:
@text:
@tooltip_text:
@tooltip_private_text:
@icon:
@callback:
@user_data:
@Returns:
@toolbar:
@text:
@tooltip_text:
@tooltip_private_text:
@icon:
@callback:
@user_data:
@Returns:
@toolbar:
@toolbar:
@widget:
@tooltip_text:
@tooltip_private_text:
@toolbar:
@position:
@toolbar:
@orientation:
@toolbar:
@enable:
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.
A alternate name for gtk_tree_model_get_iter_first() provided for
compatibility reasons; this macro will be deprecated in future
versions of GTK+.
@tree_model: A #GtkTreeModel.
@iter: uninitialized #GtkTreeIter.
@Returns: %TRUE, if @iter was set.
@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:
An alternate name for gtk_tree_path_new_first() provided for
compatibility reasons.
@Returns: A new #GtkTreePath.
@Deprecated: Use gtk_tree_path_new_first() instead.
@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:
@tree_view:
@tx:
@ty:
@wx:
@wy:
@tree_view:
@wx:
@wy:
@tx:
@ty:
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
Returns a pointer pointing to the class of @type or %NULL if there was
any trouble identifying @type. Initializes the class if necessary.
@type: a #GtkType.
@Returns: pointer to the class.
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
Returns a pointer to one of @enum_type's #GtkEnumValues's whose name (or nickname) matches @value_name.
@enum_type: a #GtkType.
@value_name: the name to look for.
@Returns: #GtkEnumValue*
If @enum_type has values, then return a pointer to all of them.
@enum_type: a #GtkType.
@Returns: #GtkEnumValue*
Returns a pointer to one of @flag_type's #GtkFlagValue's whose name (or nickname) matches @value_name.
@flags_type: a #GtkType.
@value_name: the name to look for.
@Returns: #GtkFlagValue*
@flag_type: GtkType
If @flags_type has values, then return a pointer to all of them.
@flags_type: a #GtkType.
@Returns: #GtkFlagValue*
Given the type of an object and a pointer to it, the object is freed.
@type: GtkType
@mem: gpointer to the object
Gets the internal representation of a type, given its name.
@name: the name of a GTK+ type
@Returns: a #GtkType.
Get the varargs type associated with @foreign_type
@foreign_type: GtkType
@Returns: GtkType
Initializes the data structures associated with GTK+ types.
@debug_flags: debug flags
Looks in the type hierarchy to see if @type has @is_a_type among its
ancestors. Do so with a simple lookup, not a loop.
@type: a #GtkType.
@is_a_type: another #GtkType.
@Returns: %TRUE if @type is a @is_a_type.
Returns a pointer to the name of a type, or %NULL if it has none.
@type: a #GtkType.
@Returns: a pointer to the name of a type, or %NULL if it has none.
Creates a new object of a given type, and return a pointer to it.
Returns %NULL if you give it an invalid type. It allocates the object
out of the type's memory chunk if there is a memory chunk. The object
has all the proper initializers called.
@type: a #GtkType.
@Returns: pointer to a #GtkTypeObject.
Returns the parent type of a #GtkType.
@type: a #GtkType.
@Returns: the #GtkType of the parent.
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.
Creates a new, unique type.
@parent_type: if zero, a fundamental type is created
@gtkinfo: must not be %NULL, and @type_info->type_name must also not be %NULL
@Returns: the new #GtkType
@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: