+\input texinfo @c -*-texinfo-*-
+@c Copyright (C) 1996 by Peter Mattis. All rights reserved.
+@c
+@c %**start of header
+@setfilename gtk.info
+@settitle GTK
+@setchapternewpage odd
+@include macros.texi
+@c %**end of header
+
+@set edition 1.0
+@set update-date 29 January 1998
+@set update-month January 1998
+
+@ifinfo
+This file documents GTK, the GIMP Toolkit
+
+Copyright (C) 1996 Peter Mattis
+Copyright (C) 1997 Peter Mattis
+
+Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies
+
+@ignore
+Permission is granted to process this file through TeX and print the
+results, provided the printed document carries copying permission notice
+identical to this one except for the removal of this paragraph (this
+paragraph not being relevant to the printed manual).
+
+@end ignore
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided that the
+entire resulting derived work is distributed under the terms of a
+permission notice identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that this permission notice may be stated in a translation
+approved by Peter Mattis.
+@end ifinfo
+
+@titlepage
+@title The GIMP Toolkit
+@subtitle Version @value{edition}
+@subtitle @value{update-month}
+@author by Peter Mattis
+
+@page
+@vskip 0pt plus 1filll
+Copyright @copyright{} 1996 Peter Mattis
+@vskip 0pt plus 1fill
+Copyright @copyright{} 1997 Peter Mattis
+
+Permission is granted to make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
+
+Permission is granted to copy and distribute modified versions of this
+manual under the conditions for verbatim copying, provided that the
+entire resulting derived work is distributed under the terms of a
+permission notice identical to this one.
+
+Permission is granted to copy and distribute translations of this manual
+into another language, under the above conditions for modified versions,
+except that this permission notice may be stated in a translation
+approved by Peter Mattis.
+@end titlepage
+
+@dircategory User Interface Toolkit
+@direntry
+* GTK: (gtk). The GIMP Toolkit
+@end direntry
+
+@node Top, Copying, (dir), (dir)
+@top The GIMP Toolkit
+@ifinfo
+This is edition @value{edition} of the GTK documentation,
+@w{@value{update-date}}.
+@end ifinfo
+@c FIXME: Do a introduction to the GTK?
+
+@menu
+* Copying:: Your rights.
+* Overview:: What is GTK?
+* Objects:: Object overview.
+* Signals:: Signals overview.
+* Widgets:: Widget overview.
+* Other Objects:: Utility objects.
+* Miscellaneous:: Initialization, exit and other features.
+* Examples:: Using GTK.
+* Object Implementation:: Object internals.
+* Signal Implementation:: Signal internals.
+* Widget Implementation:: Widget internals.
+* Function Index:: Index of functions.
+* Concept Index:: Index of concepts.
+@end menu
+
+@node Copying, Overview, Top, Top
+@comment node-name, next, previous, up
+@chapter Copying
+@cindex Copying
+
+GTK is @dfn{free}; this means that everyone is free to use it and free
+to redistribute it on a free basis. GTK is not in the public domain; it
+is copyrighted and there are restrictions on its distribution, but
+these restrictions are designed to permit everything that a good
+cooperating citizen would want to do. What is not allowed is to try to
+prevent others from further sharing any version of GTK that they might
+get from you.
+
+Specifically, we want to make sure that you have the right to give away
+copies of GTK, that you receive source code or else can get it if you
+want it, that you can change GTK or use pieces of it in new free
+programs, and that you know you can do these things.
+
+To make sure that everyone has such rights, we have to forbid you to
+deprive anyone else of these rights. For example, if you distribute
+copies of GTK, you must give the recipients all the rights that you
+have. You must make sure that they, too, receive or can get the source
+code. And you must tell them their rights.
+
+Also, for my own protection, we must make certain that everyone finds
+out that there is no warranty for GTK. If GTK is modified by someone
+else and passed on, we want their recipients to know that what they have
+is not what we distributed, so that any problems introduced by others
+will no reflect on our reputation.
+
+The precise conditions of the licenses for GTK are found in the General
+Public Licenses that accompanies it.
+
+
+@node Overview, Objects, Copying, Top
+@comment node-name, next, previous, up
+@chapter What is GTK?
+@cindex Overview
+
+GTK is a library for creating graphical user interfaces similar to the
+Motif ``look and feel''. It is designed to be small and efficient, but
+still flexible enough to allow the programmer freedom in the interfaces
+created. GTK allows the programmer to use a variety of standard user
+interface widgets (@pxref{Widgets}) such as push, radio and check
+buttons, menus, lists and frames. It also provides several ``container''
+widgets which can be used to control the layout of the user interface
+elements.
+
+GTK provides some unique features. (At least, I know of no other widget
+library which provides them). For example, a button does not contain a
+label, it contains a child widget, which in most instances will be a
+label. However, the child widget can also be a pixmap, image or any
+combination possible the programmer desires. This flexibility is adhered
+to throughout the library.
+
+
+@node Objects, Signals, Overview, Top
+@comment node-name, next, previous, up
+@chapter Object Overview
+@cindex Objects
+
+GTK implements a semi-simple class mechanism and an associated class
+hierarchy for widgets and several other useful objects. The GtkObject
+type is the root of the class hierarchy. It provides a few items needed
+by all classes, the foundation for the signal (@pxref{Signals})
+mechanism and the ``destroy'' method.
+
+The class hierarchy is defined by a type hierarchy. This hierarchy
+allows queries to be made in regards to a type. The basic query that can
+be performed is asking whether a given type has an ``is a'' relation
+with another type. For instance, it is common to ask whether a general
+widget pointer is a type of specific widget so that runtime sanity
+checks can be made.
+
+@section Type utility functions
+
+The @code{GtkTypeInfo} structure is used to communicate information to
+@code{gtk_type_unique} as opposed to passing in large numbers of
+parameters.
+
+@example
+typedef struct _GtkTypeInfo GtkTypeInfo;
+
+struct _GtkTypeInfo
+@{
+ gchar *type_name;
+ guint object_size;
+ guint class_size;
+ GtkClassInitFunc class_init_func;
+ GtkObjectInitFunc object_init_func;
+ GtkArgSetFunc arg_set_func;
+ GtkArgGetFunc arg_get_func;
+@}
+@end example
+
+@itemize @bullet
+@item
+The @code{type_name} field refers to the name of the type. It is
+convention for the type name to be the same as the C structure type. For
+example, the type name of the @code{GtkObject} structure is
+``GtkObject''.
+
+@item
+The @code{object_size} field refers to the size in bytes of the C
+structure. The easiest (and portable) means of computing this size is by
+using the C @code{sizeof} operator. For instance, the sizeof of the
+@code{GtkObject} structure is computed by doing @code{sizeof
+(GtkObject)}.
+
+@item
+The @code{class_size} field refers to the size in bytes of the C
+structure for the class. Again, the @code{sizeof} operator should be
+used to compute this value.
+
+@item
+The @code{class_init_func} field is a callback which is used by the type
+mechanism to initialize class specific fields. The single argument this
+function takes is a pointer to a class structure.
+
+@item
+The @code{object_init_func} field is a callback which is used by the
+type mechanism to initialize object specific fields. The single argument
+this functions takes is a pointer to an object structure.
+
+@c FIXME!! Document the arg_set_func and arg_get_func..
+
+@end itemize
+
+@deftypefun guint gtk_type_unique (guint @var{parent_type}, GtkTypeInfo *@var{type_info})
+The @var{parent_type} is simply the value of the new types parent
+type. If @var{parent_type} is 0, then the new type is the root of the
+type hierarchy. @var{type_info} is a pointer to a structure which
+contains necessary information for construction of the new
+type. Specifically, the @code{type_name}, @code{object_size} and
+@code{class_size} fields are required. The @code{class_init_func},
+@code{object_init_func} and @code{value_init_func} fields may be NULL.
+@end deftypefun
+
+@deftypefun gchar* gtk_type_name (guint @var{type})
+The returned string is the name of @var{type} as specified to
+@code{gtk_type_unique}.
+@end deftypefun
+
+@deftypefun guint gtk_type_from_name (guchar *@var{name})
+Return the type associated with @var{name}. If there is no type
+associated with @var{name}, then 0 will be returned.
+@end deftypefun
+
+@deftypefun guint gtk_type_parent (guint @var{type})
+Returns the parent type of @var{type} or 0 if @var{type} is the root of
+the type hierarchy.
+@end deftypefun
+
+@deftypefun gpointer gtk_type_class (guint @var{type})
+Returns the initialized class structure for @var{type}. The class
+structure is actually created and initialized the first time it is
+needed. If creation and initialization occurs, the @code{class_size}
+field of the @code{GtkTypeInfo} structure used to initialize this type
+is used to determine how large the class structure is. The
+@code{class_init_func} field from the @code{GtkTypeInfo} structure is
+called for all the members in the types ancestry, including the
+type. The order of this invocation proceeds from the root on down. For
+example, the @code{GtkWidgetClass} is first initialized as an
+@code{GtkObjectClass} by the object class initialization routine and
+then by the widget class initialization routine. This allows the widget
+class initialization routine to override values set by the object class
+initialization routine. The returned structure is shared by all objects
+of @var{type} and, as such, should not be modified.
+@end deftypefun
+
+@deftypefun gpointer gtk_type_new (guint @var{type})
+Returns a new instance of an @var{type} object. The object structure is
+created and initialized similarly to the class structure (as described
+above). The @code{object_size} and @code{object_init_func} fields of the
+@code{GtkTypeInfo} structure are used to determine the objects allocated
+size and the object specific initialization routine. Similarly to the
+class initialization, all the object initialization routines from the
+root on down to the particular type being created are invoked.
+@end deftypefun
+
+@deftypefun void gtk_type_describe_heritage (guint @var{type})
+Prints the type heritage for @var{type}. The heritage for a type
+includes the type and all its parent types up the type tree.
+@end deftypefun
+
+@deftypefun void gtk_type_describe_tree (guint @var{type}, gint @var{show_size})
+Prints the type tree which starts at @var{type}. @var{show_size} is a
+boolean which determines whether type sizes are printed.
+@end deftypefun
+
+@deftypefun gint gtk_type_is_a (guint @var{type}, guint @var{is_a_type})
+A predicate function which determines whether the relation @var{type}
+is_a @var{is_a_type} is true.
+@end deftypefun
+
+@deftypefun void gtk_type_get_arg (GtkObject *@var{object}, GtkType @var{type}, GtkArg *@var{arg}, guint @var{arg_id})
+@end deftypefun
+
+@deftypefun void gtk_type_set_arg (GtkObject *@var{object}, GtkType @var{type}, GtkArg *@var{arg}, guint @var{arg_id})
+@end deftypefun
+
+@section Object functions
+
+The GtkObject type is the root of the type hierarchy used by GTK. It
+provides a minimal set of fields used to implement the actual
+object, class and signal mechanisms, as well as several utility routines
+which make dealing with objects easier.
+
+For the adventurous, see @ref{Object Implementation}.
+
+@deftypefun guint gtk_object_get_type (void)
+Returns the @code{GtkObject} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_object_class_add_signals (GtkObjectClass *@var{class}, gint *@var{signals}, gint @var{nsignals})
+Adds @var{signals} to the @code{signals} field in the GtkObjectClass
+structure @var{class}. @xref{Signals}.
+@end deftypefun
+
+@deftypefun GtkObject* gtk_object_new (guint @var{type}, @dots{})
+@end deftypefun
+
+@deftypefun GtkObject* gtk_object_newv (guint @var{type}, guint @var{nargs}, GtkArg *@var{args})
+@end deftypefun
+
+@deftypefun void gtk_object_ref (GtkObject *@var{object});
+@end deftypefun
+
+@deftypefun void gtk_object_unref (GtkObject *@var{object});
+@end deftypefun
+
+@deftypefun void gtk_object_getv (GtkObject *@var{object}, guint @var{nargs}, GtkArg *@var{args})
+@end deftypefun
+
+@deftypefun void gtk_object_set (GtkObject *@var{object}, @dots{})
+@end deftypefun
+
+@deftypefun void gtk_object_setv (GtkObject *@var{object}, guint @var{nargs}, GtkArg *@var{args})
+@end deftypefun
+
+@deftypefun GtkArg* gtk_object_query_args (GtkType @var{class_type}, guint *@var{nargs})
+@end deftypefun
+
+@deftypefun void gtk_object_add_arg_type (gchar *@var{arg_name}, GtkType @var{arg_type}, guint @var{arg_id})
+@end deftypefun
+
+@deftypefun GtkType gtk_object_get_arg_type (gchar *@var{arg_name})
+@end deftypefun
+
+
+@deftypefun void gtk_object_destroy (GtkObject *@var{object})
+Performs checks to make sure it is alright to destroy @var{object} and
+then emits the @code{destroy} signal. The check which is performed is to
+make sure @var{object} is not already processing another signal. If this
+were the case then destroying the object immediately would undoubtedly
+cause problems as the other signal would not be able to tell the object
+was destroyed. The solution is that if @var{object} is processing another
+signal we mark @var{object} is needing to be destroyed. When we finish
+processing of the other signal we check whether the object needs to be
+destroyed.
+@end deftypefun
+
+The GtkObject type provides a mechanism for associating arbitrary
+amounts of data with an object. The data is associated with the object
+using a character string key. The functions @code{gtk_object_set_data},
+@code{gtk_object_get_data}, and @code{gtk_object_remove_data} are the
+interface to this mechanism. Two other routines,
+@code{gtk_object_set_user_data} and @code{gtk_object_get_user_data},
+exist as convenience functions which simply use the same mechanism.
+
+@deftypefun void gtk_object_set_data (GtkObject *@var{object}, const char *@var{key}, gpointer @var{data})
+Associate @var{data} with @var{key} in the data list of @var{object}.
+@end deftypefun
+
+@deftypefun gpointer gtk_object_get_data (GtkObject *@var{object}, const char *@var{key})
+Retrieve the data associated with @var{key} in the data list of @var{object}.
+@end deftypefun
+
+@deftypefun void gtk_object_remove_data (GtkObject *@var{object}, const char *@var{key})
+Remove the data associated with @var{key} in the data list of @var{object}.
+@end deftypefun
+
+@deftypefun void gtk_object_set_user_data (GtkObject *@var{object}, gpointer @var{data})
+Sets @var{data} into the @code{user_data} field of @var{object}.
+@end deftypefun
+
+@deftypefun gpointer gtk_object_get_user_data (GtkObject *@var{object})
+Returns the @code{user_data} field of @var{object}.
+@end deftypefun
+
+@c ------------ Is this deprecated? -----------------
+
+The GtkObject type also provides a mechanism for specifying
+initialization values for fields. This general mechanism is called
+object value stacks. The reason for using value stacks is that they can
+simplify the life of the programmer. For instance, by default widgets
+are non-visible when created. However, the ``visible'' value for widgets
+may be specified so that widgets are made visible when created. (FIXME:
+unfinished).
+
+@deftypefun void gtk_object_value_stack_new (guint @var{object_type}, const gchar *@var{value_id}, GtkParamType @var{value_type})
+@end deftypefun
+
+@deftypefun void gtk_object_push_value (guint @var{object_type}, const gchar *@var{value_id}, @dots{})
+Push a value on the value stack specified by @var{object_type} and
+@var{value_id}. The type of value is implicitly given in the context of
+@var{object_type} and @var{value_id}. (That is, it is not specified
+explicitly in the function call). Only a single extra argument is
+expected which is the data which is to be placed on the stack.
+@end deftypefun
+
+@deftypefun void gtk_object_pop_value (guint @var{object_type}, const gchar *@var{value_id})
+Pop a value of the value stack specified by @var{object_type} and
+@var{value_id}.
+@end deftypefun
+
+@deftypefun gint gtk_object_peek_value (guint @var{object_type}, const gchar *@var{value_id}, gpointer @var{data})
+Peek at the value on the top of the value stack specified by
+@var{object_type} and @var{value_id}. The @var{data} argument is
+interpreted as the location of where to place the ``peeked'' data. For
+instance, if the peeked data is of type @code{GTK_PARAM_POINTER}, then
+@var{data} will be a pointer to a pointer. If the value stack is empty
+or does not exist or an error occurs, @code{gtk_object_peek_value} will
+return @code{FALSE}. On success it will return @code{TRUE}.
+@end deftypefun
+
+
+@node Signals, Widgets, Objects, Top
+@comment node-name, next, previous, up
+@chapter Signals Overview
+@cindex Signals
+
+Signals are GTK's method for objects to perform callbacks. A signal is
+an event which occurs upon an object. The programmer can connect to a
+signal of an object which involves specifying a function to be called
+when that signal is emitted in the specified object.
+
+When a signal is emitted, both the class function associated with the
+signal (when it was defined) and all signal handlers installed for that
+signal on the particular object emitting the signal are called. The
+widget programmer can specify whether the class function is to be called
+before after or both before and after the signal handlers installed by
+the widget user. The widget user can, however, specify that their signal
+handler is to be run after the class function (using the ``_after''
+signal connection routines). Any signal handling function can emit the
+same signal on the same object while it is running causing that signal
+emission to either restart or to run recursively. Additionally, signal
+emission can be terminated prematurely. While both such abilities are
+rarely used, they do allow for greater flexibility in regards to
+signals. For instance, a programmer can attach to the key press event
+signal and intercept all tab key presses from a widget. This particular
+example is used in the file selection dialog to implement tab completion
+of filenames and prevent the entry widget from inserting the tab into
+its buffer.
+
+Signals are selected using either an integer identifier or a character
+string name. It is convention to name the signal the same as the class
+function which is associated with it. There are two versions of most of
+the signal functions, one which takes an integer identifier and one
+which takes a character string name for the signal.
+
+@deftypefun gint gtk_signal_new (gchar *@var{name}, GtkSignalRunType @var{run_type}, gint @var{object_type}, gint @var{function_offset}, GtkSignalMarshaller @var{marshaller}, GtkParamType @var{return_val}, gint @var{nparams}, @dots{})
+Create a new signal and give it the character string identifier
+@var{name}. @var{name} needs to be unique in the context of
+@var{object_type}'s branch of the class hierarchy. That is,
+@var{object_type} cannot create a signal type with the same name as a
+signal type created by one of its parent types.
+
+@var{run_type} specifies whether the class function should be run before
+(@code{GTK_RUN_FIRST}), after (@code{GTK_RUN_LAST}) or both before and
+after normal signal handlers (@code{GTK_RUN_BOTH}). Additionally, the
+@code{GTK_RUN_NO_RECURSE} value can be or'ed with any of those values to
+specify that the signal should not be recursive. By default, emitting
+the same signal on the same widget will cause the signal to be emitted
+twice. However, if the @code{GTK_RUN_NO_RECURSE} flag is specified,
+emitting the same signal on the same widget will cause the current
+signal emission to be restarted. This allows the widget programmer to
+specify the semantics of signal emission on a per signal
+basis. (The @code{GTK_RUN_NO_RECURSE} flag is used by the GtkAdjustment
+widget).
+
+The @var{function_offset} is the byte offset from the start of the class
+structure to the class function field within the class structure. The
+easiest means to compute this offset is by using the
+@code{GTK_SIGNAL_OFFSET} macro which takes the class structure type as
+the first argument and the field as the second argument. For example,
+@code{GTK_SIGNAL_OFFSET (GtkObjectClass, destroy)} will give the offset
+of the @code{destroy} class function within the
+@code{GtkObjectClass}. Note: An offset is specified instead of an
+absolute location since there will be multiple instances of a class
+structure being referenced. (The @code{GtkWidgetClass} structure ``is
+a'' @code{GtkObjectClass} structure, etc.)
+
+The @var{marshaller} function is used to invoke a signal handler. Since
+signal handlers may take different parameters and return values and a
+general mechanism for invoking them is not apparent, the approach of
+making the signal creator responsible for invoking the signal handler
+was taken. (FIXME: unfinished).
+
+The @var{return_val} and @var{nparams} and the remaining arguments
+specify the return value and the arguments to the signal handler
+respectively. Note: There is an implicit first argument to every signal
+handler which is the widget the signal has been emitted from. The
+variable argument list (@var{@dots{}}) specifies the types of the
+arguments. These can be one of @code{GTK_PARAM_CHAR},
+@code{GTK_PARAM_SHORT}, @code{GTK_PARAM_INT}, @code{GTK_PARAM_LONG},
+@code{GTK_PARAM_POINTER} or @code{GTK_PARAM_FUNCTION}. It is undefined
+to specify @code{GTK_PARAM_NONE} as an argument type, however it is OK
+to use @code{GTK_PARAM_NONE} for @var{return_val}. (This corresponds to
+returning a @code{void}).
+
+@code{gtk_signal_new} returns the integer identifier of the newly
+created signal. Signal identifiers start numbering at 1 and increase
+upwards. A value of -1 will be returned if an error occurs.
+
+@strong{Note:} @code{gtk_signal_new} is only needed by widget writers. A
+normal user of GTK will never needed to invoke this function.
+@end deftypefun
+
+@deftypefun gint gtk_signal_lookup (gchar *@var{name}, gint @var{object_type})
+Returns the integer identifier for the signal referenced by @var{name}
+and @var{object_type}. If @var{object_type} does not define the signal
+@var{name}, then the signal is looked for in @var{object_type}'s parent
+type recursively.
+@end deftypefun
+
+@deftypefun gchar* gtk_signal_name (gint @var{signal_num})
+@end deftypefun
+
+@deftypefun gint gtk_signal_emit (GtkObject *@var{object}, gint @var{signal_type}, @dots{})
+Emit the signal specified by the integer identifier @var{signal_type}
+from @var{object}. If an error occurs, @code{gtk_signal_emit} will
+return @code{FALSE} and will return @code{TRUE} on success. The signal
+definition determines the parameters passed in the variable argument
+list (@code{@dots{}}). For example, if the signal is defined as:
+
+@example
+ gint (* event) (GtkWidget *widget, GdkEvent *event);
+@end example
+
+Then a call to emit the ``event'' signal would look like:
+
+@example
+ GdkEvent event;
+ gint return_val;
+ @dots{}
+ gtk_signal_emit (some_object,
+ gtk_signal_lookup ("event",
+ GTK_OBJECT_TYPE (some_object)),
+ &event, &return_val);
+@end example
+
+Notice that the @code{widget} argument is implicit in that the first
+argument to every signal is a type derived from @code{GtkObject}. The
+@var{return_val} argument is actually a pointer to the return value type
+since the signal mechanism needs to be able to place the return value in
+an actual location. And lastly, the @code{gtk_signal_lookup} call is
+normally avoided by using the @code{gtk_signal_emit_by_name} function
+instead. @code{gtk_signal_emit} is normally used internally by widgets
+which know the signal identifier (since they defined the signal) and can
+therefore side-step the cost of calling @code{gtk_signal_lookup}.
+@end deftypefun
+
+@deftypefun gint gtk_signal_emit_by_name (GtkObject *@var{object}, gchar *@var{name}, @dots{})
+Similar to @code{gtk_signal_emit} except that the signal is referenced
+by @var{name} instead of by its integer identifier.
+@end deftypefun
+
+@deftypefun void gtk_signal_emit_stop (GtkObject *@var{object}, gint @var{signal_type})
+Stop the emission of the signal @var{signal_type} on
+@var{object}. @var{signal_type} is the integer identifier for the signal
+and can be determined using the function
+@code{gtk_signal_lookup}. Alternatively, the function
+@code{gtk_signal_emit_stop_by_name} can be used to refer to the signal
+by name. Attempting to stop the emission of a signal that isn't being
+emitted does nothing.
+@end deftypefun
+
+@deftypefun void gtk_signal_emit_stop_by_name (GtkObject *@var{object}, gchar *@var{name})
+Similar to @code{gtk_signal_emit_stop} except that the signal is
+referenced by @var{name} instead of by its integer identifier.
+@end deftypefun
+
+@deftypefun gint gtk_signal_connect (GtkObject *@var{object}, gchar *@var{name}, GtkSignalFunc @var{func}, gpointer @var{func_data})
+Connects a signal handling function to a signal emitting
+object. @var{func} is connected to the signal @var{name} emitted by
+@var{object}. The arguments and returns type of @var{func} should match
+the arguments and return type of the signal @var{name}. However,
+@var{func} may take the extra argument of @var{func_data}. Due to the C
+calling convention it is OK to ignore the extra argument. (It is OK to
+ignore all the arguments in fact).
+
+@code{gtk_signal_connect} returns an integer identifier for the
+connection which can be used to refer to it in the future. Specifically
+it is useful for removing the connection and/or blocking it from being
+used.
+@end deftypefun
+
+@deftypefun gint gtk_signal_connect_after (GtkObject *@var{object}, gchar *@var{name}, GtkSignalFunc @var{func}, gpointer @var{func_data})
+Similar to @code{gtk_signal_connect} except the signal handler is
+connected in the ``after'' slot. This allows a signal handler to be
+guaranteed to run after other signal handlers connected to the same
+signal on the same object and after the class function associated with
+the signal.
+
+Like @code{gtk_signal_connect}, @code{gtk_signal_connect_after} returns
+an integer identifier which can be used to refer to the connection.
+@end deftypefun
+
+@deftypefun gint gtk_signal_connect_object (GtkObject *@var{object}, gchar *@var{name}, GtkSignalFunc @var{func}, GtkObject *@var{slot_object})
+Connects @var{func} to the signal @var{name} emitted by
+@var{object}. Similar to @code{gtk_signal_connect} with the difference
+that @var{slot_object} is passed as the first parameter to @var{func}
+instead of the signal emitting object. This can be useful for connecting
+a signal emitted by one object to a signal in another object. A common
+usage is to connect the ``destroy'' signal of dialog to the ``clicked''
+signal emitted by a ``close'' button in the dialog. That is, the
+``clicked'' signal emitted by the button will caused the ``destroy''
+signal to be emitted for the dialog. This is also the ``right'' way to
+handle closing of a dialog since the ``destroy'' signal will be sent if
+the dialog is deleted using a window manager function and this enables
+the two methods of closing the window to be handled by the same
+mechanism. Returns an integer identifier which can be used to refer to
+the connection.
+@end deftypefun
+
+@deftypefun gint gtk_signal_connect_object_after (GtkObject *@var{object}, gchar *@var{name}, GtkSignalFunc @var{func}, GtkObject *@var{slot_object})
+Similar to @code{gtk_signal_connect_object} except the signal handler is
+connected in the ``after'' slot. This allows a signal handler to be
+guaranteed to run after other signal handlers connected to the same
+signal on the same object and after the class function associated with
+the signal. Returns an integer identifier which can be used to refer to
+the connection.
+@end deftypefun
+
+@deftypefun gint gtk_signal_connect_interp (GtkObject *@var{object}, gchar *@var{name}, GtkCallbackMarshal @var{func}, gpointer @var{data}, GtkDestroyNotify @var{destroy_func}, gint @var{after})
+@end deftypefun
+
+@deftypefun void gtk_signal_disconnect (GtkObject *@var{object}, gint @var{id})
+Disconnects a signal handler from an object. The signal handler is
+identified by the integer @var{id} which is returned by the
+@code{gtk_signal_connect*} family of functions.
+@end deftypefun
+
+@deftypefun void gtk_signal_disconnect_by_data (GtkObject *@var{object}, gpointer @var{data})
+Disconnects a signal handler from an object. The signal handler is
+identified by the @var{data} argument specified as the @var{func_data}
+argument to the @code{gtk_signal_connect*} family of functions. For the
+@code{gtk_signal_connect_object*} functions, @var{data} refers to the
+@var{slot_object}.
+
+@strong{Note:} This will remove all signal handlers connected to
+@var{object} which were connected using @var{data} as their
+@var{func_data} argument. Multiple signal handlers may be disconnected
+with this call.
+@end deftypefun
+
+@deftypefun void gtk_signal_handler_block (GtkObject *@var{object}, gint @var{id})
+Blocks calling of a signal handler during signal emission. The signal
+handler is identified by the integer @var{id} which is returned by the
+@code{gtk_signal_connect*} family of functions. If the signal is already
+blocked no change is made.
+@end deftypefun
+
+@deftypefun void gtk_signal_handler_block_by_data (GtkObject *@var{object}, gint @var{data})
+Blocks calling of a signal handler during signal emission. The signal
+handler is identified by the @var{data} argument specified as the
+@var{func_data} argument to the @code{gtk_signal_connect*} family of
+functions. For the @code{gtk_signal_connect_object*} functions,
+@var{data} refers to the @var{slot_object}. If the signal is already
+blocked no change is made.
+
+@strong{Note:} This will block all signal handlers connected to
+@var{object} which were connected using @var{data} as their
+@var{func_data} argument. Multiple signal handlers may be blocked
+with this call.
+@end deftypefun
+
+@deftypefun void gtk_signal_handler_unblock (GtkObject *@var{object}, gint @var{id})
+Unblocks calling of a signal handler during signal emission. The signal
+handler is identified by the integer @var{id} which is returned by the
+@code{gtk_signal_connect*} family of functions. If the signal is already
+unblocked no change is made.
+@end deftypefun
+
+@deftypefun void gtk_signal_handler_unblock_by_data (GtkObject *@var{object}, gint @var{data})
+Unblocks calling of a signal handler during signal emission. The signal
+handler is identified by the @var{data} argument specified as the
+@var{func_data} argument to the @code{gtk_signal_connect*} family of
+functions. For the @code{gtk_signal_connect_object*} functions,
+@var{data} refers to the @var{slot_object}. If the signal is already
+unblocked no change is made.
+
+@strong{Note:} This will unblock all signal handlers connected to
+@var{object} which were connected using @var{data} as their
+@var{func_data} argument. Multiple signal handlers may be unblocked
+with this call.
+@end deftypefun
+
+@deftypefun void gtk_signal_handlers_destroy (GtkObject *@var{object})
+Destroy all of the signal handlers connected to @var{object}. There
+should normally never be reason to call this function as it is called
+automatically when @var{object} is destroyed.
+@end deftypefun
+
+@deftypefun void gtk_signal_default_marshaller (GtkObject *@var{object}, GtkSignalFunc @var{func}, gpointer @var{func_data}, GtkSignalParam *@var{params})
+@code{gtk_signal_new} requires a callback in order to actually call a
+signal handler for a particular signal. The vast majority of signals are
+of the particular form:
+
+@example
+ (* std_signal) (gpointer std_arg);
+@end example
+
+@code{gtk_signal_default_marshaller} is a signal marshaller which
+marshals arguments for a signal of that form.
+@end deftypefun
+
+@deftypefun void gtk_signal_set_funcs (GtkSignalMarshal @var{marshal_func}, GtkSignalDestroy @var{destroy_fun})
+@end deftypefun
+
+
+@node Widgets, Other Objects, Signals, Top
+@comment node-name, next, previous, up
+@chapter Widget Overview
+@cindex Widgets
+
+
+Widgets are the general term used to describe user interface objects. A
+widget defines a class interface that all user interface objects conform
+to. This interface allows a uniform method for dealing with operations
+common to all objects such as hiding and showing, size requisition and
+allocation and events.
+
+The common interface that widgets must adhere to is described by the
+GtkWidget and GtkWidgetClass structure. For the purposes of using GTK
+these structures can be considered read-only and, for the most part,
+opaque.
+
+All widget creation routines in GTK return pointers to GtkWidget
+structures. In reality, all widget creation routines create structures
+that can be viewed as equivalent to the GtkWidget structure, but often
+have contain additional information. @xref{Object Implementation}
+
+The widgets available for use are implemented in a hierarchy. Several
+widgets exist solely as common bases for more specific widgets. For
+example, it is not possible to create a ruler widget itself, but the
+ruler widget provides a base and functionality common to the horizontal
+and vertical rulers.
+
+The available widgets (in alphabetical order):
+
+@menu
+* GtkAlignment:: The alignment widget.
+* GtkArrow:: The arrow widget.
+* GtkAspectFrame:: The aspect frame widget.
+* GtkBin:: The bin widget.
+* GtkBox:: The box widget.
+* GtkButtonBox:: The button box widget.
+* GtkButton:: The button widget.
+* GtkCheckButton:: The check button widget.
+* GtkCheckMenuItem:: The check menu item widget.
+* GtkCList:: The compound list widget.
+* GtkColorSelection:: The color selector widget.
+* GtkCombo:: The combo box widget.
+* GtkContainer:: The container widget.
+* GtkCurve:: The curve widget.
+* GtkDialog:: The dialog widget.
+* GtkDrawingArea:: The drawing area widget.
+* GtkEntry:: The entry widget.
+* GtkEventBox:: The event box widget.
+* GtkFileSelection:: The file selection dialog widget.
+* GtkFixed:: The fixed widget.
+* GtkFrame:: The frame widget.
+* GtkGamma:: The gamma widget.
+* GtkHBox:: The horizontal box widget.
+* GtkHButtonBox:: The horizontal button box widget.
+* GtkHPaned:: The horizontal paned widget.
+* GtkHRuler:: The horizontal ruler widget.
+* GtkHScale:: The horizontal scale widget.
+* GtkHScrollbar:: The horizontal scrollbar widget.
+* GtkHSeparator:: The horizontal separator widget.
+* GtkImage:: The image widget.
+* GtkInputDialog:: The input dialog widget.
+* GtkItem:: The item widget.
+* GtkLabel:: The label widget.
+* GtkList:: The list widget.
+* GtkListItem:: The list item widget.
+* GtkMenu:: The menu widget.
+* GtkMenuBar:: The menu bar widget.
+* GtkMenuItem:: The menu item widget.
+* GtkMenuShell:: The menu shell widget.
+* GtkMisc:: The misc widget.
+* GtkNotebook:: The notebook widget.
+* GtkOptionMenu:: The option menu widget.
+* GtkPaned:: The paned widget.
+* GtkPixmap:: The pixmap widget.
+* GtkPreview:: The preview widget.
+* GtkProgressBar:: The progress bar widget.
+* GtkRadioButton:: The radio button widget.
+* GtkRadioMenuItem:: The radio menu item widget.
+* GtkRange:: The range widget.
+* GtkRuler:: The ruler widget.
+* GtkScale:: The scale widget.
+* GtkScrollbar:: The scrollbar widget.
+* GtkScrolledWindow:: The scrolled window widget.
+* GtkSeparator:: The separator widget.
+* GtkStatusbar:: The statusbar widget.
+* GtkTable:: The table widget.
+* GtkText:: The text widget.
+* GtkToggleButton:: The toggle button widget.
+* GtkToolbar:: The tool bar widget.
+* GtkTooltips:: The tool tips widget.
+* GtkTree:: The tree widget.
+* GtkTreeItem:: The tree item widget.
+* GtkVBox:: The vertical box widget.
+* GtkVButtonBox:: The vertical button box widget.
+* GtkViewport:: The viewport widget.
+* GtkVPaned:: The vertical paned widget.
+* GtkVRuler:: The vertical ruler widget.
+* GtkVScale:: The vertical scale widget.
+* GtkVScrollbar:: The vertical scrollbar widget.
+* GtkVSeparator:: The vertical separator widget.
+* GtkWidget:: The base widget type.
+* GtkWindow:: The window widget.
+@end menu
+
+@node GtkAlignment, GtkArrow, Widgets, Widgets
+@comment node-name, next, previous, up
+@section The alignment widget
+
+
+@subsection Description
+
+The alignment widget is a container (@pxref{GtkContainer}) derived from
+the bin widget (@pxref{GtkBin}). Its entire purpose is to give the
+programmer flexibility in how the child it manages is positioned when a
+window is resized.
+
+Normally, a widget is allocated at least as much size as it
+requests. (@pxref{GtkContainer} for a discussion of geometry
+management). When a widget is allocated more size than it requests there
+is a question of how the widget should expand. By convention, most GTK
+widgets expand to fill their allocated space. Sometimes this behavior is
+not desired. The alignment widget allows the programmer to specify how a
+widget should expand and position itself to fill the area it is
+allocated.
+
+@subsection Options
+
+@defopt xscale
+@defoptx yscale
+The @var{xscale} and @var{yscale} options specify how to scale the child
+widget. If the scale value is 0.0, the child widget is allocated exactly
+the size it requested in that dimension. If the scale value is 1.0, the
+child widget is allocated all of the space in a dimension. A scale value
+of 1.0 for both x and y is equivalent to not using an alignment widget.
+@end defopt
+
+@defopt xalign
+@defoptx yalign
+The @var{xalign} and @var{yalign} options specify how to position the
+child widget when it is not allocated all the space available to it
+(because the @var{xscale} and/or @var{yscale} options are less than
+1.0). If an alignment value is 0.0 the widget is positioned to the left
+(or top) of its allocated space. An alignment value of 1.0 positions the
+widget to the right (or bottom) of its allocated space. A common usage
+is to specify @var{xalign} and @var{yalign} to be 0.5 which causes the
+widget to be centered within its allocated area.
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_alignment_get_type (void)
+Returns the @code{GtkAlignment} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_alignment_new (gfloat @var{xalign}, gfloat @var{yalign}, gfloat @var{xscale}, gfloat @var{yscale})
+Create a new @code{GtkAlignment} object and initialize it with the
+values @var{xalign}, @var{yalign}, @var{xscale} and @var{yscale}. The
+new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_alignment_set (GtkAlignment *@var{alignment}, gfloat @var{xalign}, gfloat @var{yalign}, gfloat @var{xscale}, gfloat @var{yscale})
+Set the @var{xalign}, @var{yalign}, @var{xscale} and @var{yscale} options
+of an alignment widget. It is important to not set the fields of the
+@code{GtkAlignment} structure directly (or, for that matter, any type
+derived from @code{GtkObject}).
+@end deftypefun
+
+@gtkstdmacros{Alignment, ALIGNMENT}
+
+@page
+@node GtkArrow, GtkAspectFrame, GtkAlignment, Widgets
+@comment node-name, next, previous, up
+@section The arrow widget
+
+@subsection Description
+
+The arrow widget is derived from the misc widget (@pxref{GtkMisc}) and
+is intended for use where a directional arrow (in one of the four
+cardinal directions) is desired. As such, it has very limited
+functionality and basically only draws itself in a particular direction
+and with a particular shadow type. The arrow widget will expand to fill
+all the space it is allocated.
+
+@subsection Options
+
+@defopt arrow_type
+The @var{arrow_type} option specifies which direction the arrow will
+point. It can be one of @code{GTK_ARROW_UP}, @code{GTK_ARROW_DOWN},
+@code{GTK_ARROW_LEFT} or @code{GTK_ARROW_RIGHT}. This will set the arrow
+pointing in the direction specified.
+@end defopt
+
+@defopt shadow_type
+The @var{shadow_type} option specifies how to draw the shadow for the
+arrow. Currently, only the @code{GTK_SHADOW_IN} and
+@code{GTK_SHADOW_OUT} shadow types are supported for drawing
+arrows. Other shadow types will cause nothing to be drawn.
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_arrow_get_type (void)
+Returns the @code{GtkArrow} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_arrow_new (GtkArrowType @var{arrow_type}, GtkShadowType @var{shadow_type})
+Create a new @code{GtkArrow} object and initialize it with the values
+@var{arrow_type} and @var{shadow_type}. The new widget is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on
+failure.
+@end deftypefun
+
+@deftypefun void gtk_arrow_set (GtkArrow *@var{arrow}, GtkArrowType @var{arrow_type}, GtkShadowType @var{shadow_type})
+Set the @var{arrow_type} and @var{shadow_type} options of an arrow
+widget. It is important to not set the fields of the @code{GtkArrow}
+structure directly (or, for that matter, any type derived from
+@code{GtkObject}).
+@end deftypefun
+
+@gtkstdmacros{Arrow, ARROW}
+
+
+@page
+@node GtkAspectFrame, GtkBin, GtkArrow, Widgets
+@comment node-name, next, previous, upa
+@section The aspect frame widget
+
+@subsection Description
+
+Ensure that the child window has a specified aspect ratio or, if
+obey_child, has the same aspect ratio as its requested size. Derived
+from @pxref{GtkFrame}).
+
+@subsection Options
+
+@defopt label
+@end defopt
+
+@defopt xalign
+@end defopt
+
+@defopt yalign
+@end defopt
+
+@defopt ratio
+@end defopt
+
+@defopt obey_child
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_aspect_frame_get_type (void)
+Returns the @code{GtkAspectFrame} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_aspect_frame_new (gchar *@var{label}, gfloat @var{xalign}, gfloat @var{yalign}, gfloat @var{ratio}, gint @var{obey_child})
+Create a new @code{GtkAspectFrame} object and initialize it with the values
+@var{label}, @var{xalign}, @var{yalign}, @var{ratio} and @var{obey_child}.
+The new widget is returned as a pointer to a @code{GtkWidget} object.
+@code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_aspect_frame_set (GtkAspectFrame *@var{aspect_frame}, gfloat @var{xalign}, gfloat @var{yalign}, gfloat @var{ratio}, gint @var{obey_child})
+@end deftypefun
+
+
+@gtkstdmacros{AspectFrame, ASPECT_FRAME}
+
+@page
+@node GtkBin, GtkBox, GtkAspectFrame, Widgets
+@comment node-name, next, previous, up
+@section The bin widget
+
+@subsection Description
+
+The bin widget is a container (@pxref{GtkContainer}) derived from the
+container widget. It is an abstract base class. That is, it is not
+possible to create an actual bin widget. It exists only to provide a
+base of functionality for other widgets. Specifically, the bin widget
+provides a base for several other widgets that contain only a single
+child. These widgets include alignments (@pxref{GtkAlignment}), frames
+(@pxref{GtkFrame}), items (@pxref{GtkItem}), viewports
+(@pxref{GtkViewport}) and windows (@pxref{GtkWindow})
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_bin_get_type (void)
+Returns the @code{GtkBin} type identifier.
+@end deftypefun
+
+@gtkstdmacros{Bin, BIN}
+
+
+@page
+@node GtkBox, GtkButtonBox, GtkBin, Widgets
+@comment node-name, next, previous, up
+@section The box widget
+
+
+@subsection Description
+
+The box widget is a container (@pxref{GtkContainer}) derived from the
+container widget. It is an abstract base class used by the horizontal
+box (@pxref{GtkHBox}), the vertical box (@pxref{GtkVBox}) and the
+(@pxref{GtkButtonBox}) widgets to provide a base of common functionality.
+
+A box provides an abstraction for organizing the position and size of
+widgets. Widgets in a box are laid out horizontally or vertically. By
+using a box widget appropriately, a programmer can control how widgets
+are positioned and how they will be allocated space when a window gets
+resized.
+
+The key attribute of boxes is that they position their children in a
+single row (horizontal boxes) or column (vertical boxes). In the case of
+horizontal boxes, all children are stretched vertically. The vertical
+size of the box is determined by the largest vertical requisition of all
+of its children. Similarly, a vertical box stretches all of its children
+horizontally. The horizontal size (of the vertical box) is determined by
+the largest horizontal requisition of all of its children. An alignment
+widget (@pxref{GtkAlignment}) can be used to control child allocation
+more precisely on a per child basis.
+
+The second attribute of boxes is how they expand children. In the case
+of a horizontal box, the main control is over how children are expanded
+horizontally to fill the allocated area. (The rest of this discussion
+will focus on horizontal boxes but it applies to vertical boxes as
+well).
+
+There are two flags which can be set controlling how a widget is
+expanded horizontally in a horizontal box. These are the @code{expand}
+and @code{fill}. There operation is fairly simple. If @code{expand} is
+set, the child's potentially allocated area will expand to fill available
+space. If @code{fill} is set, the child's actual allocated area will be
+its potentially allocated area. There is a difference between
+the potentially area (which is the area the box widget sets aside for
+the child) and the actual allocated area (which is the area the box
+widget actual allocates for the widget via
+@code{gtk_widget_size_allocate}).
+
+The allocation of space to children occurs as follows (for horizontal
+boxes):
+@enumerate
+@item
+All children are allocated at least their requested size horizontally
+and the maximum requested child size vertically.
+
+@item
+Any child with the @code{expand} flag set is allocated @code{extra_width
+/ nexpand_children} extra pixels horizontally. If the @code{homogeneous}
+flag was set, all children are considered to have the @code{expand} flag
+set. That is, all children will be allocated the same area.The
+horizontal box is a fair widget and, as such, divides up any extra
+allocated space evenly among the ``expand'' children. (Those children
+which have the @code{expand} flag set). The exception occurs when
+@code{extra_width / nexpand_children} does not divide cleanly. The extra
+space is given to the last widget.
+
+@item
+@code{spacing} number of pixels separate each child. Note: The
+separation is between the potentially allocated area for each child and
+not the actual allocated area. The @code{padding} value associated with
+each child causes that many pixels to be left empty to each side of the
+child.
+
+@item
+If a child has the @code{fill} flag set it is allocated its potentially
+allocated area. If it does not, it is allocated its requested size
+horizontally and centered within its potentially allocated area. Its
+vertical allocation is still the maximum requested size of any child.
+
+@item
+Children placed at the start of the box are placed in order of addition
+to the box from left to right in the boxes allocated area.. Children
+placed at the end of the box are placed in order of addition from right
+to left in the boxes allocated area.
+@end enumerate
+
+@xref{GtkHBox}, and @ref{GtkVBox}, for code examples of using horizontal
+and vertical boxes.
+
+@subsection Options
+
+@defopt expand
+@end defopt
+
+@defopt fill
+@end defopt
+
+@defopt padding
+@end defopt
+
+@defopt expand
+@end defopt
+
+@c FIXME: options for GtkBox
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_box_get_type (void)
+Returns the @code{GtkBox} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_box_pack_start (GtkBox *@var{box}, GtkWidget *@var{child}, gint @var{expand}, gint @var{fill}, gint @var{padding})
+Add @var{child} to the front of @var{box}. The flags @var{expand} and
+@var{fill} and the padding value of @var{padding} are associated with
+@var{child}.
+@end deftypefun
+
+@deftypefun void gtk_box_pack_end (GtkBox *@var{box}, GtkWidget *@var{child}, gint @var{expand}, gint @var{fill}, gint @var{padding})
+Add @var{child} to the end of @var{box}. The flags @var{expand} and
+@var{fill} and the padding value of @var{padding} are associated with
+@var{child}.
+@end deftypefun
+
+@deftypefun void gtk_box_pack_start_defaults (GtkBox *@var{box}, GtkWidget *@var{widget})
+A convenience function which is equivalent to the following:
+
+@example
+ gtk_box_pack_start (@var{box}, @var{widget}, TRUE, TRUE, 0);
+@end example
+@end deftypefun
+
+@deftypefun void gtk_box_pack_end_defaults (GtkBox *@var{box}, GtkWidget *@var{widget})
+A convenience function which is equivalent to the following:
+
+@example
+ gtk_box_pack_start (@var{box}, @var{widget}, TRUE, TRUE, 0);
+@end example
+@end deftypefun
+
+@deftypefun void gtk_box_set_homogeneous (GtkBox *@var{box}, gint @var{homogeneous})
+Set the homogeneous setting of this box to @var{homogeneous}.
+@end deftypefun
+
+@deftypefun void gtk_box_set_spacing (GtkBox *@var{box}, gint @var{spacing})
+@end deftypefun
+
+@deftypefun void gtk_box_reorder_child (GtkBox *@var{box}, GtkWidget *@var{child}, guint @var{pos})
+@end deftypefun
+
+@deftypefun void gtk_box_query_child_packing (GtkBox *@var{box}, GtkWidget *@var{child}, gint *@var{expand}, gint *@var{fill}, gint *@var{padding}, GtkPackType *@var{pack_type})
+@end deftypefun
+
+@deftypefun void gtk_box_set_child_packing (GtkBox *@var{box}, GtkWidget *@var{child}, gint @var{expand}, gint @var{fill}, gint @var{padding}, GtkPackType *@var{pack_type})
+@end deftypefun
+
+@gtkstdmacros{Box, BOX}
+
+
+@page
+@node GtkButtonBox, GtkButton, GtkBox, Widgets
+@comment node-name, next, previous, up
+@section The button box widget
+
+@subsection Description
+The button box widget is a container (@pxref{GtkContainer}) derived from the
+(@pxref{GtkBox}) widget. It is an abstract base class used by the horizontal
+button box (@pxref{GtkHButtonBox}) and the vertical button box
+(@pxref{GtkVButtonBox}) widgets to provide a base of common functionality.
+
+The button box, like the box widget, (@pxref{GtkBox}) provides an abstraction
+for organizing position and size of widgets. In the case of the button box
+it is targeted at the button widget,(@pxref{GtkButton}). Button widgets are
+laid out in the box horizontally or vertically. By using a button box widget
+appropriately, a programmer can control how the button widgets are positioned
+and how they will be allocated space when a window gets resized.
+
+@subsection Options
+@defopt layout_style
+@itemize @bullet
+@itemize @bullet
+@item
+@code{GTK_BUTTONBOX_SPREAD}
+@end itemize
+
+@item
+The layout style @code{GTK_BUTTONBOX_SPREAD} will spread the buttons out
+evenly within the button box. When the parent window is resized they will
+re-adjust to the new window dimensions. The @code{gtk_button_box_set_spacing}
+function will set the minimum space that the buttons will leave between
+themselves.
+
+@itemize @bullet
+@item
+@code{GTK_BUTTONBOX_EDGE}
+@end itemize
+@item
+
+@itemize @bullet
+@item
+@code{GTK_BUTTONBOX_START}
+@end itemize
+
+@item
+The layout style @code{GTK_BUTTONBOX_START} will place the buttons at the
+start of the button box, taking into account the spacing as set by the
+@code{gtk_button_box_set_spacing} function. The buttons will not move
+when the parent window is re-sized.
+
+@itemize @bullet
+@item
+@code{GTK_BUTTONBOX_END}
+@end itemize
+
+@item
+The layout style @code{GTK_BUTTONBOX_END} will place the buttons at the
+end of the button box, taking into account the spacing as set by the
+@code{gtk_button_box_set_spacing} function. Again like the
+@code{GTK_BUTTONBOX_START} layout style the buttons will not move when
+the parent window is re-sized.
+@end itemize
+@end defopt
+
+@defopt width
+@end defopt
+
+@defopt height
+@end defopt
+
+@defopt ipad_x
+@defoptx ipad_y
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_button_box_get_type (void)
+Returns the @code{GtkButtonBox} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_button_box_set_child_size_default (gint @var{width}, gint@var{height})
+@end deftypefun
+
+@deftypefun void gtk_button_box_set_child_ipadding_default (gint @var{ipad_x}, gint @var{ipad_y})
+@end deftypefun
+
+@deftypefun void gtk_button_box_get_child_size_default (gint *@var{width}, gint *@var{height})
+@end deftypefun
+
+@deftypefun void gtk_button_box_get_child_ipadding_default (gint *@var{ipad_x}, gint *@var{ipad_y})
+@end deftypefun
+
+@deftypefun void gtk_button_box_set_child_size (GtkButtonBox *@var{widget}, gint @var{width}, gint @var{height})
+@end deftypefun
+
+@deftypefun void gtk_button_box_set_child_ipadding (GtkButtonBox *@var{widget}, gint @var{ipad_x}, gint @var{ipad_y})
+@end deftypefun
+
+@deftypefun void gtk_button_box_set_layout (GtkButtonBox *@var{widget}, gint @var{layout_style})
+This will set the layout style of the buttons within this box. Currently it can
+be set to one of @code{GTK_BUTTONBOX_SPREAD}, @code{GTK_BUTTONBOX_EDGE},
+@code{GTK_BUTTONBOX_START} or @code{GTK_BUTTONBOX_END}.
+
+The following example:
+@example
+ gtk_button_box_set_layout (GTK_BUTTON_BOX (box),
+ GTK_BUTTONBOX_SPREAD);
+@end example
+Will set the @var{box} argument to the @dfn{SPREAD} layout style described
+above.
+@end deftypefun
+
+@deftypefun gint gtk_button_box_get_spacing (GtkButtonBox *@var{widget})
+Get the per widget value for spacing within the button box. This value is
+the amount of space that will be between the individual buttons contained by
+this box.
+@end deftypefun
+
+@deftypefun void gtk_button_box_get_child_size (GtkButtonBox *@var{widget}, gint *@var{width}, gint *@var{height})
+@end deftypefun
+
+@deftypefun void gtk_button_box_get_child_ipadding (GtkButtonBox *@var{widget}, gint *@var{ipad_x}, gint *@var{ipad_y})
+Get the per widget value for the padding inside the buttons. This value
+controls how large the buttons will be within the box.
+@end deftypefun
+
+@deftypefun gint gtk_button_box_get_layout (GtkButtonBox *@var{widget})
+Get the @var{layout_style} for the @code{GtkButtonBox} object passed to this
+function in the @var{widget} variable.
+
+@example
+ layout = gtk_button_box_get_layout(GTK_BUTTON_BOX (box));
+@end example
+
+@end deftypefun
+
+@gtkstdmacros{ButtonBox, BUTTON_BOX}
+
+@page
+@node GtkButton, GtkCheckButton, GtkButtonBox, Widgets
+@comment node-name, next, previous, up
+@section The button widget
+
+
+@subsection Description
+
+A pressable button. Contains a widget. Changes its appearance
+(hilites) when it gets the focus. Changes its appearance (pressed) when
+activated. Derived from @pxref{GtkContainer}.
+
+@subsection Signals
+
+@deftypefn Signal void GtkButton::pressed (GtkButton *@var{button})
+@end deftypefn
+
+@deftypefn Signal void GtkButton::released (GtkButton *@var{button})
+@end deftypefn
+
+@deftypefn Signal void GtkButton::clicked (GtkButton *@var{button})
+@end deftypefn
+
+@deftypefn Signal void GtkButton::enter (GtkButton *@var{button})
+@end deftypefn
+
+@deftypefn Signal void GtkButton::leave (GtkButton *@var{button})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_button_get_type (void)
+Returns the @code{GtkButton} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_button_new (void)
+Create a new @code{GtkButton} object. The new widget is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_button_new_with_label (gchar *@var{label})
+Create a new @code{GtkButton} object and set the text that is
+on the button to @var{label}. The new widget is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_button_pressed (GtkButton *@var{button})
+@end deftypefun
+
+@deftypefun void gtk_button_released (GtkButton *@var{button})
+@end deftypefun
+
+@deftypefun void gtk_button_clicked (GtkButton *@var{button})
+@end deftypefun
+
+@deftypefun void gtk_button_enter (GtkButton *@var{button})
+@end deftypefun
+
+@deftypefun void gtk_button_leave (GtkButton *@var{button})
+@end deftypefun
+
+@gtkstdmacros{Button, BUTTON}
+
+
+@page
+@node GtkCheckButton, GtkCheckMenuItem, GtkButton, Widgets
+@comment node-name, next, previous, up
+@section The check button widget
+
+
+@subsection Description
+
+Another form of toggle button (@pxref{GtkToggleButton}) with an
+indicator. Contains a widget to the right of the indicator. Changes
+its appearance (hilites) when it gets the focus.
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_check_button_get_type (void)
+Returns the @code{GtkCheckButton} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_check_button_new (void)
+Create a new @code{GtkCheckButton} object and initialize it with the
+default values in the library. The new widget is returned as a pointer
+to a @code{GtkWidget} object. A @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_check_button_new_with_label (gchar *@var{label})
+Create a new @code{GtkCheckButton} object and initialize it with the
+values @var{label}. The new widget is returned as a pointer to a
+@code{GtkWidget} object. @code{NULL} is returned on any failure.
+@end deftypefun
+
+@deftypefun GtkCheckButton* GTK_CHECK_BUTTON (gpointer @var{obj})
+@end deftypefun
+
+@deftypefun GtkCheckButtonClass* GTK_CHECK_BUTTON_CLASS (gpointer @var{class})
+@end deftypefun
+
+@deftypefun gint GTK_IS_CHECK_BUTTON (gpointer @var{obj})
+@end deftypefun
+
+@gtkstdmacros{CheckButton, CHECK_BUTTON}
+
+@page
+@node GtkCheckMenuItem, GtkCList, GtkCheckButton, Widgets,
+@comment node-name, next, previous, up
+@section The check menu item widget
+
+@subsection Description
+
+Derived from @pxref{GtkMenuItem}. Very similar to a checkbutton
+(@pxref{GtkCheckButton}), except that it's a menu item. Has a toggled
+state which is displayed in a small rectangle to the left of the
+contained widget.
+
+@subsection Options
+
+@defopt label
+@end defopt
+
+@defopt state
+@end defopt
+
+@subsection Signals
+
+@deftypefn Signal void GtkCheckMenuItem::toggled (GtkCheckMenuItem *@var{check_menu_item})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_check_menu_item_get_type (void)
+Returns the @code{GtkCheckMenuItem} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_check_menu_item_new (void)
+Create a new @code{GtkCheckMenuItem} object. The new widget is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_check_menu_item_new_with_label (gchar *@var{label})
+Create a new @code{GtkCheckMenuItem} object and initialize it with the values
+@var{label}. The new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_check_menu_item_set_state (GtkCheckMenuItem *@var{check_menu_item}, gint @var{state})
+@end deftypefun
+
+@deftypefun void gtk_check_menu_item_toggled (GtkCheckMenuItem *@var{check_menu_item})
+@end deftypefun
+
+@gtkstdmacros{CheckMenuItem, CHECK_MENU_ITEM}
+
+@page
+@node GtkCList, GtkColorSelection, GtkCheckMenuItem, Widgets
+@comment node-name, next, previous, up
+@section The compound list widget
+
+@subsection Description
+
+A list of rows of columns, with a title row. You can insert rows, and
+delete rows. The user can scroll around and select a row. Derived from
+@pxref{GtkContainer}. Cells can be empty, have a text and/or pixmap, or
+be a widget.
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_clist_get_type (void)
+Returns the @code{GtkCList} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_clist_new (int @var{columns})
+Create a new @code{GtkCList} initializing it with the value @var{columns}.
+The new widget is returned as a pointer to a @code{GtkWidget} object.
+@code{NULL} is returned on failure.
+@end deftypefun
+
+
+@deftypefun GtkWidget* gtk_clist_new_with_titles (int @var{columns}, gchar *@var{titles[]})
+@end deftypefun
+
+@deftypefun void gtk_clist_set_border (GtkCList *@var{clist}, GtkShadowType @var{border})
+Set the border style of the @var{clist} to the shadow type @var{border}.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_selection_mode (GtkCList *@var{clist} GtkSelectionMode @var{mode})
+Set the selection mode on the @var{clist} to the @var{mode} selection mode.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_policy (GtkCList *@var{clist}, GtkPolicyType @var{vscrollbar_policy}, GtkPolicyType @var{hscrollbar_policy})
+Set the policy on the scrollbars on the @var{clist} to @var{vscrollbar_policy} and @var{hscrollbar_policy}.
+@end deftypefun
+
+@deftypefun void gtk_clist_freeze (GtkCList *@var{clist})
+Stop all visual updates of the @var{clist}. Useful for when making a large
+number of changes to a @code{GtkCList}.
+@end deftypefun
+
+@deftypefun void gtk_clist_thaw (GtkCList *@var{clist})
+Allow all visual updates of the @var{clist} to resume.
+@end deftypefun
+
+@deftypefun void gtk_clist_column_titles_show (GtkCList *@var{clist})
+Show the column title buttons on the @var{clist}.
+@end deftypefun
+
+@deftypefun void gtk_clist_column_titles_hide (GtkCList *@var{clist})
+Hide the column title buttons on the @var{clist}.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_column_title (GtkCList *@var{clist}, gint @var{column}, gchar *@var{title})
+Set the title in column @var{column} of the @var{clist} button to @var{title}.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_column_widget (GtkCList *@var{clist}, gint @var{column}, GtkWidget *@var{widget})
+Set the @var{widget} instead of the title button for the column @var{column}
+in the @var{clist}.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_column_justification (GtkCList *@var{clist}, gint @var{column}, GtkJustification @var{justification})
+Set the @var{column}'s justification, in the @var{clist} to @var{justification}.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_column_width (GtkCList *@var{clist}, gint @var{column}, gint @var{width})
+Set the pixel width of column @var{column} in the @code{GtkCList} @var{clist}
+to @var{width}. This function is a necessary step in creating a
+@code{GtkCList} because otherwise the column width is chosen from the width
+of the column title, which is almost never correct.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_row_height (GtkCList *@var{clist}, gint @var{height})
+Change the height of the rows in the @var{clist} to @var{height}. The default
+is the height of the current font.
+@end deftypefun
+
+@deftypefun void gtk_clist_moveto (GtkCList *@var{clist}, gint @var{row}, gint@var{column}, gfloat @var{row_align}, gfloat @var{col_align})
+Scroll the viewing area of the @code{GtkClist} in @var{clist} to @var{column}
+and @var{row}. The @var{row_align} and @var{col_align} are between zero and
+one, representing the location the row should appear on screen. Setting
+@var{row_align} or the @var{col_align} to 0.0 will be the top or left of the
+viewing area. Setting the @var{row_align} or @var{col_align} to 1.0 will
+be the bottom or right of the viewing area. If the @var{row} or @var{column}
+is -1 then there is no change.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_text (GtkCList *@var{clist}, gint @var{row}, gint @var{column}, gchar *@var{text})
+Set a given cell's text, located by the @var{row} and @var{column}, to
+@var{text} replacing its current contents.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_pixmap (GtkCList *@var{clist}, gint @var{row}, gint @var{column}, GdkPixmap *@var{pixmap}, GdkBitmap *@var{mask})
+Set a given cell's text, located by the @var{column} and @var{row} arguments,
+to the pixmap described by the @var{pixmap} argument using the @var{mask} as
+its mask. The current contents of the cell will be replaced.
+@end deftypefun
+
+@deftypefun void gtk_clist_setpixtext (GtkCList *@var{clist}, gint @var{row}, gint @var{column}, gchar *@var{text}, guint8 @var{spacing}, GdkPixmap *@var{pixmap}, GdkBitmap *@var{mask})
+Set a given cell's text and pixmap, located by the @var{row} and @var{column}
+arguments, to the text and pixmap described by the @var{pixmap} and @var{text}
+arguments. The @var{mask} will be used for the pixmap mask and the
+@var{spacing} argument specifies the spacing between the two.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_foreground (GtkCList *@var{clist}, gint @var{row}, GdkColor *@var{color})
+Set the foreground color of row @var{row} to @var{color} in the
+@code{GtkCList} @var{clist}. The @var{color} must
+already be allocated.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_background (GtkCList *@var{clist}, gint @var{row}, GdkColor *@var{color})
+Set the background color of row @var{row} to @var{color} in the
+@code{GtkCList} pointed to by @var{clist}. The color must be previously
+allocated.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_shift (GtkCList *@var{clist}, gint @var{row}, gint @var{column}, gint @var{vertical}, gint @var{horizontal})
+Set the horizontal and vertical shift for drawing the contents of the cell
+located at @var{row} and @var{column}. The @var{vertical} and @var{horizontal}
+arguments can be positive or negative.
+@end deftypefun
+
+@deftypefun gint gtk_clist_append (GtkCList *@var{clist}, gchar *@var{text[]})
+Append the given text, in the @var{text[]} argument, to the @code{GtkCList}
+pointed to by the @var{clist}. The return value is the index of the row that
+was just added.
+@end deftypefun
+
+@deftypefun void gtk_clist_insert (GtkCList *@var{clist}, gint @var{row}, gchar *@var{text[]})
+Insert a row into the @code{GtkCList} pointed to by @var{clist} at row
+@var{row} with the text in @var{text[]}.
+@end deftypefun
+
+@deftypefun void gtk_clist_remove (GtkCList *@var{clist}, gint @var{row})
+Remove row index @var{row} from the @var{clist}.
+@end deftypefun
+
+@deftypefun void gtk_clist_set_row_data (GtkCList *@var{clist}, gint @var{row}, gpointer @var{data})
+Will set an arbitrary data pointer, @var{data}, for row @var{row} in the
+@code{GtkCList} pointed to by @var{clist}.
+@end deftypefun
+
+@deftypefun gpointer gtk_clist_get_row_data (GtkCList *@var{clist}, gint @var{row})
+Return the data that was set for row @var{row} from the @code{GtkCList} pointed
+to by @var{clist}. @code{NULL} is returned if no data was set.
+@end deftypefun
+
+@deftypefun void gtk_clist_select_row (GtkCList *@var{clist}, gint @var{row}, gint @var{column})
+Force selection of a row, located by @var{row} and @var{column}, in the
+@code{GtkCList} pointed to by @var{clist}.
+@end deftypefun
+
+@deftypefun void gtk_clist_unselect_row (GtkCList *@var{clist}, gint @var{row}, gint @var{column})
+Force the unselection of a row, located by @var{row} and @var{column}, in the
+@code{GtkCList} pointed to by @var{clist}.
+@end deftypefun
+
+@deftypefun void gtk_clist_clear (GtkCList *@var{clist})
+Clear the entire contents of the @code{GtkCList} pointed to by @var{clist}.
+This is much faster then removing each item separately with
+@code{gtk_clist_remove}.
+@end deftypefun
+
+@gtkstdmacros{CList, CLIST}
+
+@page
+@node GtkColorSelection, GtkCombo, GtkCList, Widgets
+@comment node-name, next, previous, up
+@section The color selector widget
+
+@subsection Description
+
+A widget that allows a user to pick a color in one of many ways. They
+can click on a color wheel or saturation bar. They can change hue,
+saturation, value, red, green, or blue with a slider, or by entering
+values. Also allows the user to set an alpha (opacity) value. Derived
+from @pxref{GtkVBox}.
+
+@subsection Options
+@defopt policy
+@itemize @bullet
+@item
+GTK_UPDATE_CONTINUOUS
+@item
+GTK_UPDATE_DISCONTINUOUS
+@item
+GTK_UPDATE_DELAYED
+@end itemize
+@end defopt
+
+@defopt color
+@end defopt
+
+@defopt use_opacity
+@end defopt
+
+@defopt title
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_color_selection_get_type (void)
+Returns the @code{GtkColorSelection} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_color_selection_new (void)
+Create a new @code{GtkColorSelection} object. The new object is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_color_selection_set_update_policy (GtkColorSelection *@var{colorsel}, GtkUpdateType @var{policy})
+@end deftypefun
+
+@deftypefun void gtk_color_selection_set_color (GtkColorSelection *@var{colorsel}, gdouble *@var{color})
+@end deftypefun
+
+@deftypefun void gtk_color_selection_get_color (GtkColorSelection *@var{colorsel}, gdouble *@var{color})
+@end deftypefun
+
+@deftypefun void gtk_color_selection_set_opacity (GtkColorSelection *@var{colorsel}, gint @var{use_opacity})
+@end deftypefun
+
+@deftypefun guint gtk_color_selection_dialog_get_type (void)
+Returns the @code{GtkColorSelection} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_color_selection_dialog_new (gchar *@var{title})
+Create a new @code{GtkColorSelection} object initializing the title bar of
+the resulting dialog to @var{title}. The new widget is returned as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{ColorSelection, COLOR_SELECTION}
+
+@page
+@node GtkCombo, GtkContainer, GtkColorSelection, Widgets
+@comment node-name, next, previous, up
+@section The combo widget
+
+@subsection Description
+
+Text input box which also lets you choose from pre-defined values from a
+drop-down menu. Derived from @pxref{GtkHBox}.
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_combo_get_type (void)
+Returns the @code{GtkCombo} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_combo_new (void)
+Create a new @code{GtkCombo} object returning the new widget as a pointer to
+a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_combo_set_value_in_list (GtkCombo *@var{combo}, gint @var{val}, gint @var{ok_if_empty})
+@end deftypefun
+
+@deftypefun void gtk_combo_set_use_arrows (GtkCombo *@var{combo}, gint @var{val})
+@end deftypefun
+
+@deftypefun void gtk_combo_set_use_arrows_always (GtkCombo *@var{combo}, gint @var{val})
+@end deftypefun
+
+@deftypefun void gtk_combo_set_case_sensitive (GtkCombo *@var{combo}, gint @var{val})
+@end deftypefun
+
+@deftypefun void gtk_combo_set_item_string (GtkCombo *@var{combo}, GtkItem *@var{item}, gchar *@var{item_value})
+@end deftypefun
+
+@deftypefun void gtk_combo_set_popdown_strings (GtkCombo *@var{combo}, GList *@var{strings})
+@end deftypefun
+
+@gtkstdmacros{Combo, COMBO}
+
+@page
+@node GtkContainer, GtkGammaCurve, GtkCurve, GtkCombo, Widgets
+@comment node-name, next, previous, up
+@section The container widget
+
+@subsection Description
+
+A base class for objects that are built out of other widgets. Many
+widgets are containers. For example, a button contains a widget. That
+widget might be a text label (usually is), or a pixmap, or even an hbox
+which has a label and a pixmap.
+
+@subsection Options
+
+@defopt border_width
+@end defopt
+
+@subsection Signals
+
+@deftypefn Signal void GtkContainer::add (GtkContainer *@var{container}, GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkContainer::remove (GtkContainer *@var{container}, GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkContainer::need_resize (GtkContainer *@var{container}, GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkContainer::foreach (GtkContainer *@var{container}, GtkCallback @var{callback}, gpointer @var{callback_data})
+@end deftypefn
+
+@deftypefn Signal gint GtkContainer::focus (GtkContainer *@var{container}, GtkDirectionType @var{direction})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_container_get_type (void)
+Returns the @code{GtkContainer} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_container_border_width (GtkContainer *@var{container}, gint @var{border_width})
+@end deftypefun
+
+@deftypefun void gtk_container_add (GtkContainer *@var{container}, GtkWidget *@var{widget})
+Add @var{widget} to the @var{container}.
+@end deftypefun
+
+@deftypefun void gtk_container_remove (GtkContainer *@var{container}, GtkWidget *@var{widget})
+Remove @var{widget} from @var{container}.
+@end deftypefun
+
+@deftypefun void gtk_container_disable_resize (GtkContainer *@var{container})
+@end deftypefun
+
+@deftypefun void gtk_container_enable_resize (GtkContainer *@var{container})
+@end deftypefun
+
+@deftypefun void gtk_container_block_resize (GtkContainer *@var{container})
+@end deftypefun
+
+@deftypefun void gtk_container_unblock_resize (GtkContainer *@var{container})
+@end deftypefun
+
+@deftypefun gint gtk_container_need_resize (GtkContainer *@var{container}, GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_container_check_resize (GtkContainer *@var{container}, GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_container_foreach (GtkContainer *@var{container}, GtkCallback @var{callback}, gpointer @var{callback_data})
+@end deftypefun
+
+@deftypefun void gtk_container_focus (GtkContainer *@var{container}, GtkDirectionType @var{direction})
+@end deftypefun
+
+@deftypefun GList* gtk_container_children (GtkContainer @var{container})
+@end deftypefun
+
+@gtkstdmacros{Container, CONTAINER}
+
+@page
+@node GtkCurve, GtkGammaCurve, GtkDialog, GtkContainer, Widgets
+@comment node-name, next, previous, up
+@section The curve widget
+
+@subsection Description
+
+Derived from @pxref{GtkDrawingArea}.
+
+@subsection Options
+
+@defopt type
+@itemize @bullet
+@item GTK_CURVE_TYPE_LINEAR
+@item GTK_CURVE_TYPE_SPLINE
+@item GTK_CURVE_TYPE_FREE
+@end itemize
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_curve_get_type (void)
+Returns the @code{GtkCurve} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_curve_new (void)
+Create a new @code{GtkCurve} returning the new widget as a pointer to a
+@code{GtkWidget} object.
+@end deftypefun
+
+@deftypefun void gtk_curve_reset (GtkCurve *@var{curve})
+@end deftypefun
+
+@deftypefun void gtk_curve_set_gamma (GtkCurve *@var{curve}, gfloat @var{gamma})
+@end deftypefun
+
+@deftypefun void gtk_curve_set_range (GtkCurve *@var{curve}, gfloat @var{min_x}, gfloat @var{max_x}, gfloat @var{min_y}, gfloat @var{max_y})
+@end deftypefun
+
+@deftypefun void gtk_curve_get_vector (GtkCurve *@var{curve}, int @var{veclen}, gfloat @var{vector[]})
+@end deftypefun
+
+@deftypefun void gtk_curve_set_vector (GtkCurve *@var{curve}, int @var{veclen}, gfloat @var{vector[]})
+@end deftypefun
+
+@deftypefun void gtk_curve_set_curve_type (GtkCurve *@var{curve}, GtkCurveType @var{type})
+@end deftypefun
+
+@gtkstdmacros{Curve, CURVE}
+
+@page
+@node GtkGammaCurve, GtkCurve, GtkDialog, GtkContainer, Widgets
+@comment node-name, next, previous, up
+@section The gamma curve widget
+
+@subsection Description
+
+Lets the user edit a gamma curve (a one-to-one mapping usually used to
+adjust the intensity of an image to the physical characteristics of the
+output device). You can set the minimum and maximum values for input
+and output. You can set the initial vector as well. You are guaranteed
+that every input value will have a (not necessarily unique) output value
+specified. Derived from @pxref{GtkVBox}. Makes use of @pxref{GtkCurve} to
+draw the curve.
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_gamma_curve_get_type (void)
+Returns the @code{GtkGamma} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_gamma_curve_new (void)
+Create a new @code{GtkGamma} returning the new widget as a pointer to a
+@code{GtkWidget} object.
+@end deftypefun
+
+@gtkstdmacros{GammaCurve, GAMMACURVE}
+
+@page
+@node GtkDialog, GtkDrawingArea, GtkGammaCurve, GtkCurve, Widgets
+@comment node-name, next, previous, up
+@section The dialog widget
+
+
+@subsection Description
+The dialog widget is a window (@pxref{GtkWindow}) that has a vertical box
+(@pxref{GtkVBox}), a horizontal box (@pxref{GtkHBox}), separated with a
+horizontal separator (@pxref{GtkHSeparator}).
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_dialog_get_type (void)
+Returns the @code{GtkDialog} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_dialog_new (void)
+Create a new @code{GtkDialog} object and return the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{Dialog, DIALOG}
+
+
+@page
+@node GtkDrawingArea, GtkEntry, GtkDialog, Widgets
+@comment node-name, next, previous, up
+@section The drawing area widget
+
+@subsection Description
+
+A base class for widgets that need a box to draw into. So far, only
+used by GtkCurve.
+
+@subsection Options
+
+@defopt width
+@end defopt
+
+@defopt height
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_drawing_area_get_type (void)
+Returns the @code{GtkDrawingArea} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_drawing_area_new (void)
+Create a new @code{GtkDrawingArea} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_drawing_area_size (GtkDrawingArea *@var{darea}, gint @var{width}, gint @var{height})
+Set the size of the @var{darea} widget, created previously, to @var{width} and @var{height}.
+@end deftypefun
+
+@gtkstdmacros{DrawingArea, DRAWING_AREA}
+
+
+@page
+@node GtkEntry, GtkEventBox, GtkDrawingArea, Widgets
+@comment node-name, next, previous, up
+@section The entry widget
+
+
+@subsection Description
+
+Enter text into this widget. Derived from @pxref{GtkEditable}. Can be
+set so it isn't editable.
+
+@subsection Options
+
+@defopt max
+With this option it is possible to set the @var{text_max_length} to the
+value specified in the @var{max} option. This value is a guint16 value.
+@end defopt
+
+@defopt text
+With this option it is possible to 'preload' the text that will be displayed
+in the @code{entry} widget to the string pointed to by @var{text}.
+@end defopt
+
+@subsection Signals
+
+@deftypefn Signal void GtkEntry::insert_text (GtkEntry *@var{entry}, gchar *@var{text}, gint @var{length}, gint *@var{position})
+@end deftypefn
+
+@deftypefn Signal void GtkEntry::delete_text (GtkEntry *@var{entry}, gint @var{start_pos}, gint @var{end_pos})
+@end deftypefn
+
+@deftypefn Signal void GtkEntry::changed (GtkEntry *@var{entry})
+@end deftypefn
+
+@deftypefn Signal void GtkEntry::set_text (GtkEntry *@var{entry})
+@end deftypefn
+
+@deftypefn Signal void GtkEntry::activate (GtkEntry *@var{entry})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_entry_get_type (void)
+Returns the @code{GtkEntry} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_entry_new (void)
+Create a new @code{GtkEntry} object. The new widget is returned
+as a pointer to a @code{GtkWidget} object. @code{NULL} is returned on
+failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_entry_new_with_max_length (guint16 @var{max})
+Create a new @code{GtkEntry} object initializing it with the value @var{max}.
+The new widget is returned as a pointer to a @code{GtkWidget} object.
+@code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_entry_set_text (GtkEntry *@var{entry}, gchar *@var{text})
+Will set the text in the previously created @code{GtkEntry} object to
+@var{text}. It is important to not set the fields of the @code{GtkEntry}
+structure directly (or, for that matter, any type derived from
+@code{GtkObject}).
+@end deftypefun
+
+@deftypefun void gtk_entry_append_text (GtkEntry *@var{entry}, gchar *@var{text})
+Append the text that is in the @var{text} argument to the widgets text. It is
+important to not set the fields of the @code{GtkEntry} structure directly.
+@end deftypefun
+
+@deftypefun void gtk_entry_prepend_text (GtkEntry *@var{entry}, gchar *@var{text})
+Add the text in the @var{text} argument to the text in the @code{GtkEntry}
+widget. It is important to not set the fields of the @code{GtkEntry} structure
+directly.
+@end deftypefun
+
+@deftypefun void gtk_entry_set_position (GtkEntry *@var{entry}, gint @var{position})
+@end deftypefun
+
+@deftypefun void gtk_entry_set_visibility (GtkEntry *@var{entry}, gint @var{visible})
+Will make the keystrokes entered into the @code{GtkEntry} object invisible
+when @var{visible} is @code{TRUE}. Defaults to @code{FALSE}.
+@end deftypefun
+
+@deftypefun gchar* gtk_entry_get_text (GtkEntry *@var{entry})
+Returns the text that is contained in the @code{GtkEntry} as a pointer to a
+@code{gchar} variable.
+@end deftypefun
+
+@gtkstdmacros{Entry, ENTRY}
+
+@page
+@node GtkEventBox, GtkFileSelection, GtkEntry, Widgets
+@comment node-name, next, previous, up
+@section The event box widget
+
+@subsection Description
+
+Derived from @pxref{GtkBin}. Used by @pxref{GtkTreeItem}.
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+@deftypefun guint gtk_event_box_get_type (void)
+Returns the @code{GtkEventBox} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_event_box_new (void)
+Create a new @code{GtkEventBox} returning the new widget as a pointer to
+a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{GtkEventBox, EVENT_BOX}
+
+@page
+@node GtkFileSelection, GtkFixed, GtkEventBox, Widgets
+@comment node-name, next, previous, up
+@section The file selection dialog widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt title
+@end defopt
+
+@defopt filename
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_file_selection_get_type (void)
+Returns the @code{GtkFileSelection} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_file_selection_new (gchar *@var{title})
+Create a new @code{GtkFileSelection} object and return the new widget as a
+pointer to a @code{GtkWidget}. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_file_selection_set_filename (GtkFileSelection *@var{filesel}, gchar *@var{filename})
+@end deftypefun
+
+@deftypefun gchar* gtk_file_selection_get_filename (GtkFileSelection *@var{filesel})
+@end deftypefun
+
+@gtkstdmacros{FileSelection, FILE_SELECTION}
+
+@page
+@node GtkFixed, GtkFrame, GtkFileSelection, Widgets
+@comment node-name, next, previous, up
+@section The fixed widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_fixed_get_type (void)
+Returns the @code{GtkFixed} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_fixed_new (void)
+Create a new @code{GtkFixed} object returning the new widget as a pointer to
+a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_fixed_put_new (GtkFixed *@var{fixed}, GtkWidget *@var{widget}, gint16 @var{x}, gint16 @var{y})
+@end deftypefun
+
+@deftypefun void gtk_fixed_move (GtkFixed *@var{fixed}, GtkWidget *@var{widget}, gint16 @var{x}, gint16 @var{y})
+@end deftypefun
+
+@gtkstdmacros{Fixed, FIXED}
+
+@page
+@node GtkFrame, GtkGamma, GtkFixed, Widgets
+@comment node-name, next, previous, up
+@section The frame widget
+
+
+@subsection Options
+@defopt label
+@end defopt
+
+@defopt xalign
+@end defopt
+
+@defopt yalign
+@end defopt
+
+@defopt type
+@end defopt
+
+@subsection Description
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_frame_get_type (void)
+Returns the @code{GtkFrame} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_frame_new (gchar *@var{label})
+Create a new @code{GtkFrame} object initializing it with the value in
+@var{label}. The new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_frame_set_label (GtkFrame *@var{frame}, gchar *@var{label})
+@end deftypefun
+
+@deftypefun void gtk_frame_set_label_align (GtkFrame *@var{frame}, gfloat @var{xalign}, gfloat @var{yalign})
+@end deftypefun
+
+@deftypefun void gtk_frame_set_shadow_type (GtkFrame *@var{frame}, GtkShadowType @var{type})
+@end deftypefun
+
+@gtkstdmacros{Frame, FRAME}
+
+@page
+@node GtkGamma, GtkHBox, GtkFrame, Widgets
+@comment node-name, next, previous, up
+@section The gamma widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_gamma_curve_get_type (void)
+Returns the @code{GtkGamma} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_gamma_curve_new (void)
+Create a new @code{GtkGamma} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{Gamma, GAMMA}
+
+@page
+@node GtkHBox, GtkHButtonBox, GtkGamma, Widgets
+@comment node-name, next, previous, up
+@section The horizontal box widget
+
+
+@subsection Description
+
+@subsection Options
+
+@defopt homogeneous
+This option controls whether each object in the box has the same size. In the
+case of the @code{GtkHBox}, this effects the width. If this option is set then
+the @var{expand} option to the @code{gtk_box_pack} (@pxref{GtkBox}) routines
+is always set to @code{TRUE}.
+@end defopt
+
+@defopt spacing
+This option controls the amount of space that is added between the objects
+packed into this @code{GtkVBox} object.
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_hbox_get_type (void)
+Returns the @code{GtkHBox} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_hbox_new (gint @var{homogeneous}, gint @var{spacing})
+Create a new @code{GtkHBox} object initializing it with the values in
+@var{homogeneous} and @var{spacing}. The new widget is returned as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{HBox, HBOX}
+
+@page
+@node GtkHButtonBox, GtkHPaned, GtkHBox, Widgets
+@comment node-name, next, previous, up
+@section The horizontal button box widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt spacing
+@end defopt
+
+@defopt layout
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_hbutton_box_get_type (void)
+Returns the @code{GtkHButtonBox} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_hbutton_box_new (void)
+Create a new @code{GtkHButtonBox} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_hbutton_box_set_spacing_default (gint @var{spacing})
+@end deftypefun
+
+@deftypefun void gtk_hbutton_box_set_layout_default (gint @var{layout})
+@end deftypefun
+
+@deftypefun gint gtk_hbutton_box_get_spacing_default (void)
+@end deftypefun
+
+@deftypefun gint gtk_hbutton_box_get_layout_default (void)
+@end deftypefun
+
+@gtkstdmacros {HButtonBox, HBUTTON_BOX}
+
+@page
+@node GtkHPaned, GtkHRuler, GtkHButtonBox, Widgets
+@comment node-name, next, previous, up
+@section The horizontal paned widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun void gtk_hpaned_get_type (void)
+Returns the @code{GtkHPaned} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_hpaned_new (void)
+Create a new @code{GtkHPaned} object returning the new widget as a pointer
+to a @code{GtkWidget} object.
+@end deftypefun
+
+@gtkstdmacros{HPaned, HPANED}
+
+@page
+@node GtkHRuler, GtkHScale, GtkHPaned, Widgets
+@comment node-name, next, previous, up
+@section The horizontal ruler widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_hruler_get_type (void)
+Returns the @code{GtkHRuler} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_hruler_new (void)
+Create a new @code{GtkHRuler} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{HRuler, HRULER}
+
+
+@page
+@node GtkHScale, GtkHScrollbar, GtkHRuler, Widgets
+@comment node-name, next, previous, up
+@section The horizontal scale widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_hscale_get_type (void)
+Returns the @code{GtkHScale} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_hscale_new (GtkAdjustment *@var{adjustment})
+Create a new @code{GtkHScale} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{HScale, HSCALE}
+
+
+@page
+@node GtkHScrollbar, GtkHSeparator, GtkHScale, Widgets
+@comment node-name, next, previous, up
+@section The horizontal scrollbar widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_hscrollbar_get_type (void)
+Returns the @code{GtkHScrollbar} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_hscrollbar_new (GtkAdjustment *@var{adjustment})
+Create a new @code{GtkHScrollbar} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{HScrollbar, HSCROLLBAR}
+
+
+@page
+@node GtkHSeparator, GtkImage, GtkHScrollbar, Widgets
+@comment node-name, next, previous, up
+@section The horizontal separator widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_hseparator_get_type (void)
+Returns the @code{GtkHSeparator} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_hseparator_new (void)
+Create a new @code{GtkHSeparator} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{HSeparator, HSEPARATOR}
+
+
+@page
+@node GtkImage, GtkInputDialog, GtkHSeparator, Widgets
+@comment node-name, next, previous, up
+@section The image widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_image_get_type (void)
+Returns the @code{GtkImage} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_image_new (GdkImage *@var{val}, GdkBitmap *@var{mask})
+Create a new @code{GtkImage} object initializing it with the values in
+@var{val} and @var{mask}. The new widget is returned as a pointer to a
+@code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_image_set (GtkImage *@var{image}, GdkImage *@var{val}, GdkBitmap *@var{mask})
+@end deftypefun
+
+@deftypefun void gtk_image_get (GtkImage *@var{image}, GdkImage **@var{val}, GdkBitmap **@var{mask})
+@end deftypefun
+
+@gtkstdmacros{Image, IMAGE}
+
+@page
+@node GtkInputDialog, GtkItem, GtkImage, Widgets
+@comment node-name, next, previous, up
+@section The input dialog widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@deftypefn Signal void GtkInputDialog::enable_device (GtkInputDialog *@var{inputd}, guint32 @var{devid}, gpointer *@var{data})
+@end deftypefn
+
+@deftypefn Signal void GtkInputDialog::disable_device (GtkInputDialog *@var{inputd}, guint32 @var{devid}, gpointer *@var{data})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_input_dialog_get_type (void)
+Returns the @code{GtkInputDialog} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_input_dialog_new (void)
+Create a new @code{GtkInputDialog} object and return the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+
+@gtkstdmacros{InputDialog, INPUTDIALOG}
+
+@page
+@node GtkItem, GtkLabel, GtkInputDialog, Widgets
+@comment node-name, next, previous, up
+@section The item widget
+
+
+@subsection Description
+
+@subsection Signals
+
+@deftypefn Signal void GtkItem::select (GtkItem *@var{item})
+@end deftypefn
+
+@deftypefn Signal void GtkItem::deselect (GtkItem *@var{item})
+@end deftypefn
+
+@deftypefn Signal void GtkItem::toggle (GtkItem *@var{toggle})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_item_get_type (void)
+Returns the @code{GtkItem} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_item_select (GtkItem *@var{item})
+@end deftypefun
+
+@deftypefun void gtk_item_deselect (GtkItem *@var{item})
+@end deftypefun
+
+@deftypefun void gtk_item_toggle (GtkItem *@var{item})
+@end deftypefun
+
+@gtkstdmacros{Item, ITEM}
+
+
+@page
+@node GtkLabel, GtkList, GtkItem, Widgets
+@comment node-name, next, previous, up
+@section The label widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt str
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_label_get_type (void)
+Returns the @code{GtkLabel} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_label_new (GtkLabel *@var{label}, gchar *@var{str})
+Create a new @code{GtkLabel} object and initialize it with the
+text in @var{str}. The new widget is returned as a pointer to a
+@code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_label_set (GtkLabel *@var{label}, gchar *@var{str})
+Set the @code{GtkLabel} label value to the value passed in the @var{str}
+argument.
+@end deftypefun
+
+@deftypefun void gtk_label_get (GtkLabel *@var{label}, gchar **@var{str})
+Copies the current value in the @code{GtkLabel} label field to the variable
+passed in the @var{str} argument.
+@end deftypefun
+
+@gtkstdmacros{Label, LABEL}
+
+
+@page
+@node GtkList, GtkListItem, GtkLabel, Widgets
+@comment node-name, next, previous, up
+@section The list widget
+
+
+@subsection Description
+
+@subsection Signals
+
+@deftypefn Signal void GtkList::selection_changed (GtkList *@var{list})
+@end deftypefn
+
+@deftypefn Signal void GtkList::select_child (GtkList *@var{list}, GtkWidget *@var{child})
+@end deftypefn
+
+@deftypefn Signal void GtkList::unselect_child (GtkList *@var{list}, GtkWidget *@var{child})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_list_get_type (void)
+Returns the @code{GtkList} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_list_new (void)
+Create a new @code{GtkList} object and return the new widget as a pointer to
+a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_list_insert_items (GtkList *@var{list}, GList *@var{items}, gint @var{position})
+@end deftypefun
+
+@deftypefun void gtk_list_append_items (GtkList *@var{list}, GList *@var{items})
+@end deftypefun
+
+@deftypefun void gtk_list_prepend_items (GtkList *@var{list}, GList *@var{items})
+@end deftypefun
+
+@deftypefun void gtk_list_remove_items (GtkList *@var{list}, GList *@var{items})
+@end deftypefun
+
+@deftypefun void gtk_list_clear_items (GtkList *@var{list}, gint @var{start}, gint @var{end})
+@end deftypefun
+
+@deftypefun void gtk_list_select_item (GtkList *@var{list}, gint @var{item})
+@end deftypefun
+
+@deftypefun void gtk_list_unselect_item (GtkList *@var{list}, gint @var{item})
+@end deftypefun
+
+@deftypefun void gtk_list_select_child (GtkList *@var{list}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_list_unselect_child (GtkList *@var{list}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun gint gtk_list_child_position (GtkList *@var{list}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_list_set_selection_mode (GtkList *@var{list}, GtkSelectionMode @var{mode})
+@end deftypefun
+
+@gtkstdmacros{List, LIST}
+
+
+@page
+@node GtkListItem, GtkMenu, GtkList, Widgets
+@comment node-name, next, previous, up
+@section The list item widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_list_item_get_type (void)
+Returns the @code{GtkListItem} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_list_item_new (void)
+Create a new @code{GtkListItem} object and return the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_list_item_new_with_label (gchar *@var{label})
+Create a new @code{GtkListItem} object initializing with the value @var{label}.
+The new widget is returned as a pointer to a @code{GtkWidget} object.
+@code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_list_item_select (GtkListItem *@var{list_item})
+@end deftypefun
+
+@deftypefun void gtk_list_item_deselect (GtkListItem *@var{list_item})
+@end deftypefun
+
+@gtkstdmacros{ListItem, LIST_ITEM}
+
+
+@page
+@node GtkMenu, GtkMenuBar, GtkListItem, Widgets
+@comment node-name, next, previous, up
+@section The menu widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_menu_get_type (void)
+Returns the @code{GtkMenu} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_menu_new (void)
+Create a new @code{GtkMenu} object returning the new widget as a pointer to
+a @code{GtkWidget}. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_menu_append (GtkMenu *@var{menu}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_menu_prepend (GtkMenu *@var{menu}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_menu_insert (GtkMenu *@var{menu}, GtkWidget *@var{child}, gint @var{position})
+@end deftypefun
+
+@deftypefun void gtk_menu_popup (GtkMenu *@var{menu}, GtkWidget *@var{parent_menu_shell}, GtkWidget *@var{parent_menu_item}, GtkMenuPositionFunc @var{func}, gpointer @var{data}, gint @var{button})
+@end deftypefun
+
+@deftypefun void gtk_menu_popdown (GtkMenu *@var{menu})
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_menu_get_active (GtkMenu *@var{menu})
+@end deftypefun
+
+@deftypefun void gtk_menu_set_active (GtkMenu *@var{menu})
+@end deftypefun
+
+@deftypefun void gtk_menu_set_accelerator_table (GtkMenu *@var{menu}, GtkAcceleratorTable *@var{table})
+@end deftypefun
+
+@gtkstdmacros{Menu, MENU}
+
+
+@page
+@node GtkMenuBar, GtkMenuItem, GtkMenu, Widgets
+@comment node-name, next, previous, up
+@section The menu bar widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt position
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_menu_bar_get_type (void)
+Returns the @code{GtkMenuBar} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_menu_bar_new (void)
+Create a new @code{GtkMenuBar} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_menu_bar_append (GtkMenuBar *@var{menu_bar}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_menu_bar_prepend (GtkMenuBar *@var{menu_bar}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_menu_bar_insert (GtkMenuBar *@var{menu_bar}, GtkWidget *@var{child}, gint @var{position})
+@end deftypefun
+
+@gtkstdmacros{MenuBar, MENU_BAR}
+
+
+@page
+@node GtkMenuItem, GtkMenuShell, GtkMenuBar, Widgets
+@comment node-name, next, previous, up
+@section The menu item widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@deftypefn Signal void GtkMenuItem::activate (GtkMenuItem *@var{menu_item})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_menu_item_get_type (void)
+Returns the @code{GtkMenuItem} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_menu_item_new (void)
+Create a new @code{GtkMenuItem} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_menu_item_new_with_label (gchar *@var{label})
+Create a new @code{GtkMenuItem} object initializing it with the value in
+@var{label}. The new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_menu_item_set_submenu (GtkMenuItem *@var{menu_item}, GtkWidget *@var{submenu})
+@end deftypefun
+
+@deftypefun void gtk_menu_item_set_placement (GtkMenuItem *@var{menu_item}, GtkSubmenuPlacement @var{placement})
+@end deftypefun
+
+@deftypefun void gtk_menu_item_accelerator_size (GtkMenuItem *@var{menu_item})
+@end deftypefun
+
+@deftypefun void gtk_menu_item_accelerator_text (GtkMenuItem *@var{menu_item}, gchar *@var{buffer})
+@end deftypefun
+
+@deftypefun void gtk_menu_item_configure (GtkMenuItem *@var{menu_item}, gint @var{show_toggle_indicator}, gint @var{show_submenu_indicator})
+@end deftypefun
+
+@deftypefun void gtk_menu_item_select (GtkMenuItem *@var{menu_item})
+@end deftypefun
+
+@deftypefun void gtk_menu_item_deselect (GtkMenuItem *@var{menu_item})
+@end deftypefun
+
+@deftypefun void gtk_menu_item_activate (GtkMenuItem *@var{menu_item})
+@end deftypefun
+
+@gtkstdmacros{MenuItem, MENU_ITEM}
+
+
+@page
+@node GtkMenuShell, GtkMisc, GtkMenuItem, Widgets
+@comment node-name, next, previous, up
+@section The menu shell widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@deftypefn Signal void GtkMenuShell::deactivate (GtkMenuShell *@var{menu_shell})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_menu_shell_get_type (void)
+Returns the @code{GtkMenuShell} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_menu_shell_append (GtkMenuShell *@var{menu_shell}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_menu_shell_prepend (GtkMenuShell *@var{menu_shell}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_menu_shell_insert (GtkMenuShell *@var{menu_shell}, GtkWidget *@var{child}, gint @var{position})
+@end deftypefun
+
+@deftypefun void gtk_menu_shell_deactivate (GtkMenuShell *@var{menu_shell})
+@end deftypefun
+
+@gtkstdmacros{MenuShell, MENU_SHELL}
+
+
+@page
+@node GtkMisc, GtkNotebook, GtkMenuShell, Widgets
+@comment node-name, next, previous, up
+@section The misc widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt xalign
+@end defopt
+
+@defopt yalign
+@end defopt
+
+@defopt xpad
+@end defopt
+
+@defopt ypad
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_misc_get_type (void)
+Returns the @code{GtkMisc} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_misc_set_alignment (GtkMisc *@var{misc}, gfloat @var{xalign}, gfloat @var{yalign})
+@end deftypefun
+
+@deftypefun void gtk_misc_set_padding (GtkMisc *@var{misc}, gint @var{xpad}, gint @var{ypad})
+@end deftypefun
+
+@gtkstdmacros{Misc, MISC}
+
+
+@page
+@node GtkNotebook, GtkOptionMenu, GtkMisc, Widgets
+@comment node-name, next, previous, up
+@section The notebook widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_notebook_get_type (void)
+Returns the @code{GtkNotebook} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_notebook_new (void)
+Create a new @code{GtkNotebook} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on a failure.
+@end deftypefun
+
+@deftypefun void gtk_notebook_append_page (GtkNotebook *@var{notebook}, GtkWidget *@var{child}, GtkWidget *@var{tab_label})
+@end deftypefun
+
+@deftypefun void gtk_notebook_prepend_page (GtkNotebook *@var{notebook}, GtkWidget *@var{child}, GtkWidget *@var{tab_label})
+@end deftypefun
+
+@deftypefun void gtk_notebook_insert_page (GtkNotebook *@var{notebook}, GtkWidget *@var{child}, GtkWidget *@var{tab_label}, gint @var{position})
+@end deftypefun
+
+@deftypefun void gtk_notebook_remove_page (GtkNotebook *@var{notebook}, gint @var{page_num})
+@end deftypefun
+
+@deftypefun void gtk_notebook_set_page (GtkNotebook *@var{notebook}, gint @var{page_num})
+@end deftypefun
+
+@deftypefun void gtk_notebook_next_page (GtkNotebook *@var{notebook})
+@end deftypefun
+
+@deftypefun void gtk_notebook_prev_page (GtkNotebook *@var{notebook})
+@end deftypefun
+
+@deftypefun void gtk_notebook_set_tab_pos (GtkNotebook *@var{notebook}, GtkPositionType @var{pos})
+@end deftypefun
+
+@deftypefun void gtk_notebook_set_show_tabs (GtkNotebook *@var{notebook}, gint @var{show_tabs})
+@end deftypefun
+
+@deftypefun void gtk_notebook_set_show_border (GtkNotebook *@var{notebook}, gint @var{show_border})
+@end deftypefun
+
+@gtkstdmacros{Notebook, NOTEBOOK}
+
+
+@page
+@node GtkOptionMenu, GtkPaned, GtkNotebook, Widgets
+@comment node-name, next, previous, up
+@section The option menu widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt index
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_option_menu_get_type (void)
+Returns the @code{GtkOptionMenu} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_option_menu_new (void)
+Create a new @code{GtkOptionMenu} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_option_menu_get_menu (GtkOptionMenu *@var{option_menu})
+@end deftypefun
+
+@deftypefun void gtk_option_menu_set_menu (GtkOptionMenu *@var{option_menu}, GtkWidget *@var{menu})
+@end deftypefun
+
+@deftypefun void gtk_option_menu_remove_menu (GtkOptionMenu *@var{option_menu})
+@end deftypefun
+
+@deftypefun void gtk_option_menu_set_history (GtkOptionMenu *@var{option_menu}, gint @var{index})
+@end deftypefun
+
+@gtkstdmacros{OptionMenu, OPTION_MENU}
+
+@page
+@node GtkPaned, GtkPixmap, GtkOptionMenu, Widgets
+@comment node-name, next, previous, up
+@section The paned widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_paned_get_type (void)
+Returns the @code{GtkPaned} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_paned_add1 (GtkPaned *@var{paned}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_paned_add2 (GtkPaned *@var{paned}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_paned_handle_size (GtkPaned *@var{paned}, guint16 @var{size})
+@end deftypefun
+
+
+@deftypefun void gtk_paned_gutter_size (GtkPaned *@var{paned}, guint16 @var{size})
+@end deftypefun
+
+@gtkstdmacros{Paned, PANED}
+
+@page
+@node GtkPixmap, GtkPreview, GtkPaned, Widgets
+@comment node-name, next, previous, up
+@section The pixmap widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_pixmap_get_type (void)
+Returns the @code{GtkPixmap} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_pixmap_new (GdkPixmap *@var{normal}, GdkPixmap *@var{active}, GdkPixmap *@var{prelight}, GdkPixmap *@var{selected}, GdkPixmap *@var{insensitive})
+@end deftypefun
+
+@deftypefun void gtk_pixmap_set (GtkPixmap *@var{pixmap}, GdkPixmap *@var{val}, GtkStateType @var{state})
+@end deftypefun
+
+@deftypefun void gtk_pixmap_get (GtkPixmap *@var{pixmap}, GdkPixmap **@var{val}, GtkStateType @var{state})
+@end deftypefun
+
+@gtkstdmacros{Pixmap, PIXMAP}
+
+
+@page
+@node GtkPreview, GtkProgressBar, GtkPixmap, Widgets
+@comment node-name, next, previous, up
+@section The preview widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt type
+@end defopt
+
+@defopt width
+@end defopt
+
+@defopt height
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_preview_get_type (void)
+Returns the @code{GtkPreview} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_preview_uninit (void)
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_preview_new (GtkPreviewType @var{type})
+Create a new @code{GtkPreview} object initializing it with the values in
+@var{type}. The new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_preview_size (GtkPreview *@var{preview}, gint @var{width}, gint @var{height})
+Set the size of the @var{preview} object to @var{width} and @var{height}.
+@end deftypefun
+
+@deftypefun void gtk_preview_put (GtkPreview *@var{preview}, GdkWindow *@var{window}, GdkGC *@var{gc}, gint @var{srcx}, gint @var{srcy}, gint @var{destx}, gint @var{desty}, gint @var{width}, gint @var{height})
+@end deftypefun
+
+@deftypefun void gtk_preview_put_row (GtkPreview *@var{preview}, guchar *@var{src}, guchar *@var{dest}, gint @var{x}, gint @var{y}, gint @var{w})
+@end deftypefun
+
+@deftypefun void gtk_preview_draw_row (GtkPreview *@var{preview}, guchar @var{data}, gint @var{x}, gint @var{y}, gint @var{w})
+@end deftypefun
+
+@deftypefun void gtk_preview_set_expand (GtkPreview *@var{preview}, gint @var{expand})
+@end deftypefun
+
+@deftypefun void gtk_preview_set_gamma (double @var{gamma})
+@end deftypefun
+
+@deftypefun void gtk_preview_set_color_cube (guint @var{nred_shades}, guint @var{ngreen_shades}, guint @var{nblue_shades}, guint @var{ngray_shades})
+@end deftypefun
+
+@deftypefun void gtk_preview_set_install_cmap (gint @var{install_cmap})
+@end deftypefun
+
+@deftypefun void gtk_preview_set_reserved (gint @var{nreserved})
+@end deftypefun
+
+@deftypefun GdkVisual* gtk_preview_get_visual (void)
+@end deftypefun
+
+@deftypefun GdkColormap* gtk_preview_get_cmap (void)
+@end deftypefun
+
+@deftypefun GtkPreviewInfo* gtk_preview_get_info (void)
+@end deftypefun
+
+@gtkstdmacros{Preview, PREVIEW}
+
+
+@page
+@node GtkProgressBar, GtkRadioButton, GtkPreview, Widgets
+@comment node-name, next, previous, up
+@section The progress bar widget
+
+
+@subsection Description
+
+@subsection Options
+
+@defopt percentage
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_progress_bar_get_type (void)
+Returns the @code{GtkProgressBar} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_progress_bar_new (void)
+Create a new @code{GtkProgressBar} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_progress_bar_update (GtkProgressBar *@var{pbar}, gfloat @var{percentage})
+Cause the @code{GtkProgressBar} to update its visual appearance to reflect the
+@var{percentage}.
+@end deftypefun
+
+@gtkstdmacros{ProgressBar, PROGRESS_BAR}
+
+
+@page
+@node GtkRadioButton, GtkRadioMenuItem, GtkProgressBar, Widgets
+@comment node-name, next, previous, up
+@section The radio button widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt group
+@end defopt
+
+@defopt label
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_radio_button_get_type (void)
+Returns the @code{GtkRadioButton} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_radio_button_new (GSList *@var{group})
+Create a new @code{GtkRadioButton} object initializing it with the value
+in the @var{group} argument. The new widget is returned as a pointer to a
+@code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_radio_button_new_with_label (GSList *@var{group}, gchar *@var{label})
+Create a new @code{GtkRadioButton} object initializing it with the values in
+the @var{group} and @var{label} arguments. The new widget is returned as a
+pointer to @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GSList* gtk_radio_button_group (GtkRadioButton *@var{radio_button})
+@end deftypefun
+
+@gtkstdmacros{RadioButton, RADIO_BUTTON}
+
+
+@page
+@node GtkRadioMenuItem, GtkRange, GtkRadioButton, Widgets
+@comment node-name, next, previous, up
+@section The radio button widget
+
+
+@subsection Description
+
+@subsection Options
+
+@defopt group
+@end defopt
+
+@defopt label
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_radio_menu_item_get_type (void)
+Returns the @code{GtkRadioMenuItem} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_radio_menu_item_new (GSList *@var{group})
+Create a new @code{GtkRadioMenuItem} object and initialize it with the
+values in @var{group}. The new widget is returned as a pointer to a
+@code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_radio_menu_item_new_with_label (GSList *@var{group}, gchar *@var{label})
+@end deftypefun
+
+@deftypefun GSList* gtk_radio_menu_item_group (GtkRadioMenuItem *@var{radio_menu_item})
+@end deftypefun
+
+@gtkstdmacros{RadioMenuItem, RADIO_MENU_ITEM}
+
+
+@page
+@node GtkRange, GtkRuler, GtkRadioMenuItem, Widgets
+@comment node-name, next, previous, up
+@section The range widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_range_get_type (void)
+Returns the @code{GtkRange} type identifier.
+@end deftypefun
+
+@deftypefun GtkAdjustment* gtk_range_get_adjustment (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun void gtk_range_set_update_policy (GtkRange *@var{range}, GtkUpdatePolicy @var{policy})
+@end deftypefun
+
+@deftypefun void gtk_range_set_adjustment (GtkRange *@var{range}, GtkAdjustment *@var{adjustment})
+@end deftypefun
+
+@deftypefun void gtk_range_draw_background (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun void gtk_range_draw_trough (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun void gtk_range_draw_slider (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun void gtk_range_draw_step_forw (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun void gtk_range_draw_step_back (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun void gtk_range_slider_update (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun gint gtk_range_trough_click (GtkRange *@var{range}, gint @var{x}, gint @var{y})
+@end deftypefun
+
+@deftypefun void gtk_range_default_hslider_update (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun void gtk_range_default_vslider_update (GtkRange *@var{range})
+@end deftypefun
+
+@deftypefun gint gtk_range_default_htrough_click (GtkRange *@var{range}, gint @var{x}, gint @var{y})
+@end deftypefun
+
+@deftypefun gint gtk_range_default_vtrough_click (GtkRange *@var{range}, gint @var{x}, gint @var{y})
+@end deftypefun
+
+@deftypefun void gtk_range_default_hmotion (GtkRange *@var{range}, gint @var{xdelta}, gint @var{ydelta})
+@end deftypefun
+
+@deftypefun void gtk_range_default_vmotion (GtkRange *@var{range}, gint @var{xdelta}, gint @var{ydelta})
+@end deftypefun
+
+@deftypefun gfloat gtk_range_calc_value (GtkRange *@var{range}, gint @var{position})
+@end deftypefun
+
+@gtkstdmacros{Range, RANGE}
+
+
+@page
+@node GtkRuler, GtkScale, GtkRange, Widgets
+@comment node-name, next, previous, up
+@section The ruler widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt metric
+@end defopt
+
+@defopt lower
+@end defopt
+
+@defopt upper
+@end defopt
+
+@defopt position
+@end defopt
+
+@defopt max_size
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_ruler_get_type (void)
+Returns the @code{GtkRuler} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_ruler_set_metric (GtkRuler *@var{ruler}, GtkMetricType @var{metric})
+@end deftypefun
+
+@deftypefun void gtk_ruler_set_range (GtkRuler *@var{ruler}, gfloat @var{lower}, gfloat @var{upper}, gfloat @var{position}, gfloat @var{max_size})
+@end deftypefun
+
+@deftypefun void gtk_ruler_draw_ticks (GtkRuler *@var{ruler})
+@end deftypefun
+
+@deftypefun void gtk_ruler_draw_pos (GtkRuler *@var{ruler})
+@end deftypefun
+
+@gtkstdmacros{Ruler, RULER}
+
+
+@page
+@node GtkScale, GtkScrollbar, GtkRuler, Widgets
+@comment node-name, next, previous, up
+@section The scale widget
+
+
+@subsection Description
+
+@subsection Options
+
+@defopt digits
+@end defopt
+
+@defopt draw_value
+@end defopt
+
+@defopt pos
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_scale_get_type (void)
+Returns the @code{GtkScale} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_scale_set_digits (GtkScale *@var{scale}, gint @var{digits})
+@end deftypefun
+
+@deftypefun void gtk_scale_set_draw_value (GtkScale *@var{scale}, gint @var{draw_value})
+@end deftypefun
+
+@deftypefun void gtk_scale_set_value_pos (GtkScale *@var{scale}, gint @var{pos})
+@end deftypefun
+
+@deftypefun gint gtk_scale_value_width (GtkScale *@var{scale})
+@end deftypefun
+
+@deftypefun void gtk_scale_draw_value (GtkScale *@var{scale})
+@end deftypefun
+
+@gtkstdmacros{Scale, SCALE}
+
+
+@page
+@node GtkScrollbar, GtkScrolledWindow, GtkScale, Widgets
+@comment node-name, next, previous, up
+@section The scrollbar widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_scrollbar_get_type (void)a
+Returns the @code{GtkScrollbar} type identifier.
+@end deftypefun
+
+@gtkstdmacros{Scrollbar, SCROLLBAR}
+
+
+@page
+@node GtkScrolledWindow, GtkSeparator, GtkScrollbar, Widgets
+@comment node-name, next, previous, up
+@section The scrolled window widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_scrolled_window_get_type (void)
+Returns the @code{GtkScrolledWindow} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_scrolled_window_new (GtkAdjustment *@var{hadjustment}, GtkAdjustment *@var{vadjustment})
+Create a new @code{GtkScrolledWindow} object initializing it with the values in
+@var{adjustment} and @var{adjustment}. The new widget is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkAdjustment* gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *@var{scrolled_window})
+@end deftypefun
+
+@deftypefun GtkAdjustment* gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *@var{scrolled_window})
+@end deftypefun
+
+@deftypefun void gtk_scrolled_window_set_policy (GtkScrolledWindow *@var{scrolled_window}, GtkPolicyType @var{hscrollbar_policy}, GtkPolicyType @var{vscrollbar_policy})
+@end deftypefun
+
+@gtkstdmacros{ScrolledWindow, SCROLLED_WINDOW}
+
+
+@page
+@node GtkSeparator, GtkStatusbar, GtkScrolledWindow, Widgets
+@comment node-name, next, previous, up
+@section The separator widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_separator_get_type (void)
+Returns the @code{GtkSeparator} type identifier.
+@end deftypefun
+
+@gtkstdmacros{Separator, SEPARATOR}
+
+@page
+@node GtkStatusbar, GtkTable, GtkSeparator, Widgets
+@comment node-name, next, previous, up
+@section The statusbar widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_statusbar_get_type (void)
+Returns the @code{GtkStatusbar} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_statusbar_new (void)
+Create a new @code{GtkStatusbar} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun gint gtk_statusbar_push (GtkStatusbar *@var{statusbar}, gchar *@var{text})
+@end deftypefun
+
+@deftypefun void gtk_statusbar_pop (GtkStatusbar *@var{statusbar}, gint @var{context_id})
+@end deftypefun
+
+@gtkstdmacros{Statusbar, STATUSBAR}
+
+@page
+@node GtkTable, GtkText, GtkStatusbar, Widgets
+@comment node-name, next, previous, up
+@section The table widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt rows
+@end defopt
+
+@defopt columns
+@end defopt
+
+@defopt homogeneous
+This option controls whether all child widgets in the @code{GtkTable} will
+be of the same size. The child widgets will be the size of the largest child.
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_table_get_type (void)
+Returns the @code{GtkTable} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_table_new (gint @var{rows}, gint @var{columns}, gint @var{homogeneous})
+Create a new @code{GtkTable} object initializing it with the values in
+@var{rows}, @var{columns} and @var{homogeneous}. The new widget is returned
+as a pointer to a @code{GtkWidget}. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_table_attach (GtkTable *@var{table}, GtkWidget *@var{child}, gint @var{left_attach}, gint @var{right_attach}, gint @var{top_attach}, gint @var{bottom_attach}, gint @var{xoptions}, gint @var{yoptions}, gint @var{xpadding}, gint @var{ypadding})
+@end deftypefun
+
+@deftypefun void gtk_table_attach_defaults (GtkTable *@var{table}, GtkWidget *@var{widget}, gint @var{left_attach}, gint @var{right_attach}, gint @var{top_attach}, gint @var{bottom_attach})
+@end deftypefun
+
+@deftypefun void gtk_table_set_row_spacing (GtkTable *@var{table}, gint @var{row}, gint @var{spacing})
+@end deftypefun
+
+@deftypefun void gtk_table_set_col_spacing (GtkTable *@var{table}, gint @var{col}, gint @var{spacing})
+@end deftypefun
+
+@deftypefun void gtk_table_set_row_spacings (GtkTable *@var{table}, gint @var{spacing})
+@end deftypefun
+
+@deftypefun void gtk_table_set_col_spacings (GtkTable *@var{table}, gint @var{spacing})
+@end deftypefun
+
+@gtkstdmacros{Table, TABLE}
+
+
+@page
+@node GtkText, GtkToggleButton, GtkTable, Widgets
+@comment node-name, next, previous, up
+@section The text widget
+
+
+@subsection Description
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_text_get_type (void)
+Returns the @code{GtkText} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_text_new (GtkAdjustment *@var{hadj}, GtkAdjustment *@var{vadj});
+Create a new @code{GtkText} object initializing it with the values in
+@var{hadj} and @var{vadj}. The new widget is returned as a pointer to a
+@code{GtkWidget}. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_text_set_editable (GtkText *@var{text}, gint @var{editable})
+@end deftypefun
+
+@deftypefun void gtk_text_set_adjustments (GtkText *@var{text}, GtkAdjustment *@var{hadj}, GtkAdjustment *@var{vadj})
+@end deftypefun
+
+@deftypefun void gtk_text_set_point (GtkText *@var{text}, guint @var{index})
+@end deftypefun
+
+@deftypefun guint gtk_text_get_point (GtkText *@var{text})
+@end deftypefun
+
+@deftypefun guint gtk_text_get_length (GtkText *@var{text})
+@end deftypefun
+
+@deftypefun void gtk_text_freeze (GtkText *@var{text})
+@end deftypefun
+
+@deftypefun void gtk_text_thaw (GtkText *@var{text})
+@end deftypefun
+
+@deftypefun void gtk_text_insert (GtkText *@var{text}, GdkFont *@var{font}, GdkColor *@var{fore}, GdkColor *@var{back}, char *@var{chars}, gint @var{length})
+@end deftypefun
+
+@deftypefun gint gtk_text_forward_delete (GtkText *@var{text}, guint @var{nchars})
+@end deftypefun
+
+@deftypefun gint gtk_text_backward_delete (GtkText *@var{text}, guint @var{nchars})
+@end deftypefun
+
+
+@gtkstdmacros{Text, TEXT}
+
+
+@page
+@node GtkToggleButton, GtkToolbar, GtkText, Widgets
+@comment node-name, next, previous, up
+@section The toggle button widget
+
+
+@subsection Description
+
+Another form of button (@pxref{GtkButton}) with two states: on and off.
+The appearance is that of a button which stays pressed on the first
+click, and is released on the second click.
+
+@subsection Options
+
+@defopt state
+@end defopt
+
+@subsection Signals
+
+@deftypefn Signal void GtkToggleButton::toggled (GtkToggleButton *@var{toggle_button})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_toggle_button_get_type (void)
+Returns the @code{GtkToggleButton} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_toggle_button_new (void)
+Create a new @code{GtkToggleButton} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_toggle_button_new_with_label (gchar *@var{label})
+Create a new @code{GtkToggleButton} object initializing it with the values in
+@var{label}. The new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_toggle_button_set_mode (GtkToggleButton *@var{toggle_button}, gint @var{draw_indicator})
+@end deftypefun
+
+@deftypefun void gtk_toggle_button_set_state (GtkToggleButton *@var{toggle_button}, gint @var{state})
+@end deftypefun
+
+@deftypefun void gtk_toggle_button_toggled (GtkToggleButton *@var{toggle_button})
+@end deftypefun
+
+@gtkstdmacros{ToggleButton, TOGGLE_BUTTON}
+
+
+@page
+@node GtkToolbar, GtkTooltips, GtkToggleButton, Widgets
+@comment node-name, next, previous, up
+@section The tool bar widget
+
+@subsection Description
+
+@subsection Options
+
+@defopt orientation
+@itemize @bullet
+@item GTK_ORIENTATION_HORIZONTAL
+
+@item GTK_ORIENTATION_VERTICAL
+@end itemize
+@end defopt
+
+@defopt style
+@itemize @bullet
+@item GTK_TOOLBAR_ICONS
+@item GTK_TOOLBAR_TEXT
+@item GTK_TOOLBAR_BOTH
+@end itemize
+@end defopt
+
+@defopt space_size
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_toolbar_get_type (void)
+Returns the @code{GtkToolbar} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_toolbar_new (GtkOrientation @var{orientation}, GtkToolbarStyle @var{style})
+Create a new @code{GtkToolbar} object initializing it with the values
+@var{orientation} and @var{style}. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_toolbar_append_item (GtkToolbar *@var{toolbar}, char *@var{text}, char *@var{tooltip_text}, GtkPixmap *@var{icon}, GtkSignalFunc @var{callback}, gpointer @var{user_data})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_prepend_item (GtkToolbar *@var{toolbar}, char *@var{text}, char *@var{tooltip_text}, GtkPixmap *@var{icon}, GtkSignalFunc @var{callback}, gpointer @var{user_data})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_insert_item (GtkToolbar *@var{toolbar}, char *@var{text}, char *@var{tooltip_text}, GtkPixmap *@var{icon}, GtkSignalFunc @var{callback}, gpointer @var{user_data}, gint @var{position})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_append_space (GtkToolbar *@var{toolbar})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_prepend_space (GtkToolbar *@var{toolbar})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_insert_space (GtkToolbar *@var{toolbar}, gint @var{position})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_set_orientation (GtkToolbar *@var{toolbar}, GtkOrientation @var{orientation})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_set_style (GtkToolbar *@var{toolbar}, GtkToolbarStyle @var{style})
+Set the @var{style} of the @var{toolbar} to @var{style}.
+@end deftypefun
+
+@deftypefun void gtk_toolbar_set_space_size (GtkToolbar *@var{toolbar}, gint @var{space_size})
+@end deftypefun
+
+@deftypefun void gtk_toolbar_set_tooltips (GtkToolbar *@var{toolbar}, gint @var{enable})
+@end deftypefun
+
+
+@gtkstdmacros{Toolbar, TOOLBAR}
+
+
+@page
+@node GtkTooltips, GtkTree, GtkToolbar, Widgets
+@comment node-name, next, previous, up
+@section The tool tips widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun GtkTooltips* gtk_tooltips_new (void)
+Create a new @code{GtkTooltips} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkTooltips* gtk_tooltips_ref (GtkTooltips *@var{tooltips})
+@end deftypefun
+
+@deftypefun void gtk_tooltips_unref (GtkTooltips *@var{tooltips})
+@end deftypefun
+
+@deftypefun void gtk_tooltips_free_string (gpointer @var{data}, gpointer @var{user_data})
+@end deftypefun
+
+@deftypefun void gtk_tooltips_enable (GtkTooltips *@var{tooltips})
+@end deftypefun
+
+@deftypefun void gtk_tooltips_disable (GtkTooltips *@var{tooltips})
+@end deftypefun
+
+@deftypefun void gtk_tooltips_set_delay (GtkTooltips *@var{tooltips}, GtkWidget *@var{widget}, gchar *@var{tips_text})
+@end deftypefun
+
+@deftypefun void gtk_tooltips_set_colors (GtkTooltips *@var{tooltips}, GdkColor *@var{background}, GdkColor *@var{foreground})
+@end deftypefun
+
+
+@gtkstdmacros{Tooltips, TOOLTIPS}
+
+
+@page
+@node GtkTree, GtkTreeItem, GtkTooltips, Widgets
+@comment node-name, next, previous, up
+@section The tree widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_tree_get_type (void)
+Returns the @code{GtkTree} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_tree_new (void)
+Create a new @code{GtkTree} object returning the new widget as a pointer to
+a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_tree_append (GtkTree *@var{tree}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_tree_prepend (GtkTree *@var{tree}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_tree_insert (GtkTree *@var{tree}, GtkWidget *@var{child}, gint @var{position})
+@end deftypefun
+
+@deftypefun gint gtk_tree_child_position (GtkTree *@var{tree}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_tree_clear_items (GtkTree *@var{tree}, gint @var{start}, gint @var{end})
+@end deftypefun
+
+@deftypefun void gtk_tree_remove_items (GtkTree *@var{tree}, GList *@var{items})
+@end deftypefun
+
+@deftypefun void gtk_tree_select_child (GtkTree *@var{tree}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_tree_select_item (GtkTree *@var{tree}, gint @var{item})
+@end deftypefun
+
+@deftypefun void gtk_tree_unselect_child (GtkTree *@var{tree}, GtkWidget *@var{child})
+@end deftypefun
+
+@deftypefun void gtk_tree_unselect_item (GtkTree *@var{tree}, gint @var{item})
+@end deftypefun
+
+@deftypefun void gtk_tree_set_selection_mode (GtkTree *@var{tree}, GtkSelectionMode @var{mode})
+@end deftypefun
+
+@deftypefun void gtk_tree_set_view_mode (GtkTree *@var{tree}, GtkTreeViewMode @var{mode})
+@end deftypefun
+
+@deftypefun void gtk_tree_set_view_lines (GtkTree *@var{tree}, guint @var{flag})
+@end deftypefun
+
+
+@gtkstdmacros{Tree, TREE}
+
+
+@page
+@node GtkTreeItem, GtkVBox, GtkTree, Widgets
+@comment node-name, next, previous, up
+@section The tree item widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_tree_item_get_type (void)
+Returns the @code{GtkTreeItem} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_tree_item_new (void)
+Create a new @code{GtkTreeItem} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_tree_item_new_with_label (gchar *@var{label})
+Create a new @code{GtkTreeItem} object initializing it with the values in
+@var{label}. The new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_tree_item_set_subtree (GtkTreeItem *@var{tree_item}, GtkWidget *@var{subtree})
+@end deftypefun
+
+@deftypefun void gtk_tree_item_select (GtkTreeItem *@var{tree_item})
+@end deftypefun
+
+@deftypefun void gtk_tree_item_deselect (GtkTreeItem *@var{tree_item})
+@end deftypefun
+
+@deftypefun void gtk_tree_item_expand (GtkTreeItem *@var{tree_item})
+@end deftypefun
+
+@deftypefun void gtk_tree_item_collapse (GtkTreeItem *@var{tree_item})
+@end deftypefun
+
+@deftypefun void gtk_tree_item_remove_subtree (GtkTreeItem *@var{item})
+@end deftypefun
+
+
+@gtkstdmacros{TreeItem, TREE_ITEM}
+
+@page
+@node GtkVBox, GtkVButtonBox, GtkTreeItem, Widgets
+@comment node-name, next, previous, up
+@section The vertical box widget
+
+
+@subsection Description
+
+@subsection Options
+
+@defopt homogeneous
+This option controls whether each object in the box has the same size. In the
+case of the @code{GtkVBox}, this refers to the height. If this option is set
+then the @var{expand} option to the @code{gtk_box_pack} (@pxref{GtkBox})
+routines is always turned on.
+@end defopt
+
+@defopt spacing
+This option sets the amount of space that is added between the objects packed
+into this @code{GtkVBox} object.
+@end defopt
+
+
+@subsection Signals
+This widget does not define any new signals.
+
+@subsection Functions
+
+@deftypefun guint gtk_vbox_get_type (void)
+Returns the @code{GtkVBox} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_vbox_new (gint @var{homogeneous}, gint @var{spacing})
+Create a new @code{GtkVBox} object initializing it with the values in
+@var{homogeneous} and @var{spacing}. The new widget is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{VBox, VBOX}
+
+@page
+@node GtkVButtonBox, GtkViewport, GtkVBox, Widgets
+@comment node-name, next, previous, up
+@section The vertical button box widget
+
+
+@subsection Description
+
+@subsection Options
+@defopt spacing
+@end defopt
+
+@defopt layout
+@end defopt
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_vbutton_box_get_type (void)
+Returns the @code{GtkVButtonBox} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_vbutton_box_new (void)
+Create a new @code{GtkVButtonBox} object returning the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@deftypefun void gtk_vbutton_box_set_spacing_default (gint @var{spacing})
+@end deftypefun
+
+@deftypefun void gtk_vbutton_box_set_layout_default (gint @var{layout})
+@end deftypefun
+
+@deftypefun gint gtk_vbutton_box_get_spacing_default (void)
+@end deftypefun
+
+@deftypefun gint gtk_vbutton_box_get_layout_default (void)
+@end deftypefun
+
+@gtkstdmacros{VButtonBox, VBUTTON_BOX}
+
+
+@page
+@node GtkViewport, GtkVPaned, GtkVButtonBox, Widgets
+@comment node-name, next, previous, up
+@section The viewport widget
+
+
+@subsection Description
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_viewport_get_type (void)
+Returns the @code{GtkViewport} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_viewport_new (GtkAdjustment *@var{hadjustment}, GtkAdjustment *@var{vadjustment})
+@end deftypefun
+
+@deftypefun GtkAdjustment* gtk_viewport_get_hadjustment (GtkViewport *@var{viewport})
+@end deftypefun
+
+@deftypefun GtkAdjustment* gtk_viewport_get_vadjustment (GtkViewport *@var{viewport})
+@end deftypefun
+
+@deftypefun void gtk_viewport_set_hadjustment (GtkViewport *@var{viewport}, GtkAdjustment *@var{adjustment})
+@end deftypefun
+
+@deftypefun void gtk_viewport_set_vadjustment (GtkViewport *@var{viewport}, GtkAdjustment *@var{adjustment})
+@end deftypefun
+
+@deftypefun void gtk_viewport_set_shadow_type (GtkViewport *@var{viewport}, GtkShadowType @var{type})
+@end deftypefun
+
+@gtkstdmacros{Viewport, VIEWPORT}
+
+@page
+@node GtkVPaned, GtkVRuler, GtkViewport, Widgets
+@comment node-name, next, previous, up
+@section The vertical paned widget
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_vpaned_get_type (void)
+Returns the @code{GtkVPaned} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_vpaned_new (void)
+Create a new @code{GtkVPaned} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{VPaned, VPANED}
+
+@page
+@node GtkVRuler, GtkVScale, GtkVPaned, Widgets
+@comment node-name, next, previous, up
+@section The vertical ruler widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_vruler_get_type (void)
+Returns the @code{GtkVRuler} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_vruler_new (void)
+Create a new @code{GtkVRuler} object returning the new widget as a pointer to
+a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{VRuler, VRULER}
+
+
+@page
+@node GtkVScale, GtkVScrollbar, GtkVRuler, Widgets
+@comment node-name, next, previous, up
+@section The vertical ruler widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_vscale_get_type (void)
+Returns the @code{GtkVScale} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_vscale_new (GtkAdjustment *@var{adjustment})
+Create a new @code{GtkVScale} object returning the new widget as a pointer
+to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{VScale, VSCALE}
+
+
+@page
+@node GtkVScrollbar, GtkVSeparator, GtkVScale, Widgets
+@comment node-name, next, previous, up
+@section The vertical scrollbar widget
+
+
+@subsection Description
+
+@subsection Options
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_vscrollbar_get_type (void)
+Returns the @code{GtkVScrollbar} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_vscrollbar_new (GtkAdjustment *@var{adjustment})
+Create a new @code{GtkVScrollbar} object initializing it with the values in
+@var{adjustment}. The new widget is returned as a pointer to a @code{GtkWidget}
+object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{VScrollbar, VSCROLLBAR}
+
+
+@page
+@node GtkVSeparator, GtkWidget, GtkVScrollbar, Widgets
+@comment node-name, next, previous, up
+@section The vertical separator widget
+
+
+@subsection Description
+
+@subsection Signals
+
+@subsection Functions
+
+@deftypefun guint gtk_vseparator_get_type (void)
+Returns the @code{GtkVSeparator} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_vseparator_new (void)
+Create a new @code{GtkVSeparator} object and return the new widget as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+@end deftypefun
+
+@gtkstdmacros{VSeparator, VSEPARATOR}
+
+
+@page
+@node GtkWidget, GtkWindow, GtkVSeparator, Widgets
+@comment node-name, next, previous, up
+@section The base widget
+
+
+@subsection Description
+
+@subsection Signals
+
+@deftypefn Signal void GtkWidget::show (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::hide (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::map (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::unmap (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::realize (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::unrealize (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::draw (GtkWidget *@var{widget}, GdkRectangle *@var{area})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::draw_focus (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::draw_default (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::size_request (GtkWidget *@var{widget}, GtkRequisition *@var{requisition})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::size_allocate (GtkWidget *@var{widget}, GtkAllocation *@var{allocation})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::state_changed (GtkWidget *@var{widget})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::install_accelerator (GtkWidget *@var{widget}, gchar *@var{signal_name}, gchar @var{key}, guint8 @var{modifiers})
+@end deftypefn
+
+@deftypefn Signal void GtkWidget::remove_accelerator (GtkWidget *@var{widget}, gchar *@var{signal_name})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::event (GtkWidget *@var{widget}, GdkEvent *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::button_press_event (GtkWidget *@var{widget}, GdkEventButton *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::button_release_event (GtkWidget *@var{widget}, GdkEventButton *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::motion_notify_event (GtkWidget *@var{widget}, GdkEventMotion *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::delete_event (GtkWidget *@var{widget}, GdkEventAny *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::destroy_event (GtkWidget *@var{widget}, GdkEventAny *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::expose_event (GtkWidget *@var{widget}, GdkEventExpose *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::key_press_event (GtkWidget *@var{widget}, GdkEventKey *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::key_release_event (GtkWidget *@var{widget}, GdkEventKey *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::enter_notify_event (GtkWidget *@var{widget}, GdkEventCrossing *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::leave_notify_event (GtkWidget *@var{widget}, GdkEventCrossing *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::configure_event (GtkWidget *@var{widget}, GdkEventConfigure *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::focus_in_event (GtkWidget *@var{widget}, GdkEventFocus *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::focus_out_event (GtkWidget *@var{widget}, GdkEventFocus *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::map_event (GtkWidget *@var{widget}, GdkEventAny *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::unmap_event (GtkWidget *@var{widget}, GdkEventAny *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::property_notify_event (GtkWidget *@var{widget}, GdkEventProperty *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::selection_clear_event (GtkWidget *@var{widget}, GdkEventSelection *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::selection_request_event (GtkWidget *@var{widget}, GdkEventSelection *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::selection_notify_event (GtkWidget *@var{widget}, GdkEventSelection *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::drop_event (GtkWidget *@var{widget}, GdkEventDrop *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::drag_begin_event (GtkWidget *@var{widget}, GdkEventDragBegin *@var{event})
+@end deftypefn
+
+@deftypefn Signal gint GtkWidget::other_event (GtkWidget *@var{widget}, GdkEventOther *@var{event})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_widget_get_type (void)
+Returns the @code{GtkWidget} type identifier.
+@end deftypefun
+
+@deftypefun void gtk_widget_class_init (GtkWidgetClass *@var{class})
+@end deftypefun
+
+@deftypefun void gtk_widget_init (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_destroy (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_show (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_hide (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_map (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_unmap (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_realize (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_unrealize (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_draw (GtkWidget *@var{widget}, GdkRectangle *@var{area})
+@end deftypefun
+
+@deftypefun void gtk_widget_draw_focus (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_draw_children (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_size_request (GtkWidget *@var{widget}, GtkRequisition *@var{requisition})
+@end deftypefun
+
+@deftypefun void gtk_widget_size_allocate (GtkWidget *@var{widget}, GtkAllocation *@var{allocation})
+@end deftypefun
+
+@deftypefun void gtk_widget_install_accelerator (GtkWidget *@var{widget}, GtkAcceleratorTable *@var{table}, gchar *@var{signal_name}, gchar @var{key}, guint8 @var{modifiers})
+@end deftypefun
+
+@deftypefun void gtk_widget_remove_accelerator (GtkWidget *@var{widget}, GtkAcceleratorTable *@var{table}, gchar *@var{signal_name})
+@end deftypefun
+
+@deftypefun gint gtk_widget_event (GtkWidget *@var{widget}, GdkEvent *@var{event})
+@end deftypefun
+
+@deftypefun void gtk_widget_reparent (GtkWidget *@var{widget}, GtkWidget *@var{new_parent})
+@end deftypefun
+
+@deftypefun void gtk_widget_popup (GtkWidget *@var{widget}, gint @var{x}, gint @var{y})
+@end deftypefun
+
+@deftypefun gint gtk_widget_intersect (GtkWidget *@var{widget}, GdkRectangle *@var{area}, GdkRectangle *@var{intersection})
+@end deftypefun
+
+@deftypefun void gtk_widget_grab_focus (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_grab_default (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_restore_state (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun void gtk_widget_set_name (GtkWidget *@var{widget}, gchar *@var{name})
+@end deftypefun
+
+@deftypefun void gtk_widget_set_state (GtkWidget *@var{widget}, GtkStateType @var{state})
+@end deftypefun
+
+@deftypefun void gtk_widget_set_sensitive (GtkWidget *@var{widget}, gint sensitive)
+@end deftypefun
+
+@deftypefun void gtk_widget_set_parent (GtkWidget *@var{widget}, GtkWidget *@var{parent})
+@end deftypefun
+
+@deftypefun void gtk_widget_set_style (GtkWidget *@var{widget}, GtkStyle *@var{style})
+@end deftypefun
+
+@deftypefun void gtk_widget_set_uposition (GtkWidget *@var{widget}, gint @var{x}, gint @var{y})
+@end deftypefun
+
+@deftypefun void gtk_widget_set_usize (GtkWidget *@var{widget}, gint @var{width}, gint @var{height})
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_widget_get_toplevel (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_widget_get_ancestor (GtkWidget *@var{widget}, gint @var{type})
+@end deftypefun
+
+@deftypefun GdkColormap* gtk_widget_get_colormap (GtkWidget *@var{widget})
+@end deftypefun
+
+@deftypefun GdkVisual* gtk_widget_get_visual (GtkWidget *@var{visual})
+@end deftypefun
+
+@deftypefun GtkStyle* gtk_widget_get_style (GtkWidget *@var{style})
+@end deftypefun
+
+@gtkstdmacros{Widget, WIDGET}
+
+
+@page
+@node GtkWindow, , GtkWidget, Widgets
+@comment node-name, next, previous, up
+@section The window widget
+
+
+@subsection Description
+
+@subsection Options
+
+@defopt type
+The @var{type} options specify how this widget will interact with the
+window manager. Currently the following types and the effect they have
+on the window to window manager interaction is as follows.
+@itemize @bullet
+
+@item
+@code{GTK_WINDOW_TOPLEVEL}
+@itemize @bullet
+@item
+The option @code{GTK_WINDOW_TOPLEVEL} is usually used for the main application
+window that will remain for the entire application run.
+@end itemize
+@item
+@code{GTK_WINDOW_DIALOG}
+@itemize @bullet
+@item
+The option @code{GTK_WINDOW_DIALOG} is usually used for transient
+windows. These windows will open up, gather some input or provide some
+application specific updates, then close. The window manager is free not
+to provide all the 'normal' window functions to this window.
+@end itemize
+@item
+@code{GTK_WINDOW_POPUP}
+@itemize @bullet
+@item
+The option @code{GTK_WINDOW_POPUP} is usually used for transient windows.
+These windows are typically used for when no user interaction is required,
+to notify the user of some condition. Other uses for these types of windows
+are for 'about windows', startup windows and the like. Typically the window
+manager will @strong{not} provide the usual widgets that surround the
+window. At the most all that will be provided is a border. Also note that
+windows that set this @var{type} will not be in any window list of the window
+manager. Though this window will @strong{not} get the kill and close widgets
+of the window manager they still can receive said events and should be
+taken into account.
+@end itemize
+@end itemize
+@end defopt
+
+@defopt title
+The @var{title} option will set the title of the window in the window manager.
+@strong{Note:} On windows that have the @var{type} option set to
+@code{GTK_WINDOW_POPUP} there is a strong possibility that this will text
+will not be seen.
+@end defopt
+
+@defopt position
+The @var{position} option will determine where the window will be displayed
+when it is finally drawn to the screen. Currently the following positions
+ and the effect they have on window placement can be specified.
+
+@itemize @bullet
+
+@item
+@code{GTK_WIN_POS_NONE}
+@itemize @bullet
+@item
+This @var{position} type will allow the window manager full freedom, depending
+on the current settings in the window manager. As to where the window will
+be placed.
+@end itemize
+@item
+@code{GTK_WIN_POS_CENTER}
+@itemize @bullet
+@item
+This @var{position} option will cause the window to center itself on the
+the screen. This option setting will take into account the @var{virtual screen}
+size when calculating the center. This is @strong{not} the same as the
+@var{virtual desktop} setting of many window managers. It will center itself
+on the current @var{virtual desktop}.
+@end itemize
+@item
+@code{GTK_WIN_POS_MOUSE}
+@itemize @bullet
+This @var{position} option will cause the window to center itself under the
+mouse pointers' current location. Typical uses for this setting is in
+warning/error/informational dialogs where user interaction is desired.
+@end itemize
+@end itemize
+@end defopt
+
+
+@subsection Signals
+
+@deftypefn Signal void GtkWindow::move_resize (GtkWindow *@var{window}, gint *@var{x}, gint *@var{y}, gint @var{width}, gint @var{height})
+@end deftypefn
+
+@deftypefn Signal void GtkWindow::set_focus (GtkWindow *@var{window}, GtkWidget *@var{focus})
+@end deftypefn
+
+@subsection Functions
+
+@deftypefun guint gtk_window_get_type (void)
+Returns the @code{GtkWindow} type identifier.
+@end deftypefun
+
+@deftypefun GtkWidget* gtk_window_new (GtkWindowType @var{type})
+Create a new @code{GtkWindow} object. The new widget is returned as a
+pointer to a @code{GtkWidget} object. @code{NULL} is returned on failure.
+The @var{type} can be one of @code{GTK_WINDOW_TOPLEVEL},
+@code{GTK_WINDOW_DIALOG} or, @code{GTK_WINDOW_POPUP}. The @var{type}
+value determines how this widget will interact with the window manager.
+@end deftypefun
+
+@deftypefun void gtk_window_set_title (GtkWindow *@var{window}, gchar *@var{title})
+Set the title of this window to the text in the @var{title} argument. It is
+important to not set the fields of the @code{GtkWindow} structure directly.
+@end deftypefun
+
+@deftypefun void gtk_window_set_focus (GtkWindow *@var{window}, GtkWidget *@var{focus})
+@end deftypefun
+
+@deftypefun void gtk_window_set_default (GtkWindow *@var{window}, GtkWidget *@var{defaultw})
+@end deftypefun
+
+@deftypefun void gtk_window_set_policy (GtkWindow *@var{window}, gint @var{allow_shrink}, gint @var{allow_grow}, gint @var{auto_shrink})
+@end deftypefun
+
+@deftypefun void gtk_window_add_accelerator_table (GtkWindow *@var{window}, GtkAcceleratorTable *@var{table})
+@end deftypefun
+
+@deftypefun void gtk_window_remove_accelerator_table (GtkWindow *@var{window}, GtkAcceleratorTable *@var{table})
+@end deftypefun
+
+@deftypefun void gtk_window_position (GtkWindow *@var{window}, GtkWindowPosition @var{position})
+Set the position that the window will be at when it is finally drawn to the
+screen. The @var{position} argument effects the the position as described
+above.
+@end deftypefun
+
+@gtkstdmacros{Window, WINDOW}
+
+
+@node Other Objects, Miscellaneous, Widgets, Top
+@comment node-name, next, previous, up
+@chapter Utility objects
+
+
+@menu
+* GtkAcceleratorTable:: The accelerator table object.
+* GtkAdjustment:: The adjustment object.
+* GtkGC:: The GC object.
+* GtkData:: The data object.
+* GtkStyle:: The style object.
+@end menu
+
+
+@node GtkAcceleratorTable, GtkAdjustment, Other Objects, Other Objects
+@comment node-name, next, previous, up
+@section The accelerator table object
+
+@subsection Description
+
+@subsection Functions
+
+@deftypefun GtkAcceleratorTable* gtk_accelerator_table_new (void)
+@end deftypefun
+
+@deftypefun GtkAcceleratorTable* gtk_accelerator_table_find (GtkObject *@var{object}, gchar *@var{signal_name}, guchar @var{accelerator_key}, guint8 @var{accelerator_mods})
+@end deftypefun
+
+@deftypefun GtkAccelerator *gtk_accelerator_table_ref (GtkAcceleratorTable *@var{table})
+@end deftypefun
+
+@deftypefun void gtk_accelerator_table_unref (GtkAcceleratorTable *@var{table})
+@end deftypefun
+
+@deftypefun void gtk_accelerator_table_install (GtkAcceleratorTable *@var{table}, GtkObject *@var{object}, gchar *@var{signal_name}, guchar @var{accelerator_key}, guint8 @var{accelerator_mods})
+@end deftypefun
+
+@deftypefun void gtk_accelerator_table_remove (GtkAcceleratorTable *@var{table}, GtkObject *@var{object}, gchar *@var{signal_name})
+@end deftypefun
+
+@deftypefun void gtk_accelerator_table_check (GtkAcceleratorTable *@var{table}, guchar @var{accelerator_key}, guint8 @var{accelerator_mods})
+@end deftypefun
+
+@deftypefun void gtk_accelerator_table_set_mod_mask (GtkAcceleratorTable *@var{table}, guint8 @var{modifier_mask})
+@end deftypefun
+
+@page
+@node GtkAdjustment, GtkGC, GtkAcceleratorTable, Other Objects
+@comment node-name, next, previous, up
+@section The adjustment object
+
+@subsection Description
+
+@subsection Functions
+
+@deftypefun guint gtk_adjustment_get_type (void)
+Returns the @code{GtkAdjustment} type identifier.
+@end deftypefun
+
+@deftypefun GtkObject* gtk_adjustment_new (gfloat @var{value}, gfloat @var{lower}, gfloat @var{upper}, gfloat @var{step_increment}, gfloat @var{page_increment}, gfloat @var{page_size})
+@end deftypefun
+
+@gtkstdmacros{GtkAdjustment, ADJUSTMENT}
+
+@page
+@node GtkGC, GtkData, GtkAdjustment, Other Objects
+@section The GC object
+
+@subsection Description
+
+@subsection Functions
+
+@deftypefun GdkGC* gtk_gc_get (gint @var{depth}, GdkColormap *@var{colormap}, GdkGCValues *@var{values}, GdkGCValuesMask @var{values_mask})
+@end deftypefun
+
+@deftypefun void gtk_gc_release (GdkGC *@var{gc})
+@end deftypefun
+
+@page
+@node GtkData, GtkStyle, GtkGC, Other Objects
+@comment node-name, next, previous, up
+@section The data object
+
+@subsection Description
+
+@subsection Functions
+
+@deftypefun guint gtk_data_get_type (void)
+Returns the @code{GtkData} type identifier.
+@end deftypefun
+
+@gtkstdmacros{Data, DATA}
+@page
+@node GtkStyle, ,GtkData, Other Objects
+@section The style object
+
+@subsection Description
+
+@subsection Functions
+
+@page
+@node Miscellaneous, Examples, Other Objects, Top
+@comment node-name, next, previous, up
+@chapter Initialization, exit and other features
+
+
+@menu
+* Initialization and exit:: Initializing and exiting GTK.
+* Customization:: Customizing the library.
+* Menu Factories:: Simplified menu creation.
+* Tree Factories:: Simplified tree creation.
+* Tool Tips:: Pop up help mechanism.
+* Resource Files:: Resource files.
+* Standard Macros:: Macros defined by all objects.
+@end menu
+
+
+@node Initialization and exit, Customization, Miscellaneous, Miscellaneous
+@comment node-name, next, previous, up
+@section Initializing and exiting GTK
+
+@subsection Initializing
+Before any GTK functions can be utilized the library must be initialized. This
+can be accomplished by calling the @code{gtk_init} function. The arguments
+you pass to this function should be the same arguments that were passed to
+your application. This function will parse the arguments that it understands
+and handle initializing the GDK library for you.
+
+@subsection Exiting
+
+@subsection Functions
+
+@deftypefun void gtk_init (int *@var{argc}, char **@var{argv})
+Function to initialize GTK and GDK for you. This function will remove any
+command line arguments from @var{argc} and @var{argv} that it understands.
+
+@example
+int main (int argc, char *argv[])
+@{
+ @dots{Any local variables or non GTK/GDK initialization}
+
+ /* Initialize GTK. */
+ gtk_init(&argc, &argc);
+
+@}
+@end example
+@end deftypefun
+
+@deftypefun void gtk_exit (int @var{error_code})
+Exit GTK and perform any necessary cleanup. @code{gtk_exit} will call the
+systems @code{exit} function passing @var{error_code} as the parameter.
+@end deftypefun
+
+@deftypefun gint gtk_events_pending (void)
+Returns the number of events pending on the event queue.
+@end deftypefun
+
+@deftypefun void gtk_main (void)
+@end deftypefun
+
+@deftypefun guint gtk_main_level (void)
+@end deftypefun
+
+@deftypefun void gtk_main_quit (void)
+A call to this function will cause the @code{gtk_main} function to exit,
+thereby allowing your application to exit.
+@end deftypefun
+
+@page
+@node Customization, Menu Factories, Initialization and exit, Miscellaneous
+@comment node-name, next, previous, up
+@section Customization of the library
+
+@subsection Description
+Like other X-windows applications the GTK library provides a way for the
+user and application programmer to change the colors of just about any widget.
+You can also specify what pixmap should be tiled onto the background of some
+widgets. All this is handled through a similar method as in the standard
+X-windows environment, through the use of 'rc' files. The format and
+functions available in these files is discussed below.
+
+@subsection Functions
+The following functions are available to handle the rc files.
+
+@deftypefun void gtk_rc_parse (char *@var{filename})
+This function will parse the @var{filename} that is passed to it as its
+argument. It will use the style settings for the widget types defined there.
+@end deftypefun
+
+@deftypefun void gtk_rc_init (void)
+This function will initialize the rc file parser, normally this need not
+be called directly as the @code{gtk_rc_parse} function will handle this for
+you.
+@end deftypefun
+
+@page
+@node Menu Factories, Tree Factories, Customization, Miscellaneous
+@comment node-name, next, previous, up
+@section Simplified menu creation
+
+@page
+@node Tree Factories, Tool Tips, Menu Factories, Miscellaneous
+@comment node-name, next, previous, up
+@section Simplified tree creation
+
+@page
+@node Tool Tips, Resource Files, Tree Factories, Miscellaneous
+@comment node-name, next, previous, up
+@section Pop up help mechanism
+
+@subsection Description
+
+@page
+@node Resource Files, Standard Macros, Tool Tips, Miscellaneous
+@comment node-name, next, previous, up
+@section Resource Files
+
+@page
+@node Standard Macros, , Resource Files, Miscellaneous
+@comment node-name, next, previous, up
+@section Macros defined by all objects
+
+There are three macros that are defined by all object types. The first
+two are used for performing casts and the last is for querying whether
+an object is of a particular type. These macros are both conveniences
+and debugging tools. If the GTK library was compiled with @code{NDEBUG}
+defined as a preprocessor symbol (via the -DNDEBUG to cc), then the
+macros check the object type and emit a warning if the cast is
+invalid. Doing such checking is fairly expensive since the cast macros
+are used everywhere in GTK and would normally be turned off in a public
+release of a product. Note: The functions below are indeed macros, but
+they may be considered functions for most purposes.
+
+@deftypefun Gtk<ObjectType>* GTK_<OBJECT_TYPE> (gpointer @var{obj})
+Cast a generic pointer to @code{Gtk<ObjectType>*}. This function is
+provided in order to be able to provide checking during development
+stages of code development since it is possible to examine the actual
+type of object (using @code{gtk_type_is_a}) before performing the cast.
+@end deftypefun
+
+@deftypefun Gtk<ObjectType>Class* GTK_<OBJECT_TYPE>_CLASS (gpointer @var{class})
+Cast a generic pointer to @code{Gtk<ObjectType>Class*}. Like
+@code{GTK_<ObjectType>}, this function is, in reality, a macro.
+@end deftypefun
+
+@deftypefun gint GTK_IS_<ObjectType> (gpointer @var{obj})
+Determine if a generic pointer refers to a @code{Gtk<ObjectType>}
+object. This function is, in reality, a macro wrapper around the
+@code{gtk_type_is_a} function (@pxref{Objects}).
+@end deftypefun
+
+
+@node Examples, Object Implementation, Miscellaneous, Top
+@comment node-name, next, previous, up
+@chapter Using GTK
+@cindex Using GTK
+
+@menu
+* Simple:: The simplest GTK program.
+* Hello World:: Hello world in GTK.
+* Hello World II:: An enhanced hello world.
+* Hello World III:: Making Hello World II robust.
+@end menu
+
+
+@node Simple, Hello World, Examples, Examples
+@comment node-name, next, previous, up
+@section The simplest GTK program
+
+
+The 16 line GTK program shown below is just about the simplest possible
+program which uses GTK. (Well, technically, you don't have to create the
+window and it would still be a program which uses GTK). The program,
+when compiled and run, will create a single window 200x200 pixels in
+size. The program does not exit until its is explicitly killed using the
+shell or a window manager function.
+
+@example
+#include <gtk/gtk.h>
+
+int
+main (int argc, char *argv[])
+@{
+ GtkWidget *window;
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_widget_show (window);
+
+ gtk_main ();
+
+ return 0;
+@}
+@end example
+
+The first point of interest in this program is the standard
+initialization line.
+
+@example
+ gtk_init (&argc, &argv);
+@end example
+
+Almost every GTK program will contain such a line. GTK will initialize
+itself and GDK and remove any command line arguments it recognizes from
+@var{argc} and @var{argv}.
+
+The next two lines of code create and display a window.
+
+@example
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_widget_show (window);
+@end example
+
+The @code{GTK_WINDOW_TOPLEVEL} argument specifies that we want the
+window to undergo window manager decoration and placement. One might be
+lead to think that the window, since it has no children, would be 0x0
+pixels in size. But, this is not the case because a window that has no
+children defaults to 200x200 pixels in size. Mainly because 0x0 windows
+are annoying to manipulate or even see in some cases.
+
+The last line enters the GTK main processing loop.
+
+@example
+ gtk_main ();
+@end example
+
+Normally, @code{gtk_main} is called once and the program should exit
+when it returns. @xref{Initialization and exit}.
+
+
+@node Hello World, Hello World II, Simple, Examples
+@comment node-name, next, previous, up
+@section Hello world in GTK
+
+
+@example
+#include <gtk/gtk.h>
+
+int
+main (int argc, char *argv[])
+@{
+ GtkWidget *window;
+ GtkWidget *label;
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+ label = gtk_label_new ("Hello World");
+ gtk_container_add (GTK_CONTAINER (window), label);
+ gtk_widget_show (label);
+
+ gtk_widget_show (window);
+
+ gtk_main ();
+
+ return 0;
+@}
+@end example
+
+
+@node Hello World II, Hello World III, Hello World, Examples
+@comment node-name, next, previous, up
+@section An enhanced hello world
+
+
+@example
+#include "gtk.h"
+
+void
+hello (void)
+@{
+ g_print ("Hello World\n");
+ gtk_exit (0);
+@}
+
+int
+main (int argc, char *argv[])
+@{
+ GtkWidget *window;
+ GtkWidget *button;
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+ button = gtk_button_new_with_label ("Hello World");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (hello), NULL);
+ gtk_container_add (GTK_CONTAINER (window), button);
+ gtk_widget_show (button);
+
+ gtk_widget_show (window);
+
+ gtk_main ();
+
+ return 0;
+@}
+@end example
+
+
+@node Hello World III, , Hello World II, Examples
+@comment node-name, next, previous, up
+@section Making Hello World II robust
+
+
+@example
+#include "gtk.h"
+
+void
+hello (void)
+@{
+ g_print ("Hello World\n");
+ gtk_exit (0);
+@}
+
+void
+destroy (void)
+@{
+ gtk_exit (0);
+@}
+
+int
+main (int argc, char *argv[])
+@{
+ GtkWidget *window;
+ GtkWidget *button;
+
+ gtk_init (&argc, &argv);
+
+ window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ gtk_signal_connect (GTK_OBJECT (window), "destroy",
+ GTK_SIGNAL_FUNC (destroy), NULL);
+ gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+ button = gtk_button_new_with_label ("Hello World");
+ gtk_signal_connect (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (hello), NULL);
+ gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+ GTK_SIGNAL_FUNC (gtk_widget_destroy),
+ GTK_OBJECT (window));
+ gtk_container_add (GTK_CONTAINER (window), button);
+ gtk_widget_show (button);
+
+ gtk_widget_show (window);
+
+ gtk_main ();
+
+ return 0;
+@}
+@end example
+
+
+@node Object Implementation, Signal Implementation, Examples, Top
+@comment node-name, next, previous, up
+@chapter Object internals
+@cindex Object Implementation
+
+Objects (or the @code{GtkObject} type) and the class hierarchy in
+general is implemented via a hierarchy of structs and type casting. Be
+aware that when classes are mentioned it is the conceptual idea of
+classes that is being referred to. GTK is written entirely in C which
+provides no direct support for classes.
+
+The first part to the class mechanism is the object fields. These are
+fields that will be used on a per object basis. For example, the widget
+type contains a field for the widgets parent. Every derived type needs a
+reference to its parent type. A descendant class of @code{GtkObject}
+would define itself like:
+
+@example
+struct Descendant
+@{
+ GtkObject object;
+
+ @dots{}
+@};
+@end example
+
+It is important to note that the @code{GtkObject} field needs to appear
+first in the descendant type structure. This allows pointers to objects
+of type @code{Descendant} to be cast to pointers to @code{GtkObject}'s
+and vice-versa.
+
+The second part to the class mechanism is the class fields. These fields
+are defined on a per class basis. In the case of widgets, the class
+fields are all the ``virtual'' functions for widgets. The
+@code{GtkObject} class defines the @code{destroy} virtual function and
+the necessary fields for the signal mechanism as well as a field for
+determining the runtime type of an object. A virtual function is
+semantically the same as it is in C++. That is, the actual function that
+is called is determined based on the type of the object. Or, more
+specifically, the actual function call depends on the class structure
+that is pointed to by the @code{klass} field of the @code{GtkObject}
+structure.
+
+To see how the class fields work it is necessary to see the object
+fields for a @code{GtkObject}. The @code{GtkObject} type is defined as
+follows:
+
+@example
+typedef struct _GtkObject GtkObject;
+
+struct _GtkObject
+@{
+ guint32 flags;
+ GtkObjectClass *klass;
+ gpointer object_data;
+@};
+@end example
+
+The @code{class} field actually points to a class structure derived from
+@code{GtkObjectClass}. By convention, each new type defines its own
+class structure even if it is unnecessary. As an example, the
+hypothetical @code{Descendant} class would define its class structure
+as:
+
+@example
+struct DescendantClass
+@{
+ GtkObjectClass parent_class;
+
+ @dots{}
+@};
+@end example
+
+It is convention to name the parent class field (@code{GtkObjectClass}
+in this case), @code{parent_class}. For the same reason as stated above
+for the object structure, the parent class field must be the first field
+in the class structure.
+
+@strong{Note:} GTK assumes that the first field in a structure will be
+placed by the compiler at the start of the structure. This is certainly
+true for gcc, however, from my precursory reading of the C standard I
+was unable to come to a definite conclusion as to whether this was
+required or simply done for simplicity. I'm not too worried about this
+assumption, though, as every C compiler I've ever encountered would work
+with GTK.
+
+The @code{flags} field of the @code{GtkObject} structure is used to keep
+track of a relatively few object flags and is also used by the
+@code{GtkWidget} type to store additional flags. At this time, the upper
+16 bits of the flags field are reserved but unused.
+
+The @code{object_data} field of the @code{GtkObject} structure is an
+opaque pointer used by the object data mechanism. In truth, it is a
+pointer to the beginning of the data list which is composed of the
+following structures.
+
+@example
+typedef struct _GtkObjectData GtkObjectData;
+
+struct _GtkObjectData
+@{
+ guint id;
+ gpointer data;
+ GtkObjectData *next;
+@};
+@end example
+
+The data mechanism allows arbitrary data to be associated with a
+character string key in any object. A hash table is used to transform
+the character string key into the data id and then a search through the
+list is made to see if the data exists. The assumption being that the
+data list will usually be short and therefore a linear search is
+OK. Future work on the data mechanism might make use of a resizable
+array instead of a linked list. This would shrink the overhead of the
+@code{GtkObjectData} structure by 4 bytes on 32 bit architectures.
+
+
+@node Signal Implementation, Widget Implementation, Object Implementation, Top
+@comment node-name, next, previous, up
+@chapter Signal internals
+@cindex Signal Implementation
+
+
+@node Widget Implementation, Function Index, Signal Implementation, Top
+@comment node-name, next, previous, up
+@chapter Widget internals
+@cindex Widget Implementation
+
+
+@node Function Index, Concept Index, Widget Implementation, Top
+@comment node-name, next, previous, up
+@unnumbered Function Index
+
+@printindex fn
+
+
+@node Concept Index, , Function Index, Top
+@comment node-name, next, previous, up
+@unnumbered Concept Index
+
+@printindex cp
+
+
+@summarycontents
+@contents
+@bye
projects / ~andy / gtk / commitdiff