The GIMP Toolkit

Version 1.0 August 1998

by Peter Mattis and the GTK+ team

Copyright \begin{matrix}c \\ ◯ \end{matrix} 1996 Peter Mattis Copyright \begin{matrix}c \\ ◯ \end{matrix} 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.

The GIMP Toolkit 1

The GIMP Toolkit

2 GTK

1 Copying

GTK is 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 our 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 accompany it.

4 GTK

2 What is GTK?

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 (see Chapter 6 [Widgets], page 25) 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.

To make life easier for you, GTK presents this flexibility in a uniform framework. Specifically, it implements its own support for object oriented programming that is well adapted to the purposes of a user interface toolkit and it aims at providing a reasonable sane and disciplined programming interface. This uniformity and discipline is intended to make it easy and reliable to access GTK from languages other than C. Especially more dynamic languages like Perl, Python or Scheme will find amble support, and in fact, bindings to these languages already exist.

6 GTK

3 Types

Other kid’s games are all such a bore!

They’ve gotta have rules and they gotta keep score!

– Calvin about CalvinBall(tm)

GTK implements a semi-simple type system with an associated class mechanism for widgets and several other useful objects. This type system is intended to be general enough to allow both a smooth binding of dynamically typed languages to Gtk, as well as to serve for a rigorous and formalistic definition of the larger part of the Gtk API.

The classes for the individual widgets are by far the most important part of this type system, but before we get to them, we describe the basics of the type system itself. This is mostly of interest for widget writers and language binders, so you might want to skip ahead to the next chapter, which talks about the object oriented stuff.

3.1 Introduction to the Type System

Gtk defines its own system of types, much like a computer language defines what types it supports. Of course, the Gtk type system is build on top of the types that C provides, so it includes members like ‘int’, ‘long’ and ‘float’. But, compared to C, it allows only few carefully selected types and specifies a lot of restrictions on the way you can use values of these types. For example, there is no general facility for specifying pointer to X. Instead, we take a more higher level approach and define such things as ‘string’, which is just like a char* but with additional rules about how to manage the memory that it points to.

The type system has two purposes: to define a formal system with which to describe the various exported features of Gtk; and to implement this system at run-time so that we get sound and flexible dynamic types for the dynamic languages that want to interface with Gtk.

Let me restate this with different words, because I think it is important to understand this idea. We will see in a moment that the type system is indeed well defined and all this detail is implemented with functions and data structures in Gtk. For example, every type (and there can be any number of them) can be represented with a unique integer and Gtk has support for the necessary bookkeeping for this. Every type also has a name and there are functions for converting between the name of a type and its unique number. Maybe more useful, there is a big discriminated union that can be used to pass around a value of any representable type, together with its precise type.

This is the run-time or dynamic side of the type system. Mostly, you do not need to use it when you don’t want to. The compile-time or static side of the type system can is used to statically define the programming interface of Gtk. For example, suppose there is function gtk_foo in the Gtk API that has a prototype

     char *gtk_foo (char *);

This looks like it does something with strings. But what does it do with the memory of the string that has been passed in, and what are we supposed or allowed to do with the memory that the returned pointer points to? The more restricted type ‘string’ from the Gtk type system can be used to be more precise. In fact, the definition of ‘string’ below includes the rule that when a ‘string’ is passed to a function, that function is not allowed to retain a pointer into the string beyond the life time of that function call. So we are safe to deallocate it or override it when the function has returned. Likewise, the definition specifies that the memory of a ‘string’ that is returned from a function becomes the sole property of the calling function. The calling function is responsible for deallocating it eventually and it can be sure that nobody else scribbles in it. When ‘gtk_foo’ really obeys these rules, we can say that it takes one argument, which is a ‘string’, and it returns a ‘string’.

Now we can understand why it makes sense to have a more restrictive type system than that of C. With it, it is possible to be more precise and we actually have a framework where we can be sure that as long as we stay inside this framework we are not gratuitously causing trouble for languages that are more disciplined than C. Of course, you are not restricted to making all your interfaces expressible within the framework. There are valid reasons for breaking it, for performance or simply for convenience. But please try to provide all the functionality of your module in such a way that it can be described with this type system and treat the non-conforming functions as additional goodies that are nice to have but not essential. The reward is an instant accessibility of your code from a huge number of scripting and extension languages such as Perl, Python, and Guile.

These formal specifications of the Gtk interface are contained in special declarations in the header files of Gtk. They are ignored by the C compiler, but can be used by other language processors. For extra convenience, these declarations are also available in a more condensed form that is easier to parse. Tools for generating bindings of Gtk to other languages can read these declarations and—because all the important details are defined— automatically generate the bulk of the needed glue code. It is also possible to feed these declarations into a running application (an interface builder, say) and thus make it aware of new widgets and functions without recompiling anything.

The run-time side of the type system is also somewhat introspective. This means that you can query Gtk about all the members of an enumeration for example. Gtk provides tools that help you provide this introspection for your definitions also.

Types are not enough to completely specify an interface, so GTK also has modes. A mode specifies what happens to a value when it crosses a module boundary; it can be ‘in’, ‘out’, or ‘inout’. Most fundamental types (and their derived types) support only mode ‘in’. The modes ‘out’ and ‘inout’ can only be used with the composite types: lists and vectors. When argument of these types are marked as ‘out’ or ‘inout’ it means that the called module is allowed to change the contents of the composite value and that these changes need to be propagated back to the originator of the value. Mode ‘out’ means that the argument has no meaningful value at the beginning and should not be read. Mode ‘in’ specifies that the called module is not allowed to change the value in any way.

The type system allows for an unbounded number of types. Every widget is a type for example and you can add new widget types at any time without confusing the runtime implementation of the type system. Nevertheless, all types are derived from a certain fundamental type, and there are only a small and finite number of fundamental types. We only specify rules for the fundamental types and all other types inherit these rules from their fundamental type. For example, ‘int’ is a fundamental type, as is ‘GtkObject’. All widgets derive from ‘GtkObject’ and so the rules for ‘GtkObject’ apply to all widgets as well.

This derivation defines a type hierarchy, but this hierarchy is not completely general. You can’t derive from ‘int’ for example, and you can only have one level of derivation from ‘enum’. The fundamental type ‘GtkObject’, however, is the basis for the large and deep hierarchy of widget types.

The individual fundamental types are defined and explained in the following sections. Here is a complete list of them:

‘none’ The not-a-value type, similar to ‘void’.

‘char’ A character. Internationalization issues are still undecided.

‘bool’ True or false.

‘byte, ubyte, int, uint, long, ulong, float, double’

The usual assortment of scalar types.

‘string’ A string. Internationalization issues are still undecided.

‘enum, flags’

Enumerations with a fixed set of literals. Either used to express a single choice from this set or to individually turn on and off several flags.

‘boxed’ A pointer to an opaque structure that can be copied and destroyed.

‘callback’

A pointer to a function with enough extra information so that it can also be used for functions written in languages completely different from C.

‘GtkObject’

A pointer to a GtkObject or derived type. The fun starts here.

‘args, slist, dlist, cvec, tvec’

An assortment of composite types like linked lists and counted or zeroterminated arrays.

‘pointer, signal, c_callback’

Obsolete types.

3.2 Basic Concepts

The basis for the type system are the fundamental types. At run-time, they are represented by members of the GtkFundamentalType enumeration. For the static declarations, they are identified with a unique name.

Enumeration GtkFundamentalType

This enumeration contains a member for each defined fundamental type. Most members are listed along with the description of their semantics, but one is listed here:

     GTK_TYPE_INVALID

No valid type is derived from this. Use GTK_TYPE_INVALID to express exceptional situations. This member does not really correspond to a fundamental type and thus there is no name for it.

Data type GtkType

The type GtkType holds the run-time representation of a type. It is an integer of a certain size. The follwing macros are defined to access the basic properties of a

GtkType:
Macro unsigned int GTK TYPE SEQNO (GtkType type)

Returns the sequence number of type. The sequence numbers are guaranteed to be dense, i.e., you can use them to index a table and the table need not be much larger than the number of different GtkTypes that you might encounter.

Macro GtkFundamentalType GTK FUNDAMENTAL TYPE

         (GtkType type)

Returns the fundamental type of type.

Both macros simply access different bit-fields of a GtkType, so they are very efficient.

New types are registered with the gtk_type_unique function. Any kind oftype can be registered with gtk_type_unique but there are convenience functions for most fundamental types. Each fundamental type has its own interpretation of the rules below and these convenience functions should be used to automatically get the type registration right. So, don’t be put off by the apparent complexity of the interface to gtk_type_unique. You will be using it only for new widgets, and there the rules are simple.

The GtkTypeInfo structure is used to communicate information to gtk_type_unique as opposed to passing in large numbers of parameters.

typedef struct _GtkTypeInfo GtkTypeInfo;
struct _GtkTypeInfo
{
  gchar *type_name;
  guint object_size;
  guint class_size;
  GtkClassInitFunc class_init_func;
  GtkObjectInitFunc object_init_func;
  gpointer reserved_1;
  gpointer reserved_2;
  GtkClassInitFunc base_class_init_func;
}

• The type_name field refers to the name of the type. This is the same name that is used in the static definitions. It is convention for the type name to be closely related to the name of the underlying C type. For example, the type name of the GtkObject structure is “GtkObject”, and the name of the GtkWindowType enumeration is “GtkWindowType”. Note that the C type corresponding to “GtkObject” is really a pointer to a GtkObject struct, but the name has no “*” in it.

• The object_size field refers to the size in bytes of the C structure for types that have such a structure. The easiest (and portable) means of computing this size is by using the C sizeof operator. For instance, the sizeof of the GtkObject structure is computed by doing sizeof (GtkObject). When the type has no associated structure or when you do not want to support the gtk_type_new function for the new type, set object_size to 0. Only types derived from GTK TYPE OBJECT can be handled by

gtk_type_new, anyway.

• The class_size field refers to the size in bytes of the C structure for the class. Again, the sizeof operator should be used to compute this value. If you don’t want to have a class structure for this type, set the field to 0. gtk_type_class will then always return

NULL.

• The class_init_func and base_class_init_func fields are callbacks which are used by the type mechanism to initialize class specific fields. The single argument these functions take is a pointer to a class structure. When you do not need one or both of them, set the corresponding field to NULL. The class_init_func will be called at most once, right after the class structure of size class_size has been allocated. The interaction between class_init_func and base_class_init_func is only really useful for the full-fledged object system. It is described there see Chapter 4 [Objects], page 15.

• The object_init_func field is a callback which is used by the type mechanism to initialize object specific fields for structures that have been allocated via gtk_type_ new. The single argument this functions takes is a pointer to an object structure. If you do not want any special object initialization to take place, set this to NULL. All object initialization functions for all types that are part of the inheritance chain are called, starting with the most basic type.

Function guint gtk type unique (GtkType parent type, GtkTypeInfo

*type info) The parent type is simply the new types parent type. If parent type is GTK TYPE INVALID, then the new type is a new fundamental type. You should never register new fundamental types. type info is a pointer to a structure which contains necessary information for construction of the new type. You can only register a specific name once.

Function gchar* gtk type name (GtkType type)

The returned string is the name of type as specified to gtk_type_unique.

Function GtkType gtk type from name (guchar *name)

Return the type associated with name. If there is no type associated with name, then GTK TYPE INVALID will be returned.

Function GtkType gtk type parent (GtkType type)

Returns the parent type of type or GTK TYPE INVALID if type is a fundamental type.

Function gpointer gtk type class (GtkType type)

Returns the initialized class structure for type. The class structure is actually created and initialized the first time it is needed. Refer to see Chapter 4 [Objects], page 15 for details on how this initialization works for GTK TYPE OBJECT derived types. The returned structure is shared by all objects of type and, as such, should not be modified.

Function gpointer gtk type new (GtkType type)

Returns a new instance of an type object. This works only for GTK TYPE OBJECT derived types. Please see see Chapter 4 [Objects], page 15.

Function void gtk type describe heritage (GtkType type)

Prints the type heritage for type. The heritage for a type includes the type and all its parent types up the type tree.

Function void gtk type describe tree (GtkType type, gboolean show size)

Prints the type tree which starts at type. show size is a boolean which determines whether type sizes are printed.

Function gboolean gtk type is a (GtkType type, GtkType is a type)

A predicate function which determines whether the relation type is a is a type is true.

Values of all types can be handled uniformly by storing them into a GtkArg structure. The GtkArg has the following fields:

gchar *name

This can be used to give the value represented by this GtkArg structure a name. It is not used much.

GtkType type

The type of this value.

union d A big union that has (at least conceptually) one member for each fundamental type. You should not access these members directly. Rather, use the GTK_ VALUE_* macros. There is one macro for each fundamental type, and its name is derived from the name of the GtkFundamentalType enumeration members simply by replacing “Gtk TYPE” with “GTK VALUE”. All GTK_VALUE_* macros take a GtkArg structure as their only parameter (not a pointer) and evaluate to a lvalue.

For example, the accessor for the fundamental type GTK TYPE INT is called GTK VALUE INT and you could use it like this:

     GtkArg value;
     value.name = NULL;
     value.type = GTK_TYPE_INT;
     GTK_VALUE_INT(value) = 7;

3.3 Simple Types

The Gtk type system has a full set of the usual simple types: integers, floating point numbers, but also boolean and character. You can not derive new types from these.

Enum  Name  Description
GTK TYPE NONE  "void"  A type without value.

GTK TYPE CHAR "char" A 8-bit unsigned number representing a character. Numbers between 0 and 127 are ASCII, the rest is undefined.

GTK TYPE BOOL "gboolean" The boolean type. It is some small integer where the number 0 represents false and 1 is true. No other values are allowed.

GTK TYPE INT  "gint"  A signed integer with at least 32 bits.
GTK TYPE UINT  "guint"  A unsigned integer with at least 32 bits.
GTK TYPE LONG  "glong"  A signed integer with at least 32 bits.

GTK TYPE ULONG "gulong" A unsigned integer with at least 32 bits. This is large enough to hold a coerced pointer.

GTK TYPE FLOAT "gfloat" A single precision floating point number.

GTK TYPE DOUBLE "gfloat" A souble precision floating point number.

GTK TYPE POINTER "gpointer" A untyped pointer. Do not use this if you can avoid it.

The values of these types are all represented ‘directly’ with the C types that are indicated in the ‘name’ column above. see Section 3.6 [Boxed types], page 13 for a discussion of this.

3.4 Enumerations and Flags

3.5 Strings

3.6 Boxed Types

3.7 Callbacks

3.8 Composite Types

14 GTK

4 Objects

4.1 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 Chapter 10 [Object Implementation], page 149.

Function guint gtk object get type (void)

Returns the GtkObject type identifier.

Function void gtk object class add signals (GtkObjectClass *class, gint

*signals, gint nsignals) Adds signals to the signals field in the GtkObjectClass structure class. See Chapter 5 [Signals], page 19.

Function GtkObject* gtk object new (guint type, ...)

Function GtkObject* gtk object newv (guint type, guint nargs, GtkArg *args)

Function void gtk object ref (GtkObject *object);

Function void gtk object unref (GtkObject *object);

Function void gtk object getv (GtkObject *object, guint nargs, GtkArg *args)

Function void gtk object set (GtkObject *object, ...)

Function void gtk object setv (GtkObject *object, guint nargs, GtkArg *args)

Function GtkArg* gtk object query args (GtkType class type, guint *nargs)

Function void gtk object add arg type (gchar *arg name, GtkType

arg type, guint arg id)

Function GtkType gtk object get arg type (gchar *arg name)

Function void gtk object destroy (GtkObject *object)

Performs checks to make sure it is alright to destroy object and then emits the destroy signal. The check which is performed is to make sure 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 object is processing another signal we mark object is needing to be destroyed. When we finish processing of the other signal we check whether the object needs to be destroyed.

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 gtk_object_set_data, gtk_object_get_data, and gtk_object_remove_data

are the interface to this mechanism. Two other routines, gtk_object_set_user_data and gtk_object_get_user_data, exist as convenience functions which simply use the same mechanism.

Function void gtk object set data (GtkObject *object, const char *key,

         gpointer data)

Associate data with key in the data list of object.

Function gpointer gtk object get data (GtkObject *object, const char

*key) Retrieve the data associated with key in the data list of object.

Function void gtk object remove data (GtkObject *object, const char

*key) Remove the data associated with key in the data list of object.

Function void gtk object set user data (GtkObject *object, gpointer data)

Sets data into the user_data field of object.

Function gpointer gtk object get user data (GtkObject *object)

Returns the user_data field of object.

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

Function void gtk object value stack new (guint object type, const gchar *value id, GtkParamType value type)

Function void gtk object push value (guint object type, const gchar

*value id, ...) Push a value on the value stack specified by object type and value id. The type of value is implicitly given in the context of object type and 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.

Function void gtk object pop value (guint object type, const gchar

*value id) Pop a value of the value stack specified by object type and value id.

Function gint gtk object peek value (guint object type, const gchar

*value id, gpointer data) Peek at the value on the top of the value stack specified by object type and value id. The data argument is interpreted as the location of where to place the “peeked” data. For instance, if the peeked data is of type GTK_PARAM_POINTER, then data will be a pointer to a pointer. If the value stack is empty or does not exist or an error occurs, gtk_object_peek_value will return FALSE. On success it will return TRUE.

18 GTK

5 Signals Overview

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.

Function gint gtk signal new (gchar *name, GtkSignalRunType run type, gint object type, gint function offset, GtkSignalMarshaller marshaller,

         GtkParamType return val, gint nparams, ...)

Create a new signal and give it the character string identifier name. name needs to be unique in the context of object type’s branch of the class hierarchy. That is, object type cannot create a signal type with the same name as a signal type created by one of its parent types.

run type specifies whether the class function should be run before (GTK_RUN_FIRST), after (GTK_RUN_LAST) or both before and after normal signal handlers (GTK_RUN_ BOTH). Additionally, the 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 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 GTK_RUN_NO_RECURSE flag is used by the GtkAdjustment widget).

The 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 GTK_SIGNAL_OFFSET macro which takes the class structure type as the first argument and the field as the second argument. For example, GTK_SIGNAL_OFFSET (GtkObjectClass, destroy) will give the offset of the destroy class function within the GtkObjectClass. Note: An offset is specified instead of an absolute location since there will be multiple instances of a class structure being referenced. (The GtkWidgetClass structure “is a” GtkObjectClass structure, etc.) The 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 return val and 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 (…) specifies the types of the arguments. These can be

one of GTK_PARAM_CHAR, GTK_PARAM_SHORT, GTK_PARAM_INT, GTK_PARAM_LONG, GTK_
PARAM_POINTER or GTK_PARAM_FUNCTION. It is undefined to specify GTK_PARAM_NONE

as an argument type, however it is OK to use GTK_PARAM_NONE for return val. (This corresponds to returning a void). 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. Note: gtk_signal_new is only needed by widget writers. A normal user of GTK will never needed to invoke this function.

Function gint gtk signal lookup (gchar *name, gint object type)

Returns the integer identifier for the signal referenced by name and object type. If object type does not define the signal name, then the signal is looked for in object type’s parent type recursively.

Function gchar* gtk signal name (gint signal num)

Function gint gtk signal emit (GtkObject *object, gint signal type, ...)

Emit the signal specified by the integer identifier signal type from object. If an error occurs, gtk_signal_emit will return FALSE and will return TRUE on success. The signal definition determines the parameters passed in the variable argument list (...). For example, if the signal is defined as:

       gint (* event) (GtkWidget *widget, GdkEvent *event);

Then a call to emit the “event” signal would look like:

       GdkEvent event;
       gint return_val;
       ...
       gtk_signal_emit (some_object,
                        gtk_signal_lookup ("event",
                          GTK_OBJECT_TYPE (some_object)),
                        &event, &return_val);

Notice that the widget argument is implicit in that the first argument to every signal is a type derived from GtkObject. The 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 gtk_signal_lookup call is normally

avoided by using the gtk_signal_emit_by_name function instead. 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 gtk_signal_lookup.

Function gint gtk signal emit by name (GtkObject *object, gchar *name,

    ...)

Similar to gtk_signal_emit except that the signal is referenced by name instead of by its integer identifier.

Function void gtk signal emit stop (GtkObject *object, gint signal type)

Stop the emission of the signal signal type on object. signal type is the integer identifier for the signal and can be determined using the function gtk_signal_lookup. Alternatively, the function 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.

Function void gtk signal emit stop by name (GtkObject *object, gchar

*name) Similar to gtk_signal_emit_stop except that the signal is referenced by name instead of by its integer identifier.

Function gint gtk signal connect (GtkObject *object, gchar *name,

    GtkSignalFunc func, gpointer func data)

Connects a signal handling function to a signal emitting object. func is connected to the signal name emitted by object. The arguments and returns type of func should match the arguments and return type of the signal name. However, func may take the extra argument of 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). 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.

Function gint gtk signal connect after (GtkObject *object, gchar *name,

    GtkSignalFunc func, gpointer func data)

Similar to 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 gtk_signal_connect, gtk_signal_connect_after returns an integer identifier

which can be used to refer to the connection.

Function gint gtk signal connect object (GtkObject *object, gchar *name,

    GtkSignalFunc func, GtkObject *slot object)

Connects func to the signal name emitted by object. Similar to gtk_signal_connect with the difference that slot object is passed as the first parameter to 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.

Function gint gtk signal connect object after (GtkObject *object, gchar

    *name, GtkSignalFunc func, GtkObject *slot object)

Similar to 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.

Function gint gtk signal connect interp (GtkObject *object, gchar *name,

    GtkCallbackMarshal func, gpointer data, GtkDestroyNotify destroy func,

gint after)

Function void gtk signal disconnect (GtkObject *object, gint id)

Disconnects a signal handler from an object. The signal handler is identified by the integer id which is returned by the gtk_signal_connect* family of functions.

Function void gtk signal disconnect by data (GtkObject *object,

    gpointer data)

Disconnects a signal handler from an object. The signal handler is identified by the data argument specified as the func data argument to the gtk_signal_connect* family of functions. For the gtk_signal_connect_object* functions, data refers to the slot object. Note: This will remove all signal handlers connected to object which were connected using data as their func data argument. Multiple signal handlers may be disconnected with this call.

Function void gtk signal handler block (GtkObject *object, gint id)

Blocks calling of a signal handler during signal emission. The signal handler is identified by the integer id which is returned by the gtk_signal_connect* family of functions. If the signal is already blocked no change is made.

Function void gtk signal handler block by data (GtkObject *object, gint

data) Blocks calling of a signal handler during signal emission. The signal handler is identified by the data argument specified as the func data argument to the gtk_signal_ connect* family of functions. For the gtk_signal_connect_object* functions, data refers to the slot object. If the signal is already blocked no change is made.

Note: This will block all signal handlers connected to object which were connected using data as their func data argument. Multiple signal handlers may be blocked with this call.

Function void gtk signal handler unblock (GtkObject *object, gint id)

Unblocks calling of a signal handler during signal emission. The signal handler is identified by the integer id which is returned by the gtk_signal_connect* family of functions. If the signal is already unblocked no change is made.

Function void gtk signal handler unblock by data (GtkObject *object,

gint data) Unblocks calling of a signal handler during signal emission. The signal handler is identified by the data argument specified as the func data argument to the gtk_signal_ connect* family of functions. For the gtk_signal_connect_object* functions, data refers to the slot object. If the signal is already unblocked no change is made. Note: This will unblock all signal handlers connected to object which were connected using data as their func data argument. Multiple signal handlers may be unblocked with this call.

Function void gtk signal handlers destroy (GtkObject *object)

Destroy all of the signal handlers connected to object. There should normally never be reason to call this function as it is called automatically when object is destroyed.

Function void gtk signal default marshaller (GtkObject *object,

    GtkSignalFunc func, gpointer func data, GtkSignalParam *params)

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:

       (* std_signal) (gpointer std_arg);

gtk_signal_default_marshaller is a signal marshaller which marshals arguments for a signal of that form.

Function void gtk signal set funcs (GtkSignalMarshal marshal func,

    GtkSignalDestroy destroy fun)

24 GTK

6 Widget Overview

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 Gtk-Widget structure, but often have contain additional information. See Chapter 10 [Object Implementation], page 149.

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

6.1 The alignment widget

6.1.1 Description

The alignment widget is a container (see Section 6.13 [GtkContainer], page 49) derived from the bin widget (see Section 6.4 [GtkBin], page 30). 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. (see Section 6.13 [GtkContainer], page 49 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.

6.1.2 Options

User Option xscale User Option yscale

The xscale and 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.

User Option xalign User Option yalign

The xalign and yalign options specify how to position the child widget when it is not allocated all the space available to it (because the xscale and/or 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 xalign and yalign to be 0.5 which causes the widget to be centered within its allocated area.

6.1.3 Signals

6.1.4 Functions

Function guint gtk alignment get type (void)

Returns the GtkAlignment type identifier.

Function GtkWidget* gtk alignment new (gfloat xalign, gfloat yalign,

    gfloat xscale, gfloat yscale)

Create a new GtkAlignment object and initialize it with the values xalign, yalign, xscale and yscale. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk alignment set (GtkAlignment *alignment, gfloat xalign,

    gfloat yalign, gfloat xscale, gfloat yscale)

Set the xalign, yalign, xscale and yscale options of an alignment widget. It is important to not set the fields of the GtkAlignment structure directly (or, for that matter, any type derived from GtkObject).

Function GtkAlignment* GTK ALIGNMENT (gpointer obj)

Cast a generic pointer to GtkAlignment*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkAlignmentClass* GTK ALIGNMENT CLASS (gpointer

class) Cast a generic pointer to GtkAlignmentClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS ALIGNMENT (gpointer obj)

Determine if a generic pointer refers to a GtkAlignment object. See Section 8.7 [Standard Macros], page 143, for more info.

6.2 The arrow widget

6.2.1 Description

The arrow widget is derived from the misc widget (see Section 6.42 [GtkMisc], page 84) 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.

6.2.2 Options

User Option arrow type

The arrow type option specifies which direction the arrow will point. It can be one of

GTK_ARROW_UP, GTK_ARROW_DOWN, GTK_ARROW_LEFT or GTK_ARROW_RIGHT. This will

set the arrow pointing in the direction specified.

User Option shadow type

The shadow type option specifies how to draw the shadow for the arrow. Currently, only the GTK_SHADOW_IN and GTK_SHADOW_OUT shadow types are supported for drawing arrows. Other shadow types will cause nothing to be drawn.

6.2.3 Signals

6.2.4 Functions

Function guint gtk arrow get type (void)

Returns the GtkArrow type identifier.

Function GtkWidget* gtk arrow new (GtkArrowType arrow type,

    GtkShadowType shadow type)

Create a new GtkArrow object and initialize it with the values arrow type and shadow type. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk arrow set (GtkArrow *arrow, GtkArrowType arrow type,

    GtkShadowType shadow type)

Set the arrow type and shadow type options of an arrow widget. It is important to not set the fields of the GtkArrow structure directly (or, for that matter, any type derived from GtkObject).

Function GtkArrow* GTK ARROW (gpointer obj)

Cast a generic pointer to GtkArrow*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkArrowClass* GTK ARROW CLASS (gpointer class)

Cast a generic pointer to GtkArrowClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS ARROW (gpointer obj)

Determine if a generic pointer refers to a GtkArrow object. See Section 8.7 [Standard Macros], page 143, for more info.

6.3 The aspect frame widget

6.3.1 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 see Section 6.23 [GtkFrame], page 63).

6.3.2 Options

User Option label

User Option xalign

User Option yalign

User Option ratio

User Option obey child

6.3.3 Signals

6.3.4 Functions

Function guint gtk aspect frame get type (void)

Returns the GtkAspectFrame type identifier.

Function GtkWidget* gtk aspect frame new (gchar *label, gfloat xalign,

gfloat yalign, gfloat ratio, gint obey child) Create a new GtkAspectFrame object and initialize it with the values label, xalign, yalign, ratio and obey child. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk aspect frame set (GtkAspectFrame *aspect frame, gfloat xalign, gfloat yalign, gfloat ratio, gint obey child)

Function GtkAspectFrame* GTK ASPECT FRAME (gpointer obj)

Cast a generic pointer to GtkAspectFrame*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkAspectFrameClass* GTK ASPECT FRAME CLASS

    (gpointer class)

Cast a generic pointer to GtkAspectFrameClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS ASPECT FRAME (gpointer obj)

Determine if a generic pointer refers to a GtkAspectFrame object. See Section 8.7 [Standard Macros], page 143, for more info.

6.4 The bin widget

6.4.1 Description

The bin widget is a container (see Section 6.13 [GtkContainer], page 49) 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 (see Section 6.1 [GtkAlignment], page 25), frames (see Section 6.23 [GtkFrame], page 63), items (see Section 6.34 [GtkItem], page 74), viewports (see Section 6.67 [GtkViewport], page 116) and windows (see Section 6.74 [GtkWindow], page 127)

6.4.2 Options

6.4.3 Signals

6.4.4 Functions

Function guint gtk bin get type (void)

Returns the GtkBin type identifier.

Function GtkBin* GTK BIN (gpointer obj)

Cast a generic pointer to GtkBin*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkBinClass* GTK BIN CLASS (gpointer class)

Cast a generic pointer to GtkBinClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS BIN (gpointer obj)

Determine if a generic pointer refers to a GtkBin object. See Section 8.7 [Standard Macros], page 143, for more info.

6.5 The box widget

6.5.1 Description

The box widget is a container (see Section 6.13 [GtkContainer], page 49) derived from the container widget. It is an abstract base class used by the horizontal box (see Section 6.25 [GtkHBox], page 65), the vertical box (see Section 6.65 [GtkVBox], page 114) and the (see Section 6.6 [GtkButtonBox], page 34) 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 (see Section 6.1 [GtkAlignment], page 25) 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 expand and fill. There operation is fairly simple. If expand is set, the child’s potentially allocated area will expand to fill available space. If 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 gtk_widget_size_allocate).

The allocation of space to children occurs as follows (for horizontal boxes):

1. All children are allocated at least their requested size horizontally and the maximum requested child size vertically.

2. Any child with the expand flag set is allocated extra_width / nexpand_children extra pixels horizontally. If the homogeneous flag was set, all children are considered to have the 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 expand flag set). The exception occurs when extra_width / nexpand_children does not divide cleanly. The extra space is given to the last widget.

3. 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 padding value associated with each child causes that many pixels to be left empty to each side of the child.

4. If a child has the 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.

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

See Section 6.25 [GtkHBox], page 65, and Section 6.65 [GtkVBox], page 114, for code examples of using horizontal and vertical boxes.

6.5.2 Options

User Option expand

User Option fill

User Option padding

User Option expand

6.5.3 Signals

6.5.4 Functions

Function guint gtk box get type (void)

Returns the GtkBox type identifier.

Function void gtk box pack start (GtkBox *box, GtkWidget *child, gint

expand, gint fill, gint padding) Add child to the front of box. The flags expand and fill and the padding value of padding are associated with child.

Function void gtk box pack end (GtkBox *box, GtkWidget *child, gint

expand, gint fill, gint padding) Add child to the end of box. The flags expand and fill and the padding value of padding are associated with child.

Function void gtk box pack start defaults (GtkBox *box, GtkWidget

*widget) A convenience function which is equivalent to the following:

       gtk_box_pack_start (box, widget, TRUE, TRUE, 0);

Function void gtk box pack end defaults (GtkBox *box, GtkWidget

*widget) A convenience function which is equivalent to the following:

       gtk_box_pack_start (box, widget, TRUE, TRUE, 0);

Function void gtk box set homogeneous (GtkBox *box, gint homogeneous)

Set the homogeneous setting of this box to homogeneous.

Function void gtk box set spacing (GtkBox *box, gint spacing)

Function void gtk box reorder child (GtkBox *box, GtkWidget *child, guint pos)

Function void gtk box query child packing (GtkBox *box, GtkWidget

    *child, gint *expand, gint *fill, gint *padding, GtkPackType *pack type)

Function void gtk box set child packing (GtkBox *box, GtkWidget *child,

    gint expand, gint fill, gint padding, GtkPackType *pack type)

Function GtkBox* GTK BOX (gpointer obj)

Cast a generic pointer to GtkBox*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkBoxClass* GTK BOX CLASS (gpointer class)

Cast a generic pointer to GtkBoxClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS BOX (gpointer obj)

Determine if a generic pointer refers to a GtkBox object. See Section 8.7 [Standard Macros], page 143, for more info.

6.6 The button box widget

6.6.1 Description

The button box widget is a container (see Section 6.13 [GtkContainer], page 49) derived from the (see Section 6.5 [GtkBox], page 31) widget. It is an abstract base class used by the horizontal button box (see Section 6.26 [GtkHButtonBox], page 66) and the vertical button box (see Section 6.66 [GtkVButtonBox], page 115) widgets to provide a base of common functionality.

The button box, like the box widget, (see Section 6.5 [GtkBox], page 31) provides an abstraction for organizing position and size of widgets. In the case of the button box it is targeted at the button widget,(see Section 6.7 [GtkButton], page 37). 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.

6.6.2 Options

User Option layout style

          • GTK_BUTTONBOX_SPREAD

• The layout style 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 gtk_button_box_set_spacing function will set the minimum space that the buttons will leave between themselves.

          • GTK_BUTTONBOX_EDGE

•

          • GTK_BUTTONBOX_START

• The layout style GTK_BUTTONBOX_START will place the buttons at the start of the button box, taking into account the spacing as set by the gtk_button_box_ set_spacing function. The buttons will not move when the parent window is re-sized.

          • GTK_BUTTONBOX_END

• The layout style GTK_BUTTONBOX_END will place the buttons at the end of the button box, taking into account the spacing as set by the gtk_button_box_set_ spacing function. Again like the GTK_BUTTONBOX_START layout style the buttons will not move when the parent window is re-sized.

User Option width

User Option height

User Option ipad x User Option ipad y

6.6.3 Signals

6.6.4 Functions

Function guint gtk button box get type (void)

Returns the GtkButtonBox type identifier.

Function void gtk button box set child size default (gint width,

gintheight)

Function void gtk button box set child ipadding default (gint ipad x,

gint ipad y)

Function void gtk button box get child size default (gint *width, gint

*height)

Function void gtk button box get child ipadding default (gint *ipad x,

gint *ipad y)

Function void gtk button box set child size (GtkButtonBox *widget, gint

width, gint height)

Function void gtk button box set child ipadding (GtkButtonBox *widget,

gint ipad x, gint ipad y)

Function void gtk button box set layout (GtkButtonBox *widget, gint

layout style) This will set the layout style of the buttons within this box. Currently it can be set

to one of GTK_BUTTONBOX_SPREAD, GTK_BUTTONBOX_EDGE, GTK_BUTTONBOX_START or
GTK_BUTTONBOX_END.

The following example:

         gtk_button_box_set_layout (GTK_BUTTON_BOX (box),
                                    GTK_BUTTONBOX_SPREAD);

Will set the box argument to the SPREAD layout style described above.

Function gint gtk button box get spacing (GtkButtonBox *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.

Function void gtk button box get child size (GtkButtonBox *widget, gint

*width, gint *height)

Function void gtk button box get child ipadding (GtkButtonBox *widget,

    gint *ipad x, gint *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.

Function gint gtk button box get layout (GtkButtonBox *widget)

Get the layout style for the GtkButtonBox object passed to this function in the widget variable.

        layout = gtk_button_box_get_layout(GTK_BUTTON_BOX (box));

Function GtkButtonBox* GTK BUTTON BOX (gpointer obj)

Cast a generic pointer to GtkButtonBox*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkButtonBoxClass* GTK BUTTON BOX CLASS (gpointer

class) Cast a generic pointer to GtkButtonBoxClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS BUTTON BOX (gpointer obj)

Determine if a generic pointer refers to a GtkButtonBox object. See Section 8.7 [Standard Macros], page 143, for more info.

6.7 The button widget

6.7.1 Description

A pressable button. Contains a widget. Changes its appearance (hilites) when it gets the focus. Changes its appearance (pressed) when activated. Derived from see Section 6.13 [GtkContainer], page 49.

6.7.2 Signals

Signal void GtkButton::pressed (GtkButton *button)

Signal void GtkButton::released (GtkButton *button)

Signal void GtkButton::clicked (GtkButton *button)

Signal void GtkButton::enter (GtkButton *button)

Signal void GtkButton::leave (GtkButton *button)

6.7.3 Functions

Function guint gtk button get type (void)

Returns the GtkButton type identifier.

Function GtkWidget* gtk button new (void)

Create a new GtkButton object. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk button new with label (gchar *label)

Create a new GtkButton object and set the text that is on the button to label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk button pressed (GtkButton *button)

Function void gtk button released (GtkButton *button)

Function void gtk button clicked (GtkButton *button)

Function void gtk button enter (GtkButton *button)

Function void gtk button leave (GtkButton *button)

Function GtkButton* GTK BUTTON (gpointer obj)

Cast a generic pointer to GtkButton*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkButtonClass* GTK BUTTON CLASS (gpointer class)

Cast a generic pointer to GtkButtonClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS BUTTON (gpointer obj)

Determine if a generic pointer refers to a GtkButton object. See Section 8.7 [Standard Macros], page 143, for more info.

6.8 The check button widget

6.8.1 Description

Another form of toggle button (see Section 6.60 [GtkToggleButton], page 106) with an indicator. Contains a widget to the right of the indicator. Changes its appearance (hilites) when it gets the focus.

6.8.2 Options

6.8.3 Signals

6.8.4 Functions

Function guint gtk check button get type (void)

Returns the GtkCheckButton type identifier.

Function GtkWidget* gtk check button new (void)

Create a new GtkCheckButton object and initialize it with the default values in the library. The new widget is returned as a pointer to a GtkWidget object. A NULL is returned on failure.

Function GtkWidget* gtk check button new with label (gchar *label)

Create a new GtkCheckButton object and initialize it with the values label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on any failure.

Function GtkCheckButton* GTK CHECK BUTTON (gpointer obj)

Function GtkCheckButtonClass* GTK CHECK BUTTON CLASS

    (gpointer class)

Function gint GTK IS CHECK BUTTON (gpointer obj)

Function GtkCheckButton* GTK CHECK BUTTON (gpointer obj)

Cast a generic pointer to GtkCheckButton*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkCheckButtonClass* GTK CHECK BUTTON CLASS

    (gpointer class)

Cast a generic pointer to GtkCheckButtonClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS CHECK BUTTON (gpointer obj)

Determine if a generic pointer refers to a GtkCheckButton object. See Section 8.7 [Standard Macros], page 143, for more info.

6.9 The check menu item widget

6.9.1 Description

Derived from see Section 6.40 [GtkMenuItem], page 81. Very similar to a checkbutton (see Section 6.8 [GtkCheckButton], page 39), 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.

6.9.2 Options

User Option label

User Option state

6.9.3 Signals

Signal void GtkCheckMenuItem::toggled (GtkCheckMenuItem

*check menu item)

6.9.4 Functions

Function guint gtk check menu item get type (void)

Returns the GtkCheckMenuItem type identifier.

Function GtkWidget* gtk check menu item new (void)

Create a new GtkCheckMenuItem object. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk check menu item new with label (gchar

*label) Create a new GtkCheckMenuItem object and initialize it with the values label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk check menu item set state (GtkCheckMenuItem

*check menu item, gint state)

Function void gtk check menu item toggled (GtkCheckMenuItem

*check menu item)

Function GtkCheckMenuItem* GTK CHECK MENU ITEM (gpointer

obj) Cast a generic pointer to GtkCheckMenuItem*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkCheckMenuItemClass*

GTK CHECK MENU ITEM CLASS (gpointer class)

Cast a generic pointer to GtkCheckMenuItemClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS CHECK MENU ITEM (gpointer obj)

Determine if a generic pointer refers to a GtkCheckMenuItem object. See Section 8.7 [Standard Macros], page 143, for more info.

6.10 The compound list widget

6.10.1 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 see Section 6.13 [GtkContainer], page 49. Cells can be empty, have a text and/or pixmap, or be a widget.

6.10.2 Options

6.10.3 Signals

6.10.4 Functions

Function guint gtk clist get type (void)

Returns the GtkCList type identifier.

Function GtkWidget* gtk clist new (int columns)

Create a new GtkCList initializing it with the value columns. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk clist new with titles (int columns, gchar

*titles[])

Function void gtk clist set border (GtkCList *clist, GtkShadowType border)

Set the border style of the clist to the shadow type border.

Function void gtk clist set selection mode (GtkCList *clist

    GtkSelectionMode mode)

Set the selection mode on the clist to the mode selection mode.

Function void gtk clist set policy (GtkCList *clist, GtkPolicyType

vscrollbar policy, GtkPolicyType hscrollbar policy) Set the policy on the scrollbars on the clist to vscrollbar policy and hscrollbar policy.

Function void gtk clist freeze (GtkCList *clist)

Stop all visual updates of the clist. Useful for when making a large number of changes

to a GtkCList.

Function void gtk clist thaw (GtkCList *clist)

Allow all visual updates of the clist to resume.

Function void gtk clist column titles show (GtkCList *clist)

Show the column title buttons on the clist.

Function void gtk clist column titles hide (GtkCList *clist)

Hide the column title buttons on the clist.

Function void gtk clist set column title (GtkCList *clist, gint column,

    gchar *title)

Set the title in column column of the clist button to title.

Function void gtk clist set column widget (GtkCList *clist, gint column,

    GtkWidget *widget)

Set the widget instead of the title button for the column column in the clist.

Function void gtk clist set column justification (GtkCList *clist, gint

column, GtkJustification justification) Set the column’s justification, in the clist to justification.

Function void gtk clist set column width (GtkCList *clist, gint column,

gint width) Set the pixel width of column column in the GtkCList clist to width. This function is a necessary step in creating a GtkCList because otherwise the column width is chosen from the width of the column title, which is almost never correct.

Function void gtk clist set row height (GtkCList *clist, gint height)

Change the height of the rows in the clist to height. The default is the height of the current font.

Function void gtk clist moveto (GtkCList *clist, gint row, gintcolumn,

gfloat row align, gfloat col align) Scroll the viewing area of the GtkClist in clist to column and row. The row align and col align are between zero and one, representing the location the row should appear on screen. Setting row align or the col align to 0.0 will be the top or left of the viewing area. Setting the row align or col align to 1.0 will be the bottom or right of the viewing area. If the row or column is -1 then there is no change.

Function void gtk clist set text (GtkCList *clist, gint row, gint column,

    gchar *text)

Set a given cell’s text, located by the row and column, to text replacing its current contents.

Function void gtk clist set pixmap (GtkCList *clist, gint row, gint

    column, GdkPixmap *pixmap, GdkBitmap *mask)

Set a given cell’s text, located by the column and row arguments, to the pixmap described by the pixmap argument using the mask as its mask. The current contents of the cell will be replaced.

Function void gtk clist setpixtext (GtkCList *clist, gint row, gint column,

    gchar *text, guint8 spacing, GdkPixmap *pixmap, GdkBitmap *mask)

Set a given cell’s text and pixmap, located by the row and column arguments, to the text and pixmap described by the pixmap and text arguments. The mask will be used for the pixmap mask and the spacing argument specifies the spacing between the two.

Function void gtk clist set foreground (GtkCList *clist, gint row,

    GdkColor *color)

Set the foreground color of row row to color in the GtkCList clist. The color must already be allocated.

Function void gtk clist set background (GtkCList *clist, gint row,

    GdkColor *color)

Set the background color of row row to color in the GtkCList pointed to by clist. The color must be previously allocated.

Function void gtk clist set shift (GtkCList *clist, gint row, gint column,

gint vertical, gint horizontal) Set the horizontal and vertical shift for drawing the contents of the cell located at row and column. The vertical and horizontal arguments can be positive or negative.

Function gint gtk clist append (GtkCList *clist, gchar *text[])

Append the given text, in the text[] argument, to the GtkCList pointed to by the clist. The return value is the index of the row that was just added.

Function void gtk clist insert (GtkCList *clist, gint row, gchar *text[])

Insert a row into the GtkCList pointed to by clist at row row with the text in text[].

Function void gtk clist remove (GtkCList *clist, gint row)

Remove row index row from the clist.

Function void gtk clist set row data (GtkCList *clist, gint row, gpointer

data) Will set an arbitrary data pointer, data, for row row in the GtkCList pointed to by clist.

Function gpointer gtk clist get row data (GtkCList *clist, gint row)

Return the data that was set for row row from the GtkCList pointed to by clist. NULL is returned if no data was set.

Function void gtk clist select row (GtkCList *clist, gint row, gint column)

Force selection of a row, located by row and column, in the GtkCList pointed to by clist.

Function void gtk clist unselect row (GtkCList *clist, gint row, gint

column) Force the unselection of a row, located by row and column, in the GtkCList pointed to by clist.

Function void gtk clist clear (GtkCList *clist)

Clear the entire contents of the GtkCList pointed to by clist. This is much faster then removing each item separately with gtk_clist_remove.

Function GtkCList* GTK CLIST (gpointer obj)

Cast a generic pointer to GtkCList*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkCListClass* GTK CLIST CLASS (gpointer class)

Cast a generic pointer to GtkCListClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS CLIST (gpointer obj)

Determine if a generic pointer refers to a GtkCList object. See Section 8.7 [Standard Macros], page 143, for more info.

6.11 The color selector widget

6.11.1 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 see Section 6.65 [GtkVBox], page 114.

6.11.2 Options

User Option policy

• GTK UPDATE CONTINUOUS

• GTK UPDATE DISCONTINUOUS

• GTK UPDATE DELAYED

User Option color

User Option use opacity

User Option title

6.11.3 Signals

6.11.4 Functions

Function guint gtk color selection get type (void)

Returns the GtkColorSelection type identifier.

Function GtkWidget* gtk color selection new (void)

Create a new GtkColorSelection object. The new object is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk color selection set update policy (GtkColorSelection

         *colorsel, GtkUpdateType policy)

Function void gtk color selection set color (GtkColorSelection *colorsel,

         gdouble *color)

Function void gtk color selection get color (GtkColorSelection *colorsel,

         gdouble *color)

Function void gtk color selection set opacity (GtkColorSelection

*colorsel, gint use opacity)

Function guint gtk color selection dialog get type (void)

Returns the GtkColorSelection type identifier.

Function GtkWidget* gtk color selection dialog new (gchar *title)

Create a new GtkColorSelection object initializing the title bar of the resulting dialog to title. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkColorSelection* GTK COLOR SELECTION (gpointer

obj) Cast a generic pointer to GtkColorSelection*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkColorSelectionClass*

GTK COLOR SELECTION CLASS (gpointer class)

Cast a generic pointer to GtkColorSelectionClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS COLOR SELECTION (gpointer obj)

Determine if a generic pointer refers to a GtkColorSelection object. See Section 8.7 [Standard Macros], page 143, for more info.

6.12 The combo widget

6.12.1 Description

Text input box which also lets you choose from pre-defined values from a drop-down menu. Derived from see Section 6.25 [GtkHBox], page 65.

6.12.2 Options

6.12.3 Signals

6.12.4 Functions

Function guint gtk combo get type (void)

Returns the GtkCombo type identifier.

Function GtkWidget* gtk combo new (void)

Create a new GtkCombo object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk combo set value in list (GtkCombo *combo, gint val,

gint ok if empty)

Function void gtk combo set use arrows (GtkCombo *combo, gint val)

Function void gtk combo set use arrows always (GtkCombo *combo, gint

val)

Function void gtk combo set case sensitive (GtkCombo *combo, gint val)

Function void gtk combo set item string (GtkCombo *combo, GtkItem

*item, gchar *item value)

Function void gtk combo set popdown strings (GtkCombo *combo, GList

*strings)

Function GtkCombo* GTK COMBO (gpointer obj)

Cast a generic pointer to GtkCombo*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkComboClass* GTK COMBO CLASS (gpointer class)

Cast a generic pointer to GtkComboClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS COMBO (gpointer obj)

Determine if a generic pointer refers to a GtkCombo object. See Section 8.7 [Standard Macros], page 143, for more info.

6.13 The container widget

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

6.13.2 Options

User Option border width

6.13.3 Signals

Signal void GtkContainer::add (GtkContainer *container, GtkWidget *widget)

Signal void GtkContainer::remove (GtkContainer *container, GtkWidget *widget)

Signal void GtkContainer::need resize (GtkContainer *container,

         GtkWidget *widget)

Signal void GtkContainer::foreach (GtkContainer *container, GtkCallback callback, gpointer callback data)

Signal gint GtkContainer::focus (GtkContainer *container,

         GtkDirectionType direction)

6.13.4 Functions

Function guint gtk container get type (void)

Returns the GtkContainer type identifier.

Function void gtk container border width (GtkContainer *container, gint border width)

Function void gtk container add (GtkContainer *container, GtkWidget

*widget) Add widget to the container.

Function void gtk container remove (GtkContainer *container, GtkWidget

*widget) Remove widget from container.

Function void gtk container disable resize (GtkContainer *container)

Function void gtk container enable resize (GtkContainer *container)

Function void gtk container block resize (GtkContainer *container)

Function void gtk container unblock resize (GtkContainer *container)

Function gint gtk container need resize (GtkContainer *container,

    GtkWidget *widget)

Function void gtk container check resize (GtkContainer *container,

    GtkWidget *widget)

Function void gtk container foreach (GtkContainer *container, GtkCallback callback, gpointer callback data)

Function void gtk container focus (GtkContainer *container,

    GtkDirectionType direction)

Function GList* gtk container children (GtkContainer container)

Function GtkContainer* GTK CONTAINER (gpointer obj)

Cast a generic pointer to GtkContainer*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkContainerClass* GTK CONTAINER CLASS (gpointer

class) Cast a generic pointer to GtkContainerClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS CONTAINER (gpointer obj)

Determine if a generic pointer refers to a GtkContainer object. See Section 8.7 [Standard Macros], page 143, for more info.

6.14 The multi-column tree widget

6.14.1 Description

The GtkCTree widget is a multi-columned list with a designated column, the tree column, to display hierarchically-organized data. Each node is either a folder (a branch of the tree) or a leaf. Nodes can be (recursively) expanded, collapsed, (un)selected, removed, moved, sorted etc.

GtkCTree is a descendant of see Section 6.10 [GtkCList], page 42. Therefore, a cell in a column other than the tree column can only contain a string, a pixmap, both or nothing. A node in the tree column can contain a string and up to two pixmaps and masks, indicating the "folder openend" and "folder closed" status.

Compared to GtkCList, there is no concept of row numbers. Therefore, a number of GtkCList methods had to be re-implemented taking GList *node arguments instead of

gint row.

6.14.2 Options

6.14.3 Signals

Signal void GtkCTree::tree expand (GtkCTree *ctree, GList *node)

Signal void GtkCTree::tree collapse (GtkCTree *ctree, GList *node)

Signal void GtkCTree::tree move (GtkCTree *ctree, GList *node, GList *new parent, GList *new sibling)

Signal void GtkCTree::tree select row (GtkCTree *ctree, GList *row, gint column)

Signal void GtkCTree::tree unselect row (GtkCTree *ctree, GList *row,

gint column)

6.14.4 Functions

Function GtkType gtk ctree get type (void)

Returns the GtkCTree type identifier.

Function GtkWidget* gtk ctree new (gint columns, gint tree column)

Creates a new GtkCTree widget with the given number of columns and the given tree column.

On success, a pointer to the newly created widget is returned, and NULL otherwise.

Function GtkWidget* gtk ctree new with titles (gint columns, gint

tree column, gchar *titles[]) Creates a new GtkCTree widget with the given number of columns and the given tree column. The column titles are initialized to the strings of the array titles. On success, a pointer to the newly created widget is returned, and NULL otherwise.

Function GList* gtk ctree insert (GtkCTree *ctree, GList *parent, GList *sibling, gchar *text[], guint8 spacing, GdkPixmap *pixmap closed,

    GdkPixmap *mask closed, GdkPixmap *pixmap opened, GdkPixmap

*mask opened, gboolean is leaf, gboolean expanded) Inserts a new node at the given position. If parent == NULL, the node is inserted at root level. If sibling == NULL, the node is appended to the existing list of siblings. Otherwise, the node is inserted before sibling. If not NULL, the two pixmaps/masks are used to indicate the opened/closed status of the node. spacing is the number of pixels between pixmap and text. If is leaf == TRUE, the node cannot have any children. The initial expanded/collapsed status is given by expanded. On success, the pointer to the newly inserted node is returned, and NULL otherwise.

Function void gtk ctree remove (GtkCTree *ctree, GList *node)

Removes the given node and all its children.

Function void gtk ctree clear (GtkCTree *ctree)

Removes all nodes of ctree.

Function void gtk ctree post recursive (GtkCTree *ctree, GList *node,

    GtkCTreeFunc func, gpointer data)

Apply func to node and all its children, traversing ctree in post-order.

Function void gtk ctree pre recursive (GtkCTree *ctree, GList *node,

    GtkCTreeFunc func, gpointer data)

Apply func to node and all its children, traversing ctree in pre-order.

Function gboolean gtk ctree is visible (GtkCTree *ctree, GList *node)

Returns the visibility status of the given node. A node is said to be visible if in the chain of parent nodes every node is expanded. Or : the node is currently being displayed (but not necessarily inside the viewing area).

Function GtkCTree* GTK CTREE (gpointer obj)

Cast a generic pointer to GtkCTree*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkCTreeClass* GTK CTREE CLASS (gpointer class)

Cast a generic pointer to GtkCTreeClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS CTREE (gpointer obj)

Determine if a generic pointer refers to a GtkCTree object. See Section 8.7 [Standard Macros], page 143, for more info.

6.15 The curve widget

6.15.1 Description

Derived from see Section 6.18 [GtkDrawingArea], page 57.

6.15.2 Options

User Option type

• GTK CURVE TYPE LINEAR

• GTK CURVE TYPE SPLINE

• GTK CURVE TYPE FREE

6.15.3 Signals

6.15.4 Functions

Function guint gtk curve get type (void)

Returns the GtkCurve type identifier.

Function GtkWidget* gtk curve new (void)

Create a new GtkCurve returning the new widget as a pointer to a GtkWidget object.

Function void gtk curve reset (GtkCurve *curve)

Function void gtk curve set gamma (GtkCurve *curve, gfloat gamma)

Function void gtk curve set range (GtkCurve *curve, gfloat min x, gfloat

         max x, gfloat min y, gfloat max y)

Function void gtk curve get vector (GtkCurve *curve, int veclen, gfloat vector[])

Function void gtk curve set vector (GtkCurve *curve, int veclen, gfloat vector[])

Function void gtk curve set curve type (GtkCurve *curve, GtkCurveType type)

Function GtkCurve* GTK CURVE (gpointer obj)

Cast a generic pointer to GtkCurve*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkCurveClass* GTK CURVE CLASS (gpointer class)

Cast a generic pointer to GtkCurveClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS CURVE (gpointer obj)

Determine if a generic pointer refers to a GtkCurve object. See Section 8.7 [Standard Macros], page 143, for more info.

6.16 The gamma curve widget

6.16.1 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 see Section 6.65 [GtkVBox], page 114. Makes use of see Section 6.15 [GtkCurve], page 53 to draw the curve.

6.16.2 Options

6.16.3 Signals

6.16.4 Functions

Function guint gtk gamma curve get type (void)

Returns the GtkGamma type identifier.

Function GtkWidget* gtk gamma curve new (void)

Create a new GtkGamma returning the new widget as a pointer to a GtkWidget object.

Function GtkGammaCurve* GTK GAMMACURVE (gpointer obj)

Cast a generic pointer to GtkGammaCurve*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkGammaCurveClass* GTK GAMMACURVE CLASS

    (gpointer class)

Cast a generic pointer to GtkGammaCurveClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS GAMMACURVE (gpointer obj)

Determine if a generic pointer refers to a GtkGammaCurve object. See Section 8.7 [Standard Macros], page 143, for more info.

6.17 The dialog widget

6.17.1 Description

The dialog widget is a window (see Section 6.74 [GtkWindow], page 127) that has a vertical box (see Section 6.65 [GtkVBox], page 114), a horizontal box (see Section 6.25 [GtkHBox], page 65), separated with a horizontal separator (see Section 6.31 [GtkHSeparator], page 71).

6.17.2 Options

6.17.3 Signals

6.17.4 Functions

Function guint gtk dialog get type (void)

Returns the GtkDialog type identifier.

Function GtkWidget* gtk dialog new (void)

Create a new GtkDialog object and return the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkDialog* GTK DIALOG (gpointer obj)

Cast a generic pointer to GtkDialog*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkDialogClass* GTK DIALOG CLASS (gpointer class)

Cast a generic pointer to GtkDialogClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS DIALOG (gpointer obj)

Determine if a generic pointer refers to a GtkDialog object. See Section 8.7 [Standard Macros], page 143, for more info.

6.18 The drawing area widget

6.18.1 Description

A base class for widgets that need a box to draw into. So far, only used by GtkCurve.

6.18.2 Options

User Option width

User Option height

6.18.3 Signals

6.18.4 Functions

Function guint gtk drawing area get type (void)

Returns the GtkDrawingArea type identifier.

Function GtkWidget* gtk drawing area new (void)

Create a new GtkDrawingArea object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk drawing area size (GtkDrawingArea *darea, gint width,

gint height) Set the size of the darea widget, created previously, to width and height.

Function GtkDrawingArea* GTK DRAWING AREA (gpointer obj)

Cast a generic pointer to GtkDrawingArea*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkDrawingAreaClass* GTK DRAWING AREA CLASS

    (gpointer class)

Cast a generic pointer to GtkDrawingAreaClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS DRAWING AREA (gpointer obj)

Determine if a generic pointer refers to a GtkDrawingArea object. See Section 8.7 [Standard Macros], page 143, for more info.

6.19 The entry widget

6.19.1 Description

Enter text into this widget. Derived from GtkEditable. Can be set so it isn’t editable.

6.19.2 Options

User Option max

With this option it is possible to set the text max length to the value specified in the max option. This value is a guint16 value.

User Option text

With this option it is possible to ’preload’ the text that will be displayed in the entry widget to the string pointed to by text.

6.19.3 Signals

Signal void GtkEntry::insert text (GtkEntry *entry, gchar *text, gint length, gint *position)

Signal void GtkEntry::delete text (GtkEntry *entry, gint start pos, gint end pos)

Signal void GtkEntry::changed (GtkEntry *entry)

Signal void GtkEntry::set text (GtkEntry *entry)

Signal void GtkEntry::activate (GtkEntry *entry)

6.19.4 Functions

Function guint gtk entry get type (void)

Returns the GtkEntry type identifier.

Function GtkWidget* gtk entry new (void)

Create a new GtkEntry object. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk entry new with max length (guint16 max)

Create a new GtkEntry object initializing it with the value max. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk entry set text (GtkEntry *entry, gchar *text)

Will set the text in the previously created GtkEntry object to text. It is important to not set the fields of the GtkEntry structure directly (or, for that matter, any type derived from GtkObject).

Function void gtk entry append text (GtkEntry *entry, gchar *text)

Append the text that is in the text argument to the widgets text. It is important to not set the fields of the GtkEntry structure directly.

Function void gtk entry prepend text (GtkEntry *entry, gchar *text)

Add the text in the text argument to the text in the GtkEntry widget. It is important to not set the fields of the GtkEntry structure directly.

Function void gtk entry set position (GtkEntry *entry, gint position)

Function void gtk entry set visibility (GtkEntry *entry, gint visible)

Will make the keystrokes entered into the GtkEntry object invisible when visible is TRUE. Defaults to FALSE.

Function gchar* gtk entry get text (GtkEntry *entry)

Returns the text that is contained in the GtkEntry as a pointer to a gchar variable.

Function GtkEntry* GTK ENTRY (gpointer obj)

Cast a generic pointer to GtkEntry*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkEntryClass* GTK ENTRY CLASS (gpointer class)

Cast a generic pointer to GtkEntryClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS ENTRY (gpointer obj)

Determine if a generic pointer refers to a GtkEntry object. See Section 8.7 [Standard Macros], page 143, for more info.

6.20 The event box widget

6.20.1 Description

Derived from see Section 6.4 [GtkBin], page 30. Used by see Section 6.64 [GtkTreeItem], page 113.

6.20.2 Options

6.20.3 Signals

6.20.4 Functions

Function guint gtk event box get type (void)

Returns the GtkEventBox type identifier.

Function GtkWidget* gtk event box new (void)

Create a new GtkEventBox returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkGtkEventBox* GTK EVENT BOX (gpointer obj)

Cast a generic pointer to GtkGtkEventBox*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkGtkEventBoxClass* GTK EVENT BOX CLASS (gpointer

class) Cast a generic pointer to GtkGtkEventBoxClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS EVENT BOX (gpointer obj)

Determine if a generic pointer refers to a GtkGtkEventBox object. See Section 8.7 [Standard Macros], page 143, for more info.

6.21 The file selection dialog widget

6.21.1 Description

6.21.2 Options

User Option title

User Option filename

6.21.3 Signals

6.21.4 Functions

Function guint gtk file selection get type (void)

Returns the GtkFileSelection type identifier.

Function GtkWidget* gtk file selection new (gchar *title)

Create a new GtkFileSelection object and return the new widget as a pointer to a GtkWidget. NULL is returned on failure.

Function void gtk file selection set filename (GtkFileSelection *filesel,

gchar *filename)

Function gchar* gtk file selection get filename (GtkFileSelection

*filesel)

Function GtkFileSelection* GTK FILE SELECTION (gpointer obj)

Cast a generic pointer to GtkFileSelection*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkFileSelectionClass* GTK FILE SELECTION CLASS

    (gpointer class)

Cast a generic pointer to GtkFileSelectionClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS FILE SELECTION (gpointer obj)

Determine if a generic pointer refers to a GtkFileSelection object. See Section 8.7 [Standard Macros], page 143, for more info.

6.22 The fixed widget

6.22.1 Description

6.22.2 Options

6.22.3 Signals

6.22.4 Functions

Function guint gtk fixed get type (void)

Returns the GtkFixed type identifier.

Function GtkWidget* gtk fixed new (void)

Create a new GtkFixed object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk fixed put new (GtkFixed *fixed, GtkWidget *widget,

    gint16 x, gint16 y)
Function void gtk fixed move (GtkFixed *fixed, GtkWidget *widget, gint16
    x, gint16 y)

Function GtkFixed* GTK FIXED (gpointer obj)

Cast a generic pointer to GtkFixed*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkFixedClass* GTK FIXED CLASS (gpointer class)

Cast a generic pointer to GtkFixedClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS FIXED (gpointer obj)

Determine if a generic pointer refers to a GtkFixed object. See Section 8.7 [Standard Macros], page 143, for more info.

6.23 The frame widget

6.23.1 Options

User Option label

User Option xalign

User Option yalign

User Option type

6.23.2 Description

6.23.3 Signals

6.23.4 Functions

Function guint gtk frame get type (void)

Returns the GtkFrame type identifier.

Function GtkWidget* gtk frame new (gchar *label)

Create a new GtkFrame object initializing it with the value in label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk frame set label (GtkFrame *frame, gchar *label)

Function void gtk frame set label align (GtkFrame *frame, gfloat xalign, gfloat yalign)

Function void gtk frame set shadow type (GtkFrame *frame,

    GtkShadowType type)

Function GtkFrame* GTK FRAME (gpointer obj)

Cast a generic pointer to GtkFrame*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkFrameClass* GTK FRAME CLASS (gpointer class)

Cast a generic pointer to GtkFrameClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS FRAME (gpointer obj)

Determine if a generic pointer refers to a GtkFrame object. See Section 8.7 [Standard Macros], page 143, for more info.

6.24 The gamma widget

6.24.1 Description

6.24.2 Options

6.24.3 Signals

6.24.4 Functions

Function guint gtk gamma curve get type (void)

Returns the GtkGamma type identifier.

Function GtkWidget* gtk gamma curve new (void)

Create a new GtkGamma object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkGamma* GTK GAMMA (gpointer obj)

Cast a generic pointer to GtkGamma*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkGammaClass* GTK GAMMA CLASS (gpointer class)

Cast a generic pointer to GtkGammaClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS GAMMA (gpointer obj)

Determine if a generic pointer refers to a GtkGamma object. See Section 8.7 [Standard Macros], page 143, for more info.

6.25 The horizontal box widget

6.25.1 Description

6.25.2 Options

User Option homogeneous

This option controls whether each object in the box has the same size. In the case of the GtkHBox, this effects the width. If this option is set then the expand option to the gtk_box_pack (see Section 6.5 [GtkBox], page 31) routines is always set to TRUE.

User Option spacing

This option controls the amount of space that is added between the objects packed into this GtkVBox object.

6.25.3 Signals

6.25.4 Functions

Function guint gtk hbox get type (void)

Returns the GtkHBox type identifier.

Function GtkWidget* gtk hbox new (gint homogeneous, gint spacing)

Create a new GtkHBox object initializing it with the values in homogeneous and spacing. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkHBox* GTK HBOX (gpointer obj)

Cast a generic pointer to GtkHBox*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkHBoxClass* GTK HBOX CLASS (gpointer class)

Cast a generic pointer to GtkHBoxClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS HBOX (gpointer obj)

Determine if a generic pointer refers to a GtkHBox object. See Section 8.7 [Standard Macros], page 143, for more info.

6.26 The horizontal button box widget

6.26.1 Description

6.26.2 Options

User Option spacing

User Option layout

6.26.3 Signals

6.26.4 Functions

Function guint gtk hbutton box get type (void)

Returns the GtkHButtonBox type identifier.

Function GtkWidget* gtk hbutton box new (void)

Create a new GtkHButtonBox object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk hbutton box set spacing default (gint spacing)

Function void gtk hbutton box set layout default (gint layout)

Function gint gtk hbutton box get spacing default (void)

Function gint gtk hbutton box get layout default (void)

Function GtkHButtonBox* GTK HBUTTON BOX (gpointer obj)

Cast a generic pointer to GtkHButtonBox*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkHButtonBoxClass* GTK HBUTTON BOX CLASS

         (gpointer class)

Cast a generic pointer to GtkHButtonBoxClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS HBUTTON BOX (gpointer obj)

Determine if a generic pointer refers to a GtkHButtonBox object. See Section 8.7 [Standard Macros], page 143, for more info.

6.27 The horizontal paned widget

6.27.1 Description

6.27.2 Options

6.27.3 Signals

6.27.4 Functions

Function void gtk hpaned get type (void)

Returns the GtkHPaned type identifier.

Function GtkWidget* gtk hpaned new (void)

Create a new GtkHPaned object returning the new widget as a pointer to a GtkWidget object.

Function GtkHPaned* GTK HPANED (gpointer obj)

Cast a generic pointer to GtkHPaned*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkHPanedClass* GTK HPANED CLASS (gpointer class)

Cast a generic pointer to GtkHPanedClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS HPANED (gpointer obj)

Determine if a generic pointer refers to a GtkHPaned object. See Section 8.7 [Standard Macros], page 143, for more info.

6.28 The horizontal ruler widget

6.28.1 Description

6.28.2 Options

6.28.3 Signals

6.28.4 Functions

Function guint gtk hruler get type (void)

Returns the GtkHRuler type identifier.

Function GtkWidget* gtk hruler new (void)

Create a new GtkHRuler object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkHRuler* GTK HRULER (gpointer obj)

Cast a generic pointer to GtkHRuler*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkHRulerClass* GTK HRULER CLASS (gpointer class)

Cast a generic pointer to GtkHRulerClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS HRULER (gpointer obj)

Determine if a generic pointer refers to a GtkHRuler object. See Section 8.7 [Standard Macros], page 143, for more info.

6.29 The horizontal scale widget

6.29.1 Description

6.29.2 Options

6.29.3 Signals

6.29.4 Functions

Function guint gtk hscale get type (void)

Returns the GtkHScale type identifier.

Function GtkWidget* gtk hscale new (GtkAdjustment *adjustment)

Create a new GtkHScale object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkHScale* GTK HSCALE (gpointer obj)

Cast a generic pointer to GtkHScale*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkHScaleClass* GTK HSCALE CLASS (gpointer class)

Cast a generic pointer to GtkHScaleClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS HSCALE (gpointer obj)

Determine if a generic pointer refers to a GtkHScale object. See Section 8.7 [Standard Macros], page 143, for more info.

6.30 The horizontal scrollbar widget

6.30.1 Description

6.30.2 Options

6.30.3 Signals

6.30.4 Functions

Function guint gtk hscrollbar get type (void)

Returns the GtkHScrollbar type identifier.

Function GtkWidget* gtk hscrollbar new (GtkAdjustment *adjustment)

Create a new GtkHScrollbar object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkHScrollbar* GTK HSCROLLBAR (gpointer obj)

Cast a generic pointer to GtkHScrollbar*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkHScrollbarClass* GTK HSCROLLBAR CLASS (gpointer

class) Cast a generic pointer to GtkHScrollbarClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS HSCROLLBAR (gpointer obj)

Determine if a generic pointer refers to a GtkHScrollbar object. See Section 8.7 [Standard Macros], page 143, for more info.

6.31 The horizontal separator widget

6.31.1 Description

6.31.2 Options

6.31.3 Signals

6.31.4 Functions

Function guint gtk hseparator get type (void)

Returns the GtkHSeparator type identifier.

Function GtkWidget* gtk hseparator new (void)

Create a new GtkHSeparator object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkHSeparator* GTK HSEPARATOR (gpointer obj)

Cast a generic pointer to GtkHSeparator*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkHSeparatorClass* GTK HSEPARATOR CLASS (gpointer

class) Cast a generic pointer to GtkHSeparatorClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS HSEPARATOR (gpointer obj)

Determine if a generic pointer refers to a GtkHSeparator object. See Section 8.7 [Standard Macros], page 143, for more info.

6.32 The image widget

6.32.1 Description

6.32.2 Options

6.32.3 Signals

6.32.4 Functions

Function guint gtk image get type (void)

Returns the GtkImage type identifier.

Function GtkWidget* gtk image new (GdkImage *val, GdkBitmap *mask)

Create a new GtkImage object initializing it with the values in val and mask. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk image set (GtkImage *image, GdkImage *val, GdkBitmap

*mask)

Function void gtk image get (GtkImage *image, GdkImage **val, GdkBitmap

**mask)

Function GtkImage* GTK IMAGE (gpointer obj)

Cast a generic pointer to GtkImage*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkImageClass* GTK IMAGE CLASS (gpointer class)

Cast a generic pointer to GtkImageClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS IMAGE (gpointer obj)

Determine if a generic pointer refers to a GtkImage object. See Section 8.7 [Standard Macros], page 143, for more info.

6.33 The input dialog widget

6.33.1 Description

6.33.2 Options

6.33.3 Signals

Signal void GtkInputDialog::enable device (GtkInputDialog *inputd,

    guint32 devid, gpointer *data)

Signal void GtkInputDialog::disable device (GtkInputDialog *inputd,

    guint32 devid, gpointer *data)

6.33.4 Functions

Function guint gtk input dialog get type (void)

Returns the GtkInputDialog type identifier.

Function GtkWidget* gtk input dialog new (void)

Create a new GtkInputDialog object and return the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkInputDialog* GTK INPUTDIALOG (gpointer obj)

Cast a generic pointer to GtkInputDialog*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkInputDialogClass* GTK INPUTDIALOG CLASS

    (gpointer class)

Cast a generic pointer to GtkInputDialogClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS INPUTDIALOG (gpointer obj)

Determine if a generic pointer refers to a GtkInputDialog object. See Section 8.7 [Standard Macros], page 143, for more info.

6.34 The item widget

6.34.1 Description

6.34.2 Signals

Signal void GtkItem::select (GtkItem *item)

Signal void GtkItem::deselect (GtkItem *item)

Signal void GtkItem::toggle (GtkItem *toggle)

6.34.3 Functions

Function guint gtk item get type (void)

Returns the GtkItem type identifier.

Function void gtk item select (GtkItem *item)

Function void gtk item deselect (GtkItem *item)

Function void gtk item toggle (GtkItem *item)

Function GtkItem* GTK ITEM (gpointer obj)

Cast a generic pointer to GtkItem*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkItemClass* GTK ITEM CLASS (gpointer class)

Cast a generic pointer to GtkItemClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS ITEM (gpointer obj)

Determine if a generic pointer refers to a GtkItem object. See Section 8.7 [Standard Macros], page 143, for more info.

6.35 The label widget

6.35.1 Description

6.35.2 Options

User Option str

6.35.3 Signals

6.35.4 Functions

Function guint gtk label get type (void)

Returns the GtkLabel type identifier.

Function GtkWidget* gtk label new (GtkLabel *label, gchar *str)

Create a new GtkLabel object and initialize it with the text in str. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk label set (GtkLabel *label, gchar *str)

Set the GtkLabel label value to the value passed in the str argument.

Function void gtk label get (GtkLabel *label, gchar **str)

Copies the current value in the GtkLabel label field to the variable passed in the str argument.

Function GtkLabel* GTK LABEL (gpointer obj)

Cast a generic pointer to GtkLabel*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkLabelClass* GTK LABEL CLASS (gpointer class)

Cast a generic pointer to GtkLabelClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS LABEL (gpointer obj)

Determine if a generic pointer refers to a GtkLabel object. See Section 8.7 [Standard Macros], page 143, for more info.

6.36 The list widget

6.36.1 Description

6.36.2 Signals

Signal void GtkList::selection changed (GtkList *list)

Signal void GtkList::select child (GtkList *list, GtkWidget *child) Signal void GtkList::unselect child (GtkList *list, GtkWidget *child)

6.36.3 Functions

Function guint gtk list get type (void)

Returns the GtkList type identifier.

Function GtkWidget* gtk list new (void)

Create a new GtkList object and return the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk list insert items (GtkList *list, GList *items, gint

position)

Function void gtk list append items (GtkList *list, GList *items) Function void gtk list prepend items (GtkList *list, GList *items) Function void gtk list remove items (GtkList *list, GList *items) Function void gtk list clear items (GtkList *list, gint start, gint end) Function void gtk list select item (GtkList *list, gint item)

Function void gtk list unselect item (GtkList *list, gint item)

Function void gtk list select child (GtkList *list, GtkWidget *child) Function void gtk list unselect child (GtkList *list, GtkWidget *child) Function gint gtk list child position (GtkList *list, GtkWidget *child)

Function void gtk list set selection mode (GtkList *list,

         GtkSelectionMode mode)

Function GtkList* GTK LIST (gpointer obj)

Cast a generic pointer to GtkList*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkListClass* GTK LIST CLASS (gpointer class)

Cast a generic pointer to GtkListClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS LIST (gpointer obj)

Determine if a generic pointer refers to a GtkList object. See Section 8.7 [Standard Macros], page 143, for more info.

6.37 The list item widget

6.37.1 Description

6.37.2 Options

6.37.3 Signals

6.37.4 Functions

Function guint gtk list item get type (void)

Returns the GtkListItem type identifier.

Function GtkWidget* gtk list item new (void)

Create a new GtkListItem object and return the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk list item new with label (gchar *label)

Create a new GtkListItem object initializing with the value label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk list item select (GtkListItem *list item)

Function void gtk list item deselect (GtkListItem *list item)

Function GtkListItem* GTK LIST ITEM (gpointer obj)

Cast a generic pointer to GtkListItem*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkListItemClass* GTK LIST ITEM CLASS (gpointer class)

Cast a generic pointer to GtkListItemClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS LIST ITEM (gpointer obj)

Determine if a generic pointer refers to a GtkListItem object. See Section 8.7 [Standard Macros], page 143, for more info.

6.38 The menu widget

6.38.1 Description

6.38.2 Options

6.38.3 Signals

6.38.4 Functions

Function guint gtk menu get type (void)

Returns the GtkMenu type identifier.

Function GtkWidget* gtk menu new (void)

Create a new GtkMenu object returning the new widget as a pointer to a GtkWidget. NULL is returned on failure.

Function void gtk menu append (GtkMenu *menu, GtkWidget *child)

Function void gtk menu prepend (GtkMenu *menu, GtkWidget *child)

Function void gtk menu insert (GtkMenu *menu, GtkWidget *child, gint position)

Function void gtk menu popup (GtkMenu *menu, GtkWidget

    *parent menu shell, GtkWidget *parent menu item, GtkMenuPositionFunc

func, gpointer data, gint button)

Function void gtk menu popdown (GtkMenu *menu)

Function GtkWidget* gtk menu get active (GtkMenu *menu)

Function void gtk menu set active (GtkMenu *menu)

Function void gtk menu set accelerator table (GtkMenu *menu,

    GtkAcceleratorTable *table)

Function GtkMenu* GTK MENU (gpointer obj)

Cast a generic pointer to GtkMenu*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkMenuClass* GTK MENU CLASS (gpointer class)

Cast a generic pointer to GtkMenuClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS MENU (gpointer obj)

Determine if a generic pointer refers to a GtkMenu object. See Section 8.7 [Standard Macros], page 143, for more info.

6.39 The menu bar widget

6.39.1 Description

6.39.2 Options

User Option position

6.39.3 Signals

6.39.4 Functions

Function guint gtk menu bar get type (void)

Returns the GtkMenuBar type identifier.

Function GtkWidget* gtk menu bar new (void)

Create a new GtkMenuBar object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk menu bar append (GtkMenuBar *menu bar, GtkWidget *child)

Function void gtk menu bar prepend (GtkMenuBar *menu bar, GtkWidget *child)

Function void gtk menu bar insert (GtkMenuBar *menu bar, GtkWidget *child, gint position)

Function GtkMenuBar* GTK MENU BAR (gpointer obj)

Cast a generic pointer to GtkMenuBar*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkMenuBarClass* GTK MENU BAR CLASS (gpointer class)

Cast a generic pointer to GtkMenuBarClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS MENU BAR (gpointer obj)

Determine if a generic pointer refers to a GtkMenuBar object. See Section 8.7 [Standard Macros], page 143, for more info.

6.40 The menu item widget

6.40.1 Description

6.40.2 Options

6.40.3 Signals

Signal void GtkMenuItem::activate (GtkMenuItem *menu item)

6.40.4 Functions

Function guint gtk menu item get type (void)

Returns the GtkMenuItem type identifier.

Function GtkWidget* gtk menu item new (void)

Create a new GtkMenuItem object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk menu item new with label (gchar *label)

Create a new GtkMenuItem object initializing it with the value in label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk menu item set submenu (GtkMenuItem *menu item,

    GtkWidget *submenu)

Function void gtk menu item set placement (GtkMenuItem *menu item,

    GtkSubmenuPlacement placement)

Function void gtk menu item accelerator size (GtkMenuItem *menu item)

Function void gtk menu item accelerator text (GtkMenuItem *menu item,

    gchar *buffer)

Function void gtk menu item configure (GtkMenuItem *menu item, gint show toggle indicator, gint show submenu indicator)

Function void gtk menu item select (GtkMenuItem *menu item)

Function void gtk menu item deselect (GtkMenuItem *menu item)

Function void gtk menu item activate (GtkMenuItem *menu item)

Function GtkMenuItem* GTK MENU ITEM (gpointer obj)

Cast a generic pointer to GtkMenuItem*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkMenuItemClass* GTK MENU ITEM CLASS (gpointer

class) Cast a generic pointer to GtkMenuItemClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS MENU ITEM (gpointer obj)

Determine if a generic pointer refers to a GtkMenuItem object. See Section 8.7 [Standard Macros], page 143, for more info.

6.41 The menu shell widget

6.41.1 Description

6.41.2 Options

6.41.3 Signals

Signal void GtkMenuShell::deactivate (GtkMenuShell *menu shell)

6.41.4 Functions

Function guint gtk menu shell get type (void)

Returns the GtkMenuShell type identifier.

Function void gtk menu shell append (GtkMenuShell *menu shell,

    GtkWidget *child)

Function void gtk menu shell prepend (GtkMenuShell *menu shell,

    GtkWidget *child)

Function void gtk menu shell insert (GtkMenuShell *menu shell, GtkWidget *child, gint position)

Function void gtk menu shell deactivate (GtkMenuShell *menu shell)

Function GtkMenuShell* GTK MENU SHELL (gpointer obj)

Cast a generic pointer to GtkMenuShell*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkMenuShellClass* GTK MENU SHELL CLASS (gpointer

class) Cast a generic pointer to GtkMenuShellClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS MENU SHELL (gpointer obj)

Determine if a generic pointer refers to a GtkMenuShell object. See Section 8.7 [Standard Macros], page 143, for more info.

6.42 The misc widget

6.42.1 Description

6.42.2 Options

User Option xalign

User Option yalign

User Option xpad

User Option ypad

6.42.3 Signals

6.42.4 Functions

Function guint gtk misc get type (void)

Returns the GtkMisc type identifier.

Function void gtk misc set alignment (GtkMisc *misc, gfloat xalign, gfloat yalign)

Function void gtk misc set padding (GtkMisc *misc, gint xpad, gint ypad)

Function GtkMisc* GTK MISC (gpointer obj)

Cast a generic pointer to GtkMisc*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkMiscClass* GTK MISC CLASS (gpointer class)

Cast a generic pointer to GtkMiscClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS MISC (gpointer obj)

Determine if a generic pointer refers to a GtkMisc object. See Section 8.7 [Standard Macros], page 143, for more info.

6.43 The notebook widget

6.43.1 Description

6.43.2 Options

6.43.3 Signals

6.43.4 Functions

Function guint gtk notebook get type (void)

Returns the GtkNotebook type identifier.

Function GtkWidget* gtk notebook new (void)

Create a new GtkNotebook object returning the new widget as a pointer to a GtkWidget object. NULL is returned on a failure.

Function void gtk notebook append page (GtkNotebook *notebook,

         GtkWidget *child, GtkWidget *tab label)

Function void gtk notebook prepend page (GtkNotebook *notebook,

         GtkWidget *child, GtkWidget *tab label)

Function void gtk notebook insert page (GtkNotebook *notebook,

         GtkWidget *child, GtkWidget *tab label, gint position)

Function void gtk notebook remove page (GtkNotebook *notebook, gint page num)

Function void gtk notebook set page (GtkNotebook *notebook, gint page num)

Function void gtk notebook next page (GtkNotebook *notebook)

Function void gtk notebook prev page (GtkNotebook *notebook)

Function void gtk notebook set tab pos (GtkNotebook *notebook,

         GtkPositionType pos)

Function void gtk notebook set show tabs (GtkNotebook *notebook, gint

show tabs)

Function void gtk notebook set show border (GtkNotebook *notebook,

gint show border)

Function GtkNotebook* GTK NOTEBOOK (gpointer obj)

Cast a generic pointer to GtkNotebook*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkNotebookClass* GTK NOTEBOOK CLASS (gpointer

class) Cast a generic pointer to GtkNotebookClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS NOTEBOOK (gpointer obj)

Determine if a generic pointer refers to a GtkNotebook object. See Section 8.7 [Standard Macros], page 143, for more info.

6.44 The option menu widget

6.44.1 Description

6.44.2 Options

User Option index

6.44.3 Signals

6.44.4 Functions

Function guint gtk option menu get type (void)

Returns the GtkOptionMenu type identifier.

Function GtkWidget* gtk option menu new (void)

Create a new GtkOptionMenu object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk option menu get menu (GtkOptionMenu

*option menu)

Function void gtk option menu set menu (GtkOptionMenu *option menu,

    GtkWidget *menu)

Function void gtk option menu remove menu (GtkOptionMenu

*option menu)

Function void gtk option menu set history (GtkOptionMenu *option menu,

gint index)

Function GtkOptionMenu* GTK OPTION MENU (gpointer obj)

Cast a generic pointer to GtkOptionMenu*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkOptionMenuClass* GTK OPTION MENU CLASS

    (gpointer class)

Cast a generic pointer to GtkOptionMenuClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS OPTION MENU (gpointer obj)

Determine if a generic pointer refers to a GtkOptionMenu object. See Section 8.7 [Standard Macros], page 143, for more info.

6.45 The paned widget

6.45.1 Description

6.45.2 Options

6.45.3 Signals

6.45.4 Functions

Function guint gtk paned get type (void)

Returns the GtkPaned type identifier.

Function void gtk paned add1 (GtkPaned *paned, GtkWidget *child)

Function void gtk paned add2 (GtkPaned *paned, GtkWidget *child)

Function void gtk paned handle size (GtkPaned *paned, guint16 size)

Function void gtk paned gutter size (GtkPaned *paned, guint16 size)

Function GtkPaned* GTK PANED (gpointer obj)

Cast a generic pointer to GtkPaned*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkPanedClass* GTK PANED CLASS (gpointer class)

Cast a generic pointer to GtkPanedClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS PANED (gpointer obj)

Determine if a generic pointer refers to a GtkPaned object. See Section 8.7 [Standard Macros], page 143, for more info.

6.46 The pixmap widget

6.46.1 Description

6.46.2 Options

6.46.3 Signals

6.46.4 Functions

Function guint gtk pixmap get type (void)

Returns the GtkPixmap type identifier.

Function GtkWidget* gtk pixmap new (GdkPixmap *normal, GdkPixmap
    *active, GdkPixmap *prelight, GdkPixmap *selected, GdkPixmap *insensitive)

Function void gtk pixmap set (GtkPixmap *pixmap, GdkPixmap *val,

    GtkStateType state)

Function void gtk pixmap get (GtkPixmap *pixmap, GdkPixmap **val,

    GtkStateType state)

Function GtkPixmap* GTK PIXMAP (gpointer obj)

Cast a generic pointer to GtkPixmap*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkPixmapClass* GTK PIXMAP CLASS (gpointer class)

Cast a generic pointer to GtkPixmapClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS PIXMAP (gpointer obj)

Determine if a generic pointer refers to a GtkPixmap object. See Section 8.7 [Standard Macros], page 143, for more info.

6.47 The preview widget

6.47.1 Description

6.47.2 Options

User Option type

User Option width

User Option height

6.47.3 Signals

6.47.4 Functions

Function guint gtk preview get type (void)

Returns the GtkPreview type identifier.

Function void gtk preview uninit (void)

Function GtkWidget* gtk preview new (GtkPreviewType type)

Create a new GtkPreview object initializing it with the values in type. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk preview size (GtkPreview *preview, gint width, gint

height) Set the size of the preview object to width and height.

Function void gtk preview put (GtkPreview *preview, GdkWindow *window,

         GdkGC *gc, gint srcx, gint srcy, gint destx, gint desty, gint width, gint

height)

Function void gtk preview put row (GtkPreview *preview, guchar *src,

         guchar *dest, gint x, gint y, gint w)

Function void gtk preview draw row (GtkPreview *preview, guchar data,

         gint x, gint y, gint w)

Function void gtk preview set expand (GtkPreview *preview, gint expand)

Function void gtk preview set gamma (double gamma)

Function void gtk preview set color cube (guint nred shades, guint

ngreen shades, guint nblue shades, guint ngray shades)

Function void gtk preview set install cmap (gint install cmap)

Function void gtk preview set reserved (gint nreserved)

Function GdkVisual* gtk preview get visual (void)

Function GdkColormap* gtk preview get cmap (void)

Function GtkPreviewInfo* gtk preview get info (void)

Function GtkPreview* GTK PREVIEW (gpointer obj)

Cast a generic pointer to GtkPreview*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkPreviewClass* GTK PREVIEW CLASS (gpointer class)

Cast a generic pointer to GtkPreviewClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS PREVIEW (gpointer obj)

Determine if a generic pointer refers to a GtkPreview object. See Section 8.7 [Standard Macros], page 143, for more info.

6.48 The progress bar widget

6.48.1 Description

6.48.2 Options

User Option percentage

6.48.3 Signals

6.48.4 Functions

Function guint gtk progress bar get type (void)

Returns the GtkProgressBar type identifier.

Function GtkWidget* gtk progress bar new (void)

Create a new GtkProgressBar object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk progress bar update (GtkProgressBar *pbar, gfloat

percentage) Cause the GtkProgressBar to update its visual appearance to reflect the percentage.

Function GtkProgressBar* GTK PROGRESS BAR (gpointer obj)

Cast a generic pointer to GtkProgressBar*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkProgressBarClass* GTK PROGRESS BAR CLASS

    (gpointer class)

Cast a generic pointer to GtkProgressBarClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS PROGRESS BAR (gpointer obj)

Determine if a generic pointer refers to a GtkProgressBar object. See Section 8.7 [Standard Macros], page 143, for more info.

6.49 The radio button widget

6.49.1 Description

6.49.2 Options

User Option group

User Option label

6.49.3 Signals

6.49.4 Functions

Function guint gtk radio button get type (void)

Returns the GtkRadioButton type identifier.

Function GtkWidget* gtk radio button new (GSList *group)

Create a new GtkRadioButton object initializing it with the value in the group argument. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk radio button new with label (GSList *group,

    gchar *label)

Create a new GtkRadioButton object initializing it with the values in the group and label arguments. The new widget is returned as a pointer to GtkWidget object. NULL is returned on failure.

Function GSList* gtk radio button group (GtkRadioButton *radio button)

Function GtkRadioButton* GTK RADIO BUTTON (gpointer obj)

Cast a generic pointer to GtkRadioButton*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkRadioButtonClass* GTK RADIO BUTTON CLASS

    (gpointer class)

Cast a generic pointer to GtkRadioButtonClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS RADIO BUTTON (gpointer obj)

Determine if a generic pointer refers to a GtkRadioButton object. See Section 8.7 [Standard Macros], page 143, for more info.

6.50 The radio button widget

6.50.1 Description

6.50.2 Options

User Option group

User Option label

6.50.3 Signals

6.50.4 Functions

Function guint gtk radio menu item get type (void)

Returns the GtkRadioMenuItem type identifier.

Function GtkWidget* gtk radio menu item new (GSList *group)

Create a new GtkRadioMenuItem object and initialize it with the values in group. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk radio menu item new with label (GSList

*group, gchar *label)

Function GSList* gtk radio menu item group (GtkRadioMenuItem

*radio menu item)

Function GtkRadioMenuItem* GTK RADIO MENU ITEM (gpointer

obj) Cast a generic pointer to GtkRadioMenuItem*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkRadioMenuItemClass*

GTK RADIO MENU ITEM CLASS (gpointer class)

Cast a generic pointer to GtkRadioMenuItemClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS RADIO MENU ITEM (gpointer obj)

Determine if a generic pointer refers to a GtkRadioMenuItem object. See Section 8.7 [Standard Macros], page 143, for more info.

6.51 The range widget

6.51.1 Description

6.51.2 Options

6.51.3 Signals

6.51.4 Functions

Function guint gtk range get type (void)

Returns the GtkRange type identifier.

Function GtkAdjustment* gtk range get adjustment (GtkRange *range) Function void gtk range set update policy (GtkRange *range,

         GtkUpdatePolicy policy)

Function void gtk range set adjustment (GtkRange *range, GtkAdjustment

*adjustment)

Function void gtk range draw background (GtkRange *range) Function void gtk range draw trough (GtkRange *range) Function void gtk range draw slider (GtkRange *range) Function void gtk range draw step forw (GtkRange *range) Function void gtk range draw step back (GtkRange *range) Function void gtk range slider update (GtkRange *range)

Function gint gtk range trough click (GtkRange *range, gint x, gint y)

Function void gtk range default hslider update (GtkRange *range) Function void gtk range default vslider update (GtkRange *range) Function gint gtk range default htrough click (GtkRange *range, gint x,

         gint y)

Function gint gtk range default vtrough click (GtkRange *range, gint x,

         gint y)

Function void gtk range default hmotion (GtkRange *range, gint xdelta, gint ydelta)

Function void gtk range default vmotion (GtkRange *range, gint xdelta, gint ydelta)

Function gfloat gtk range calc value (GtkRange *range, gint position)

Function GtkRange* GTK RANGE (gpointer obj)

Cast a generic pointer to GtkRange*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkRangeClass* GTK RANGE CLASS (gpointer class)

Cast a generic pointer to GtkRangeClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS RANGE (gpointer obj)

Determine if a generic pointer refers to a GtkRange object. See Section 8.7 [Standard Macros], page 143, for more info.

6.52 The ruler widget

6.52.1 Description

6.52.2 Options

User Option metric

User Option lower

User Option upper

User Option position

User Option max size

6.52.3 Signals

6.52.4 Functions

Function guint gtk ruler get type (void)

Returns the GtkRuler type identifier.

Function void gtk ruler set metric (GtkRuler *ruler, GtkMetricType metric)

Function void gtk ruler set range (GtkRuler *ruler, gfloat lower, gfloat upper, gfloat position, gfloat max size)

Function void gtk ruler draw ticks (GtkRuler *ruler)

Function void gtk ruler draw pos (GtkRuler *ruler)

Function GtkRuler* GTK RULER (gpointer obj)

Cast a generic pointer to GtkRuler*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkRulerClass* GTK RULER CLASS (gpointer class)

Cast a generic pointer to GtkRulerClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS RULER (gpointer obj)

Determine if a generic pointer refers to a GtkRuler object. See Section 8.7 [Standard Macros], page 143, for more info.

6.53 The scale widget

6.53.1 Description

6.53.2 Options

User Option digits User Option draw value User Option pos

6.53.3 Signals

6.53.4 Functions

Function guint gtk scale get type (void)

Returns the GtkScale type identifier. Function void gtk scale set digits (GtkScale *scale, gint digits) Function void gtk scale set draw value (GtkScale *scale, gint draw value) Function void gtk scale set value pos (GtkScale *scale, gint pos)

Function gint gtk scale value width (GtkScale *scale) Function void gtk scale draw value (GtkScale *scale) Function GtkScale* GTK SCALE (gpointer obj)

Cast a generic pointer to GtkScale*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkScaleClass* GTK SCALE CLASS (gpointer class)

Cast a generic pointer to GtkScaleClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS SCALE (gpointer obj)

Determine if a generic pointer refers to a GtkScale object. See Section 8.7 [Standard Macros], page 143, for more info.

6.54 The scrollbar widget

6.54.1 Description

6.54.2 Options

6.54.3 Signals

6.54.4 Functions

Function guint gtk scrollbar get type (void)a

Returns the GtkScrollbar type identifier.

Function GtkScrollbar* GTK SCROLLBAR (gpointer obj)

Cast a generic pointer to GtkScrollbar*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkScrollbarClass* GTK SCROLLBAR CLASS (gpointer

class) Cast a generic pointer to GtkScrollbarClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS SCROLLBAR (gpointer obj)

Determine if a generic pointer refers to a GtkScrollbar object. See Section 8.7 [Standard Macros], page 143, for more info.

6.55 The scrolled window widget

6.55.1 Description

6.55.2 Options

6.55.3 Signals

6.55.4 Functions

Function guint gtk scrolled window get type (void)

Returns the GtkScrolledWindow type identifier.

Function GtkWidget* gtk scrolled window new (GtkAdjustment

*hadjustment, GtkAdjustment *vadjustment) Create a new GtkScrolledWindow object initializing it with the values in adjustment and adjustment. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkAdjustment* gtk scrolled window get hadjustment

    (GtkScrolledWindow *scrolled window)

Function GtkAdjustment* gtk scrolled window get vadjustment

    (GtkScrolledWindow *scrolled window)

Function void gtk scrolled window set policy (GtkScrolledWindow

*scrolled window, GtkPolicyType hscrollbar policy, GtkPolicyType vscrollbar policy)

Function GtkScrolledWindow* GTK SCROLLED WINDOW (gpointer

obj) Cast a generic pointer to GtkScrolledWindow*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkScrolledWindowClass*

GTK SCROLLED WINDOW CLASS (gpointer class)

Cast a generic pointer to GtkScrolledWindowClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS SCROLLED WINDOW (gpointer obj)

Determine if a generic pointer refers to a GtkScrolledWindow object. See Section 8.7 [Standard Macros], page 143, for more info.

6.56 The separator widget

6.56.1 Description

6.56.2 Options

6.56.3 Signals

6.56.4 Functions

Function guint gtk separator get type (void)

Returns the GtkSeparator type identifier.

Function GtkSeparator* GTK SEPARATOR (gpointer obj)

Cast a generic pointer to GtkSeparator*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkSeparatorClass* GTK SEPARATOR CLASS (gpointer

class) Cast a generic pointer to GtkSeparatorClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS SEPARATOR (gpointer obj)

Determine if a generic pointer refers to a GtkSeparator object. See Section 8.7 [Standard Macros], page 143, for more info.

6.57 The statusbar widget

6.57.1 Description

6.57.2 Options

6.57.3 Signals

6.57.4 Functions

Function guint gtk statusbar get type (void)

Returns the GtkStatusbar type identifier.

Function GtkWidget* gtk statusbar new (void)

Create a new GtkStatusbar object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function gint gtk statusbar push (GtkStatusbar *statusbar, gchar *text)

Function void gtk statusbar pop (GtkStatusbar *statusbar, gint context id)

Function GtkStatusbar* GTK STATUSBAR (gpointer obj)

Cast a generic pointer to GtkStatusbar*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkStatusbarClass* GTK STATUSBAR CLASS (gpointer

class) Cast a generic pointer to GtkStatusbarClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS STATUSBAR (gpointer obj)

Determine if a generic pointer refers to a GtkStatusbar object. See Section 8.7 [Standard Macros], page 143, for more info.

6.58 The table widget

6.58.1 Description

6.58.2 Options

User Option rows

User Option columns

User Option homogeneous

This option controls whether all child widgets in the GtkTable will be of the same size. The child widgets will be the size of the largest child.

6.58.3 Signals

6.58.4 Functions

Function guint gtk table get type (void)

Returns the GtkTable type identifier.

Function GtkWidget* gtk table new (gint rows, gint columns, gint

homogeneous) Create a new GtkTable object initializing it with the values in rows, columns and homogeneous. The new widget is returned as a pointer to a GtkWidget. NULL is returned on failure.

Function void gtk table attach (GtkTable *table, GtkWidget *child, gint left attach, gint right attach, gint top attach, gint bottom attach, gint xoptions, gint yoptions, gint xpadding, gint ypadding)

Function void gtk table attach defaults (GtkTable *table, GtkWidget

*widget, gint left attach, gint right attach, gint top attach, gint bottom attach)

Function void gtk table set row spacing (GtkTable *table, gint row, gint spacing)

Function void gtk table set col spacing (GtkTable *table, gint col, gint spacing)

Function void gtk table set row spacings (GtkTable *table, gint spacing)

Function void gtk table set col spacings (GtkTable *table, gint spacing)

Function GtkTable* GTK TABLE (gpointer obj)

Cast a generic pointer to GtkTable*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkTableClass* GTK TABLE CLASS (gpointer class)

Cast a generic pointer to GtkTableClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS TABLE (gpointer obj)

Determine if a generic pointer refers to a GtkTable object. See Section 8.7 [Standard Macros], page 143, for more info.

6.59 The text widget

6.59.1 Description

6.59.2 Signals

6.59.3 Functions

Function guint gtk text get type (void)

Returns the GtkText type identifier.

Function GtkWidget* gtk text new (GtkAdjustment *hadj, GtkAdjustment

*vadj); Create a new GtkText object initializing it with the values in hadj and vadj. The new widget is returned as a pointer to a GtkWidget. NULL is returned on failure.

Function void gtk text set editable (GtkText *text, gint editable)

Function void gtk text set adjustments (GtkText *text, GtkAdjustment

    *hadj, GtkAdjustment *vadj)

Function void gtk text set point (GtkText *text, guint index)

Function guint gtk text get point (GtkText *text)

Function guint gtk text get length (GtkText *text)

Function void gtk text freeze (GtkText *text)

Function void gtk text thaw (GtkText *text)

Function void gtk text insert (GtkText *text, GdkFont *font, GdkColor
    *fore, GdkColor *back, char *chars, gint length)

Function gint gtk text forward delete (GtkText *text, guint nchars)

Function gint gtk text backward delete (GtkText *text, guint nchars)

Function GtkText* GTK TEXT (gpointer obj)

Cast a generic pointer to GtkText*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkTextClass* GTK TEXT CLASS (gpointer class)

Cast a generic pointer to GtkTextClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS TEXT (gpointer obj)

Determine if a generic pointer refers to a GtkText object. See Section 8.7 [Standard Macros], page 143, for more info.

6.60 The toggle button widget

6.60.1 Description

Another form of button (see Section 6.7 [GtkButton], page 37) 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.

6.60.2 Options

User Option state

6.60.3 Signals

Signal void GtkToggleButton::toggled (GtkToggleButton *toggle button)

6.60.4 Functions

Function guint gtk toggle button get type (void)

Returns the GtkToggleButton type identifier.

Function GtkWidget* gtk toggle button new (void)

Create a new GtkToggleButton object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk toggle button new with label (gchar *label)

Create a new GtkToggleButton object initializing it with the values in label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk toggle button set mode (GtkToggleButton

*toggle button, gint draw indicator)

Function void gtk toggle button set state (GtkToggleButton

*toggle button, gint state)

Function void gtk toggle button toggled (GtkToggleButton *toggle button)

Function GtkToggleButton* GTK TOGGLE BUTTON (gpointer obj)

Cast a generic pointer to GtkToggleButton*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkToggleButtonClass* GTK TOGGLE BUTTON CLASS

    (gpointer class)

Cast a generic pointer to GtkToggleButtonClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS TOGGLE BUTTON (gpointer obj)

Determine if a generic pointer refers to a GtkToggleButton object. See Section 8.7 [Standard Macros], page 143, for more info.

6.61 The tool bar widget

6.61.1 Description

6.61.2 Options

User Option orientation

• GTK ORIENTATION HORIZONTAL

• GTK ORIENTATION VERTICAL

User Option style

• GTK TOOLBAR ICONS

• GTK TOOLBAR TEXT

• GTK TOOLBAR BOTH

User Option space size

6.61.3 Signals

6.61.4 Functions

Function guint gtk toolbar get type (void)

Returns the GtkToolbar type identifier.

Function GtkWidget* gtk toolbar new (GtkOrientation orientation,

GtkToolbarStyle style)

Create a new GtkToolbar object initializing it with the values orientation and style. NULL is returned on failure.

Function void gtk toolbar append item (GtkToolbar *toolbar, char *text,

char *tooltip text, GtkPixmap *icon, GtkSignalFunc callback, gpointer

user data)

Function void gtk toolbar prepend item (GtkToolbar *toolbar, char

*text, char *tooltip text, GtkPixmap *icon, GtkSignalFunc callback,

gpointer user data)

Function void gtk toolbar insert item (GtkToolbar *toolbar, char *text,

char *tooltip text, GtkPixmap *icon, GtkSignalFunc callback, gpointer

user data, gint position)

Function void gtk toolbar append space (GtkToolbar *toolbar)

Function void gtk toolbar prepend space (GtkToolbar *toolbar)

Function void gtk toolbar insert space (GtkToolbar *toolbar, gint

position)

Function void gtk toolbar set orientation (GtkToolbar *toolbar,

    GtkOrientation orientation)

Function void gtk toolbar set style (GtkToolbar *toolbar, GtkToolbarStyle

style) Set the style of the toolbar to style.

Function void gtk toolbar set space size (GtkToolbar *toolbar, gint

space size)

Function void gtk toolbar set tooltips (GtkToolbar *toolbar, gint enable)

Function GtkToolbar* GTK TOOLBAR (gpointer obj)

Cast a generic pointer to GtkToolbar*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkToolbarClass* GTK TOOLBAR CLASS (gpointer class)

Cast a generic pointer to GtkToolbarClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS TOOLBAR (gpointer obj)

Determine if a generic pointer refers to a GtkToolbar object. See Section 8.7 [Standard Macros], page 143, for more info.

6.62 The tool tips widget

6.62.1 Description

6.62.2 Options

6.62.3 Signals

6.62.4 Functions

Function GtkTooltips* gtk tooltips new (void)

Create a new GtkTooltips object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkTooltips* gtk tooltips ref (GtkTooltips *tooltips)

Function void gtk tooltips unref (GtkTooltips *tooltips)

Function void gtk tooltips free string (gpointer data, gpointer user data)

Function void gtk tooltips enable (GtkTooltips *tooltips)

Function void gtk tooltips disable (GtkTooltips *tooltips)

Function void gtk tooltips set delay (GtkTooltips *tooltips, GtkWidget *widget, gchar *tips text)

Function void gtk tooltips set colors (GtkTooltips *tooltips, GdkColor *background, GdkColor *foreground)

Function GtkTooltips* GTK TOOLTIPS (gpointer obj)

Cast a generic pointer to GtkTooltips*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkTooltipsClass* GTK TOOLTIPS CLASS (gpointer class)

Cast a generic pointer to GtkTooltipsClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS TOOLTIPS (gpointer obj)

Determine if a generic pointer refers to a GtkTooltips object. See Section 8.7 [Standard Macros], page 143, for more info.

6.63 The tree widget

6.63.1 Description

6.63.2 Options

6.63.3 Signals

6.63.4 Functions

Function guint gtk tree get type (void)

Returns the GtkTree type identifier.

Function GtkWidget* gtk tree new (void)

Create a new GtkTree object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk tree append (GtkTree *tree, GtkWidget *child) Function void gtk tree prepend (GtkTree *tree, GtkWidget *child) Function void gtk tree insert (GtkTree *tree, GtkWidget *child, gint

position)

Function gint gtk tree child position (GtkTree *tree, GtkWidget *child) Function void gtk tree clear items (GtkTree *tree, gint start, gint end) Function void gtk tree remove items (GtkTree *tree, GList *items) Function void gtk tree select child (GtkTree *tree, GtkWidget *child) Function void gtk tree select item (GtkTree *tree, gint item) Function void gtk tree unselect child (GtkTree *tree, GtkWidget *child)

Function void gtk tree unselect item (GtkTree *tree, gint item) Function void gtk tree set selection mode (GtkTree *tree,

         GtkSelectionMode mode)

Function void gtk tree set view mode (GtkTree *tree, GtkTreeViewMode

mode)

Function void gtk tree set view lines (GtkTree *tree, guint flag)

Function GtkTree* GTK TREE (gpointer obj)

Cast a generic pointer to GtkTree*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkTreeClass* GTK TREE CLASS (gpointer class)

Cast a generic pointer to GtkTreeClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS TREE (gpointer obj)

Determine if a generic pointer refers to a GtkTree object. See Section 8.7 [Standard Macros], page 143, for more info.

6.64 The tree item widget

6.64.1 Description

6.64.2 Options

6.64.3 Signals

6.64.4 Functions

Function guint gtk tree item get type (void)

Returns the GtkTreeItem type identifier.

Function GtkWidget* gtk tree item new (void)

Create a new GtkTreeItem object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkWidget* gtk tree item new with label (gchar *label)

Create a new GtkTreeItem object initializing it with the values in label. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk tree item set subtree (GtkTreeItem *tree item,

    GtkWidget *subtree)

Function void gtk tree item select (GtkTreeItem *tree item)

Function void gtk tree item deselect (GtkTreeItem *tree item)

Function void gtk tree item expand (GtkTreeItem *tree item)

Function void gtk tree item collapse (GtkTreeItem *tree item)

Function void gtk tree item remove subtree (GtkTreeItem *item)

Function GtkTreeItem* GTK TREE ITEM (gpointer obj)

Cast a generic pointer to GtkTreeItem*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkTreeItemClass* GTK TREE ITEM CLASS (gpointer

class) Cast a generic pointer to GtkTreeItemClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS TREE ITEM (gpointer obj)

Determine if a generic pointer refers to a GtkTreeItem object. See Section 8.7 [Standard Macros], page 143, for more info.

6.65 The vertical box widget

6.65.1 Description

6.65.2 Options

User Option homogeneous

This option controls whether each object in the box has the same size. In the case of the GtkVBox, this refers to the height. If this option is set then the expand option to the gtk_box_pack (see Section 6.5 [GtkBox], page 31) routines is always turned on.

User Option spacing

This option sets the amount of space that is added between the objects packed into this GtkVBox object.

6.65.3 Signals

This widget does not define any new signals.

6.65.4 Functions

Function guint gtk vbox get type (void)

Returns the GtkVBox type identifier.

Function GtkWidget* gtk vbox new (gint homogeneous, gint spacing)

Create a new GtkVBox object initializing it with the values in homogeneous and spacing. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkVBox* GTK VBOX (gpointer obj)

Cast a generic pointer to GtkVBox*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkVBoxClass* GTK VBOX CLASS (gpointer class)

Cast a generic pointer to GtkVBoxClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VBOX (gpointer obj)

Determine if a generic pointer refers to a GtkVBox object. See Section 8.7 [Standard Macros], page 143, for more info.

6.66 The vertical button box widget

6.66.1 Description

6.66.2 Options

User Option spacing

User Option layout

6.66.3 Signals

6.66.4 Functions

Function guint gtk vbutton box get type (void)

Returns the GtkVButtonBox type identifier.

Function GtkWidget* gtk vbutton box new (void)

Create a new GtkVButtonBox object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function void gtk vbutton box set spacing default (gint spacing)

Function void gtk vbutton box set layout default (gint layout)

Function gint gtk vbutton box get spacing default (void)

Function gint gtk vbutton box get layout default (void)

Function GtkVButtonBox* GTK VBUTTON BOX (gpointer obj)

Cast a generic pointer to GtkVButtonBox*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkVButtonBoxClass* GTK VBUTTON BOX CLASS

    (gpointer class)

Cast a generic pointer to GtkVButtonBoxClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VBUTTON BOX (gpointer obj)

Determine if a generic pointer refers to a GtkVButtonBox object. See Section 8.7 [Standard Macros], page 143, for more info.

6.67 The viewport widget

6.67.1 Description

6.67.2 Signals

6.67.3 Functions

Function guint gtk viewport get type (void)

Returns the GtkViewport type identifier.

Function GtkWidget* gtk viewport new (GtkAdjustment *hadjustment,

    GtkAdjustment *vadjustment)

Function GtkAdjustment* gtk viewport get hadjustment (GtkViewport

*viewport)

Function GtkAdjustment* gtk viewport get vadjustment (GtkViewport

*viewport)

Function void gtk viewport set hadjustment (GtkViewport *viewport,

    GtkAdjustment *adjustment)

Function void gtk viewport set vadjustment (GtkViewport *viewport,

    GtkAdjustment *adjustment)

Function void gtk viewport set shadow type (GtkViewport *viewport,

    GtkShadowType type)

Function GtkViewport* GTK VIEWPORT (gpointer obj)

Cast a generic pointer to GtkViewport*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkViewportClass* GTK VIEWPORT CLASS (gpointer class)

Cast a generic pointer to GtkViewportClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VIEWPORT (gpointer obj)

Determine if a generic pointer refers to a GtkViewport object. See Section 8.7 [Standard Macros], page 143, for more info.

6.68 The vertical paned widget

6.68.1 Description

6.68.2 Options

6.68.3 Signals

6.68.4 Functions

Function guint gtk vpaned get type (void)

Returns the GtkVPaned type identifier.

Function GtkWidget* gtk vpaned new (void)

Create a new GtkVPaned object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkVPaned* GTK VPANED (gpointer obj)

Cast a generic pointer to GtkVPaned*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkVPanedClass* GTK VPANED CLASS (gpointer class)

Cast a generic pointer to GtkVPanedClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VPANED (gpointer obj)

Determine if a generic pointer refers to a GtkVPaned object. See Section 8.7 [Standard Macros], page 143, for more info.

6.69 The vertical ruler widget

6.69.1 Description

6.69.2 Options

6.69.3 Signals

6.69.4 Functions

Function guint gtk vruler get type (void)

Returns the GtkVRuler type identifier.

Function GtkWidget* gtk vruler new (void)

Create a new GtkVRuler object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkVRuler* GTK VRULER (gpointer obj)

Cast a generic pointer to GtkVRuler*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkVRulerClass* GTK VRULER CLASS (gpointer class)

Cast a generic pointer to GtkVRulerClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VRULER (gpointer obj)

Determine if a generic pointer refers to a GtkVRuler object. See Section 8.7 [Standard Macros], page 143, for more info.

6.70 The vertical ruler widget

6.70.1 Description

6.70.2 Options

6.70.3 Signals

6.70.4 Functions

Function guint gtk vscale get type (void)

Returns the GtkVScale type identifier.

Function GtkWidget* gtk vscale new (GtkAdjustment *adjustment)

Create a new GtkVScale object returning the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkVScale* GTK VSCALE (gpointer obj)

Cast a generic pointer to GtkVScale*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkVScaleClass* GTK VSCALE CLASS (gpointer class)

Cast a generic pointer to GtkVScaleClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VSCALE (gpointer obj)

Determine if a generic pointer refers to a GtkVScale object. See Section 8.7 [Standard Macros], page 143, for more info.

6.71 The vertical scrollbar widget

6.71.1 Description

6.71.2 Options

6.71.3 Signals

6.71.4 Functions

Function guint gtk vscrollbar get type (void)

Returns the GtkVScrollbar type identifier.

Function GtkWidget* gtk vscrollbar new (GtkAdjustment *adjustment)

Create a new GtkVScrollbar object initializing it with the values in adjustment. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkVScrollbar* GTK VSCROLLBAR (gpointer obj)

Cast a generic pointer to GtkVScrollbar*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkVScrollbarClass* GTK VSCROLLBAR CLASS (gpointer

class) Cast a generic pointer to GtkVScrollbarClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VSCROLLBAR (gpointer obj)

Determine if a generic pointer refers to a GtkVScrollbar object. See Section 8.7 [Standard Macros], page 143, for more info.

6.72 The vertical separator widget

6.72.1 Description

6.72.2 Signals

6.72.3 Functions

Function guint gtk vseparator get type (void)

Returns the GtkVSeparator type identifier.

Function GtkWidget* gtk vseparator new (void)

Create a new GtkVSeparator object and return the new widget as a pointer to a GtkWidget object. NULL is returned on failure.

Function GtkVSeparator* GTK VSEPARATOR (gpointer obj)

Cast a generic pointer to GtkVSeparator*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkVSeparatorClass* GTK VSEPARATOR CLASS (gpointer

class) Cast a generic pointer to GtkVSeparatorClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS VSEPARATOR (gpointer obj)

Determine if a generic pointer refers to a GtkVSeparator object. See Section 8.7 [Standard Macros], page 143, for more info.

6.73 The base widget

6.73.1 Description

6.73.2 Signals

Signal void GtkWidget::show (GtkWidget *widget) Signal void GtkWidget::hide (GtkWidget *widget) Signal void GtkWidget::map (GtkWidget *widget) Signal void GtkWidget::unmap (GtkWidget *widget) Signal void GtkWidget::realize (GtkWidget *widget) Signal void GtkWidget::unrealize (GtkWidget *widget)

Signal void GtkWidget::draw (GtkWidget *widget, GdkRectangle *area)

Signal void GtkWidget::draw focus (GtkWidget *widget) Signal void GtkWidget::draw default (GtkWidget *widget)

Signal void GtkWidget::size request (GtkWidget *widget, GtkRequisition

*requisition)

Signal void GtkWidget::size allocate (GtkWidget *widget, GtkAllocation

*allocation)

Signal void GtkWidget::state changed (GtkWidget *widget) Signal gint GtkWidget::install accelerator (GtkWidget *widget, gchar

*signal name, gchar key, guint8 modifiers)

Signal void GtkWidget::remove accelerator (GtkWidget *widget, gchar

*signal name)

Signal gint GtkWidget::event (GtkWidget *widget, GdkEvent *event)

Signal gint GtkWidget::button press event (GtkWidget *widget,

         GdkEventButton *event)

Signal gint GtkWidget::button release event (GtkWidget *widget,

         GdkEventButton *event)

Signal gint GtkWidget::motion notify event (GtkWidget *widget,

         GdkEventMotion *event)

Signal gint GtkWidget::delete event (GtkWidget *widget, GdkEventAny *event)

Signal gint GtkWidget::destroy event (GtkWidget *widget, GdkEventAny *event)

Signal gint GtkWidget::expose event (GtkWidget *widget,

GdkEventExpose *event)

Signal gint GtkWidget::key press event (GtkWidget *widget, GdkEventKey *event)

Signal gint GtkWidget::key release event (GtkWidget *widget,

GdkEventKey *event)

Signal gint GtkWidget::enter notify event (GtkWidget *widget,

GdkEventCrossing *event)

Signal gint GtkWidget::leave notify event (GtkWidget *widget,

GdkEventCrossing *event)

Signal gint GtkWidget::configure event (GtkWidget *widget,

GdkEventConfigure *event)

Signal gint GtkWidget::focus in event (GtkWidget *widget,

GdkEventFocus *event)

Signal gint GtkWidget::focus out event (GtkWidget *widget,

GdkEventFocus *event)

Signal gint GtkWidget::map event (GtkWidget *widget, GdkEventAny *event)

Signal gint GtkWidget::unmap event (GtkWidget *widget, GdkEventAny *event)

Signal gint GtkWidget::property notify event (GtkWidget *widget,

GdkEventProperty *event)

Signal gint GtkWidget::selection clear event (GtkWidget *widget,

GdkEventSelection *event)

Signal gint GtkWidget::selection request event (GtkWidget *widget,

GdkEventSelection *event)

Signal gint GtkWidget::selection notify event (GtkWidget *widget,

GdkEventSelection *event)

Signal gint GtkWidget::drop event (GtkWidget *widget, GdkEventDrop *event)

Signal gint GtkWidget::drag begin event (GtkWidget *widget,

         GdkEventDragBegin *event)

Signal gint GtkWidget::other event (GtkWidget *widget, GdkEventOther

*event)

6.73.3 Functions

Function guint gtk widget get type (void)

Returns the GtkWidget type identifier.

Function void gtk widget class init (GtkWidgetClass *class)

Function void gtk widget init (GtkWidget *widget)

Function void gtk widget destroy (GtkWidget *widget)

Function void gtk widget show (GtkWidget *widget) Function void gtk widget hide (GtkWidget *widget) Function void gtk widget map (GtkWidget *widget)

Function void gtk widget unmap (GtkWidget *widget) Function void gtk widget realize (GtkWidget *widget) Function void gtk widget unrealize (GtkWidget *widget)

Function void gtk widget draw (GtkWidget *widget, GdkRectangle *area)

Function void gtk widget draw focus (GtkWidget *widget) Function void gtk widget draw children (GtkWidget *widget) Function void gtk widget size request (GtkWidget *widget,

         GtkRequisition *requisition)

Function void gtk widget size allocate (GtkWidget *widget, GtkAllocation

*allocation)

Function void gtk widget install accelerator (GtkWidget *widget,

         GtkAcceleratorTable *table, gchar *signal name, gchar key, guint8

modifiers)

Function void gtk widget remove accelerator (GtkWidget *widget,

         GtkAcceleratorTable *table, gchar *signal name)

Function gint gtk widget event (GtkWidget *widget, GdkEvent *event) Function void gtk widget reparent (GtkWidget *widget, GtkWidget

*new parent)

Function void gtk widget popup (GtkWidget *widget, gint x, gint y) Function gint gtk widget intersect (GtkWidget *widget, GdkRectangle

*area, GdkRectangle *intersection)

Function void gtk widget grab focus (GtkWidget *widget) Function void gtk widget grab default (GtkWidget *widget) Function void gtk widget restore state (GtkWidget *widget)

Function void gtk widget set name (GtkWidget *widget, gchar *name) Function void gtk widget set state (GtkWidget *widget, GtkStateType

state)

Function void gtk widget set sensitive (GtkWidget *widget, gint

         sensitive)

Function void gtk widget set parent (GtkWidget *widget, GtkWidget

*parent)

Function void gtk widget set style (GtkWidget *widget, GtkStyle *style) Function void gtk widget set uposition (GtkWidget *widget, gint x, gint

y)

Function void gtk widget set usize (GtkWidget *widget, gint width, gint

height)

Function GtkWidget* gtk widget get toplevel (GtkWidget *widget) Function GtkWidget* gtk widget get ancestor (GtkWidget *widget, gint

type)

Function GdkColormap* gtk widget get colormap (GtkWidget *widget) Function GdkVisual* gtk widget get visual (GtkWidget *visual) Function GtkStyle* gtk widget get style (GtkWidget *style) Function GtkWidget* GTK WIDGET (gpointer obj)

Cast a generic pointer to GtkWidget*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkWidgetClass* GTK WIDGET CLASS (gpointer class)

Cast a generic pointer to GtkWidgetClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS WIDGET (gpointer obj)

Determine if a generic pointer refers to a GtkWidget object. See Section 8.7 [Standard Macros], page 143, for more info.

6.74 The window widget

6.74.1 Description

6.74.2 Options

User Option type

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

• GTK_WINDOW_TOPLEVEL

• The option GTK_WINDOW_TOPLEVEL is usually used for the main application

window that will remain for the entire application run.

• GTK_WINDOW_DIALOG

• The option 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.

• GTK_WINDOW_POPUP

• The option 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 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 type will not be in any window list of the window manager. Though this window will not get the kill and close widgets of the window manager they still can receive said events and should be taken into account.

User Option title

The title option will set the title of the window in the window manager. Note: On windows that have the type option set to GTK_WINDOW_POPUP there is a strong possibility that this will text will not be seen.

User Option position

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

• GTK_WIN_POS_NONE

• This 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.

• GTK_WIN_POS_CENTER

• This position option will cause the window to center itself on the the screen. This option setting will take into account the virtual screen size when calculating the center. This is not the same as the virtual desktop setting of many window managers. It will center itself on the current virtual desktop.

  • GTK_WIN_POS_MOUSE

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

6.74.3 Signals

Signal void GtkWindow::move resize (GtkWindow *window, gint *x, gint *y, gint width, gint height)

Signal void GtkWindow::set focus (GtkWindow *window, GtkWidget *focus)

6.74.4 Functions

Function guint gtk window get type (void)

Returns the GtkWindow type identifier.

Function GtkWidget* gtk window new (GtkWindowType type)

Create a new GtkWindow object. The new widget is returned as a pointer to a GtkWidget object. NULL is returned on failure. The type can be one of GTK_WINDOW_

TOPLEVEL, GTK_WINDOW_DIALOG or, GTK_WINDOW_POPUP. The type value determines

how this widget will interact with the window manager.

Function void gtk window set title (GtkWindow *window, gchar *title)

Set the title of this window to the text in the title argument. It is important to not set the fields of the GtkWindow structure directly.

Function void gtk window set focus (GtkWindow *window, GtkWidget *focus)

Function void gtk window set default (GtkWindow *window, GtkWidget *defaultw)

Function void gtk window set policy (GtkWindow *window, gint

allow shrink, gint allow grow, gint auto shrink)

Function void gtk window add accelerator table (GtkWindow *window,

    GtkAcceleratorTable *table)

Function void gtk window remove accelerator table (GtkWindow

    *window, GtkAcceleratorTable *table)

Function void gtk window position (GtkWindow *window,

    GtkWindowPosition position)

Set the position that the window will be at when it is finally drawn to the screen. The position argument effects the the position as described above.

Function GtkWindow* GTK WINDOW (gpointer obj)

Cast a generic pointer to GtkWindow*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkWindowClass* GTK WINDOW CLASS (gpointer class)

Cast a generic pointer to GtkWindowClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS WINDOW (gpointer obj)

Determine if a generic pointer refers to a GtkWindow object. See Section 8.7 [Standard Macros], page 143, for more info.

130 GTK

7 Utility objects

7.1 The accelerator table object

7.1.1 Description

7.1.2 Functions

Function GtkAcceleratorTable* gtk accelerator table new (void)

Function GtkAcceleratorTable* gtk accelerator table find (GtkObject

*object, gchar *signal name, guchar accelerator key, guint8

accelerator mods)

Function GtkAccelerator *gtk accelerator table ref

         (GtkAcceleratorTable *table)

Function void gtk accelerator table unref (GtkAcceleratorTable *table)

Function void gtk accelerator table install (GtkAcceleratorTable *table,

         GtkObject *object, gchar *signal name, guchar accelerator key, guint8

accelerator mods)

Function void gtk accelerator table remove (GtkAcceleratorTable *table,

         GtkObject *object, gchar *signal name)

Function void gtk accelerator table check (GtkAcceleratorTable *table,

guchar accelerator key, guint8 accelerator mods)

Function void gtk accelerator table set mod mask

         (GtkAcceleratorTable *table, guint8 modifier mask)

7.2 The adjustment object

7.2.1 Description

7.2.2 Functions

Function guint gtk adjustment get type (void)

Returns the GtkAdjustment type identifier.

Function GtkObject* gtk adjustment new (gfloat value, gfloat lower,

gfloat upper, gfloat step increment, gfloat page increment, gfloat page size)

Function GtkGtkAdjustment* GTK ADJUSTMENT (gpointer obj)

Cast a generic pointer to GtkGtkAdjustment*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkGtkAdjustmentClass* GTK ADJUSTMENT CLASS

    (gpointer class)

Cast a generic pointer to GtkGtkAdjustmentClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS ADJUSTMENT (gpointer obj)

Determine if a generic pointer refers to a GtkGtkAdjustment object. See Section 8.7 [Standard Macros], page 143, for more info.

Chapter 7: Utility objects 133

7.3 The GC object

7.3.1 Description 7.3.2 Functions

Function GdkGC* gtk gc get (gint depth, GdkColormap *colormap,

         GdkGCValues *values, GdkGCValuesMask values mask)

Function void gtk gc release (GdkGC *gc)

7.4 The data object

7.4.1 Description

7.4.2 Functions

Function guint gtk data get type (void)

Returns the GtkData type identifier.

Function GtkData* GTK DATA (gpointer obj)

Cast a generic pointer to GtkData*. See Section 8.7 [Standard Macros], page 143, for more info.

Function GtkDataClass* GTK DATA CLASS (gpointer class)

Cast a generic pointer to GtkDataClass*. See Section 8.7 [Standard Macros], page 143, for more info.

Function gint GTK IS DATA (gpointer obj)

Determine if a generic pointer refers to a GtkData object. See Section 8.7 [Standard Macros], page 143, for more info.

Chapter 7: Utility objects 135

7.5 The style object

7.5.1 Description 7.5.2 Functions

136 GTK

8 Initialization, exit and other features

8.1 Initializing and exiting GTK

8.1.1 Initializing

Before any GTK functions can be utilized the library must be initialized. This can be accomplished by calling the 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.

8.1.2 Exiting

8.1.3 Functions

Function void gtk init (int *argc, char **argv)

Function to initialize GTK and GDK for you. This function will remove any command line arguments from argc and argv that it understands.

     int main (int argc, char *argv[])
     {
        ...Any local variables or non GTK/GDK initialization
        /* Initialize GTK. */
        gtk_init(&argc, &argc);
     }

Function void gtk exit (int error code)

Exit GTK and perform any necessary cleanup. gtk_exit will call the systems exit function passing error code as the parameter.

Function gint gtk events pending (void)

Returns the number of events pending on the event queue.

Function void gtk main (void)

Function guint gtk main level (void)

Function void gtk main quit (void)

A call to this function will cause the gtk_main function to exit, thereby allowing your application to exit.

8.2 Customization of the library

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

8.2.2 Functions

The following functions are available to handle the rc files.

Function void gtk rc parse (char *filename)

This function will parse the filename that is passed to it as its argument. It will use the style settings for the widget types defined there.

Function void gtk rc init (void)

This function will initialize the rc file parser, normally this need not be called directly as the gtk_rc_parse function will handle this for you.

Chapter 8: Initialization, exit and other features 139

8.3 Simplified menu creation

140 GTK

8.4 Simplified tree creation

Chapter 8: Initialization, exit and other features 141

8.5 Pop up help mechanism

8.5.1 Description

142 GTK

8.6 Resource Files 8.7 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 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.

Function Gtk<ObjectType>* GTK <OBJECT TYPE> (gpointer obj)

Cast a generic pointer to 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 gtk_type_is_a) before performing the cast.

Function Gtk<ObjectType>Class* GTK <OBJECT TYPE> CLASS

    (gpointer class)
Cast a generic pointer to Gtk<ObjectType>Class*. Like GTK_<ObjectType>, this

function is, in reality, a macro.

Function gint GTK IS <ObjectType> (gpointer obj)

Determine if a generic pointer refers to a Gtk<ObjectType> object. This function is, in reality, a macro wrapper around the gtk_type_is_a function (see Chapter 3 [Types], page 7).

144 GTK

9 Using GTK

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

     #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;
     }

The first point of interest in this program is the standard initialization line.

       gtk_init (&argc, &argv);

Almost every GTK program will contain such a line. GTK will initialize itself and GDK and remove any command line arguments it recognizes from argc and argv.

The next two lines of code create and display a window.

       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
       gtk_widget_show (window);

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

       gtk_main ();

Normally, gtk_main is called once and the program should exit when it returns. See Section 8.1 [Initialization and exit], page 137.

9.2 Hello world in GTK

#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;
}

9.3 An enhanced hello world

#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;
}

9.4 Making Hello World II robust

#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;
}

10 Object internals

Objects (or the 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 GtkObject would define itself like:

     struct Descendant
     {
       GtkObject object;
       ...
     };

It is important to note that the GtkObject field needs to appear first in the descendant type structure. This allows pointers to objects of type Descendant to be cast to pointers to 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 GtkObject class defines the 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 klass field of the GtkObject structure.

To see how the class fields work it is necessary to see the object fields for a GtkObject. The GtkObject type is defined as follows:

     typedef struct _GtkObject GtkObject;
     struct _GtkObject
     {
       guint32 flags;
       GtkObjectClass *klass;
       gpointer object_data;
     };

The class field actually points to a class structure derived from GtkObjectClass. By convention, each new type defines its own class structure even if it is unnecessary. As an example, the hypothetical Descendant class would define its class structure as:

     struct DescendantClass
     {
       GtkObjectClass parent_class;
       ...
     };

It is convention to name the parent class field (GtkObjectClass in this case), 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.

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 flags field of the GtkObject structure is used to keep track of a relatively few object flags and is also used by the GtkWidget type to store additional flags. At this time, the upper 16 bits of the flags field are reserved but unused.

The object_data field of the 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.

     typedef struct _GtkObjectData GtkObjectData;
     struct _GtkObjectData
     {
       guint id;
       gpointer data;
       GtkObjectData *next;
     };

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 GtkObjectData structure by 4 bytes on 32 bit architectures.

Chapter 11: Signal internals 151

11 Signal internals

152 GTK Chapter 12: Widget internals 153

12 Widget internals

154 GTK

Function Index 155

Function Index

*

*gtk_accelerator_table_ref . . . . . . . . . . . . . . . 131

G

GTK_<OBJECT_TYPE> . . . . . . . . . . . . . . . . . . . . . . . . . 143

GTK_<OBJECT_TYPE>_CLASS . . . . . . . . . . . . . . . . . . 143
gtk_accelerator_table_check . . . . . . . . . . . . . . 131
gtk_accelerator_table_find . . . . . . . . . . . . . . . 131
gtk_accelerator_table_install . . . . . . . . . . . . 131
gtk_accelerator_table_new . . . . . . . . . . . . . . . . 131
gtk_accelerator_table_remove . . . . . . . . . . . . . 131
gtk_accelerator_table_set_mod_mask . . . . . . 131
gtk_accelerator_table_unref . . . . . . . . . . . . . . 131

GTK_ADJUSTMENT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 GTK_ADJUSTMENT_CLASS. . . . . . . . . . . . . . . . . . . . . . 132

gtk_adjustment_get_type . . . . . . . . . . . . . . . . . . 132

gtk_adjustment_new. . . . . . . . . . . . . . . . . . . . . . . . 132 GTK_ALIGNMENT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 GTK_ALIGNMENT_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 26

gtk_alignment_get_type . . . . . . . . . . . . . . . . . . . . 26

gtk_alignment_new . . . . . . . . . . . . . . . . . . . . . . . . . . 26 gtk_alignment_set . . . . . . . . . . . . . . . . . . . . . . . . . . 26 GTK_ARROW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 GTK_ARROW_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 gtk_arrow_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 27 gtk_arrow_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 gtk_arrow_set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 GTK_ASPECT_FRAME . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

GTK_ASPECT_FRAME_CLASS . . . . . . . . . . . . . . . . . . . . 29
gtk_aspect_frame_get_type . . . . . . . . . . . . . . . . . 29

gtk_aspect_frame_new. . . . . . . . . . . . . . . . . . . . . . . 29 gtk_aspect_frame_set. . . . . . . . . . . . . . . . . . . . . . . 29 GTK_BIN. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 GTK_BIN_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 gtk_bin_get_type . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 GTK_BOX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 GTK_BOX_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 gtk_box_get_type . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 gtk_box_pack_end . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

gtk_box_pack_end_defaults . . . . . . . . . . . . . . . . . 32

gtk_box_pack_start . . . . . . . . . . . . . . . . . . . . . . . . . 32

gtk_box_pack_start_defaults . . . . . . . . . . . . . . . 32
gtk_box_query_child_packing . . . . . . . . . . . . . . . 33

gtk_box_reorder_child . . . . . . . . . . . . . . . . . . . . . 33

gtk_box_set_child_packing . . . . . . . . . . . . . . . . . 33
gtk_box_set_homogeneous . . . . . . . . . . . . . . . . . . . 33

gtk_box_set_spacing. . . . . . . . . . . . . . . . . . . . . . . . 33 GTK_BUTTON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 GTK_BUTTON_BOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 GTK_BUTTON_BOX_CLASS. . . . . . . . . . . . . . . . . . . . . . . 36

gtk_button_box_get_child_ipadding. . . . . . . . . 35
gtk_button_box_get_child_ipadding_default

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

gtk_button_box_get_child_size . . . . . . . . . . . . . 35
gtk_button_box_get_child_size_default . . . . 35
gtk_button_box_get_layout . . . . . . . . . . . . . . . . . 36
gtk_button_box_get_spacing . . . . . . . . . . . . . . . . 35
gtk_button_box_get_type . . . . . . . . . . . . . . . . . . . 35
gtk_button_box_set_child_ipadding. . . . . . . . . 35
gtk_button_box_set_child_ipadding_default

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

gtk_button_box_set_child_size . . . . . . . . . . . . . 35
gtk_button_box_set_child_size_default . . . . 35
gtk_button_box_set_layout . . . . . . . . . . . . . . . . . 35

GTK_BUTTON_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 gtk_button_clicked . . . . . . . . . . . . . . . . . . . . . . . . . 37 gtk_button_enter . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 gtk_button_get_type. . . . . . . . . . . . . . . . . . . . . . . . 37 gtk_button_leave . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 gtk_button_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

gtk_button_new_with_label . . . . . . . . . . . . . . . . . 37

gtk_button_pressed . . . . . . . . . . . . . . . . . . . . . . . . . 37 gtk_button_released. . . . . . . . . . . . . . . . . . . . . . . . 37 GTK_CHECK_BUTTON . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

GTK_CHECK_BUTTON_CLASS . . . . . . . . . . . . . . . . . . . . 39
gtk_check_button_get_type . . . . . . . . . . . . . . . . . 39

gtk_check_button_new. . . . . . . . . . . . . . . . . . . . . . . 39

gtk_check_button_new_with_label . . . . . . . . . . . 39

GTK_CHECK_MENU_ITEM. . . . . . . . . . . . . . . . . . . . . . . . 40

GTK_CHECK_MENU_ITEM_CLASS . . . . . . . . . . . . . . . . . 41
gtk_check_menu_item_get_type . . . . . . . . . . . . . . 40
gtk_check_menu_item_new . . . . . . . . . . . . . . . . . . . 40
gtk_check_menu_item_new_with_label . . . . . . . 40
gtk_check_menu_item_set_state . . . . . . . . . . . . . 40
gtk_check_menu_item_toggled . . . . . . . . . . . . . . . 40

GTK_CLIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 gtk_clist_append . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 GTK_CLIST_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 gtk_clist_clear . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

gtk_clist_column_titles_hide . . . . . . . . . . . . . . 43
gtk_clist_column_titles_show . . . . . . . . . . . . . . 42

gtk_clist_freeze . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

gtk_clist_get_row_data . . . . . . . . . . . . . . . . . . . . 44

gtk_clist_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 42 gtk_clist_insert . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

156 GTK

gtk_clist_moveto . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 gtk_clist_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

gtk_clist_new_with_titles . . . . . . . . . . . . . . . . . 42

gtk_clist_remove . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 gtk_clist_select_row. . . . . . . . . . . . . . . . . . . . . . . 44

gtk_clist_set_background . . . . . . . . . . . . . . . . . . 44

gtk_clist_set_border. . . . . . . . . . . . . . . . . . . . . . . 42

gtk_clist_set_column_justification . . . . . . . 43
gtk_clist_set_column_title . . . . . . . . . . . . . . . . 43
gtk_clist_set_column_widget . . . . . . . . . . . . . . . 43
gtk_clist_set_column_width . . . . . . . . . . . . . . . . 43
gtk_clist_set_foreground . . . . . . . . . . . . . . . . . . 44

gtk_clist_set_pixmap. . . . . . . . . . . . . . . . . . . . . . . 43 gtk_clist_set_policy. . . . . . . . . . . . . . . . . . . . . . . 42

gtk_clist_set_row_data . . . . . . . . . . . . . . . . . . . . 44
gtk_clist_set_row_height . . . . . . . . . . . . . . . . . . 43
gtk_clist_set_selection_mode . . . . . . . . . . . . . . 42

gtk_clist_set_shift. . . . . . . . . . . . . . . . . . . . . . . . 44 gtk_clist_set_text . . . . . . . . . . . . . . . . . . . . . . . . . 43 gtk_clist_setpixtext. . . . . . . . . . . . . . . . . . . . . . . 44 gtk_clist_thaw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

gtk_clist_unselect_row . . . . . . . . . . . . . . . . . . . . 45

GTK_COLOR_SELECTION. . . . . . . . . . . . . . . . . . . . . . . . 47

GTK_COLOR_SELECTION_CLASS . . . . . . . . . . . . . . . . . 47
gtk_color_selection_dialog_get_type . . . . . . 47
gtk_color_selection_dialog_new . . . . . . . . . . . . 47
gtk_color_selection_get_color . . . . . . . . . . . . . 46
gtk_color_selection_get_type . . . . . . . . . . . . . . 46
gtk_color_selection_new . . . . . . . . . . . . . . . . . . . 46
gtk_color_selection_set_color . . . . . . . . . . . . . 46
gtk_color_selection_set_opacity . . . . . . . . . . . 46
gtk_color_selection_set_update_policy . . . . 46

GTK_COMBO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 GTK_COMBO_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 gtk_combo_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 48 gtk_combo_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

gtk_combo_set_case_sensitive . . . . . . . . . . . . . . 48
gtk_combo_set_item_string . . . . . . . . . . . . . . . . . 48
gtk_combo_set_popdown_strings . . . . . . . . . . . . . 48
gtk_combo_set_use_arrows . . . . . . . . . . . . . . . . . . 48
gtk_combo_set_use_arrows_always . . . . . . . . . . . 48
gtk_combo_set_value_in_list . . . . . . . . . . . . . . . 48

GTK_CONTAINER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 gtk_container_add . . . . . . . . . . . . . . . . . . . . . . . . . . 49

gtk_container_block_resize . . . . . . . . . . . . . . . . 50
gtk_container_border_width . . . . . . . . . . . . . . . . 49
gtk_container_check_resize . . . . . . . . . . . . . . . . 50
gtk_container_children . . . . . . . . . . . . . . . . . . . . 50

GTK_CONTAINER_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 50

                                                gtk_container_disable_resize . . . . . . . . . . . . . . 49
                                                gtk_container_enable_resize . . . . . . . . . . . . . . . 50

gtk_container_focus. . . . . . . . . . . . . . . . . . . . . . . . 50 gtk_container_foreach . . . . . . . . . . . . . . . . . . . . . 50

                                                gtk_container_get_type . . . . . . . . . . . . . . . . . . . . 49
                                                gtk_container_need_resize . . . . . . . . . . . . . . . . . 50

gtk_container_remove. . . . . . . . . . . . . . . . . . . . . . . 49

                                                gtk_container_unblock_resize . . . . . . . . . . . . . . 50

GTK_CTREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 GTK_CTREE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 gtk_ctree_clear . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 gtk_ctree_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 51 gtk_ctree_insert . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 gtk_ctree_is_visible. . . . . . . . . . . . . . . . . . . . . . . 52 gtk_ctree_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

                                                gtk_ctree_new_with_titles . . . . . . . . . . . . . . . . . 52
                                                gtk_ctree_post_recursive . . . . . . . . . . . . . . . . . . 52
                                                gtk_ctree_pre_recursive . . . . . . . . . . . . . . . . . . . 52

gtk_ctree_remove . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 GTK_CURVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 GTK_CURVE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 gtk_curve_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 53 gtk_curve_get_vector. . . . . . . . . . . . . . . . . . . . . . . 53 gtk_curve_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 gtk_curve_reset . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

                                                gtk_curve_set_curve_type . . . . . . . . . . . . . . . . . . 53

gtk_curve_set_gamma. . . . . . . . . . . . . . . . . . . . . . . . 53 gtk_curve_set_range. . . . . . . . . . . . . . . . . . . . . . . . 53 gtk_curve_set_vector. . . . . . . . . . . . . . . . . . . . . . . 53 GTK_DATA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 GTK_DATA_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 gtk_data_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 134 GTK_DIALOG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 GTK_DIALOG_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 gtk_dialog_get_type. . . . . . . . . . . . . . . . . . . . . . . . 56 gtk_dialog_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 GTK_DRAWING_AREA . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

                                                GTK_DRAWING_AREA_CLASS . . . . . . . . . . . . . . . . . . . . 57
                                                gtk_drawing_area_get_type . . . . . . . . . . . . . . . . . 57

gtk_drawing_area_new. . . . . . . . . . . . . . . . . . . . . . . 57 gtk_drawing_area_size . . . . . . . . . . . . . . . . . . . . . 57 GTK_ENTRY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 gtk_entry_append_text . . . . . . . . . . . . . . . . . . . . . 59 GTK_ENTRY_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 gtk_entry_get_text . . . . . . . . . . . . . . . . . . . . . . . . . 59 gtk_entry_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 58 gtk_entry_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

gtk_entry_new_with_max_length . . . . . . . . . . . . . 58
gtk_entry_prepend_text . . . . . . . . . . . . . . . . . . . . 59
gtk_entry_set_position . . . . . . . . . . . . . . . . . . . . 59

gtk_entry_set_text . . . . . . . . . . . . . . . . . . . . . . . . . 58

gtk_entry_set_visibility . . . . . . . . . . . . . . . . . . 59

GTK_EVENT_BOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 GTK_EVENT_BOX_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 60

gtk_event_box_get_type . . . . . . . . . . . . . . . . . . . . 60

gtk_event_box_new . . . . . . . . . . . . . . . . . . . . . . . . . . 60 gtk_events_pending. . . . . . . . . . . . . . . . . . . . . . . . 137 gtk_exit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 GTK_FILE_SELECTION . . . . . . . . . . . . . . . . . . . . . . . . . 61

GTK_FILE_SELECTION_CLASS . . . . . . . . . . . . . . . . . . 61
gtk_file_selection_get_filename . . . . . . . . . . . 61
gtk_file_selection_get_type . . . . . . . . . . . . . . . 61
gtk_file_selection_new . . . . . . . . . . . . . . . . . . . . 61
gtk_file_selection_set_filename . . . . . . . . . . . 61

GTK_FIXED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 GTK_FIXED_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 gtk_fixed_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 62 gtk_fixed_move . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 gtk_fixed_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 gtk_fixed_put_new . . . . . . . . . . . . . . . . . . . . . . . . . . 62 GTK_FRAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 GTK_FRAME_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 gtk_frame_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 63 gtk_frame_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 gtk_frame_set_label. . . . . . . . . . . . . . . . . . . . . . . . 63

gtk_frame_set_label_align . . . . . . . . . . . . . . . . . 63
gtk_frame_set_shadow_type . . . . . . . . . . . . . . . . . 63

GTK_FUNDAMENTAL_TYPE. . . . . . . . . . . . . . . . . . . . . . . 10 GTK_GAMMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 GTK_GAMMA_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

gtk_gamma_curve_get_type . . . . . . . . . . . . . . . 55, 64

gtk_gamma_curve_new . . . . . . . . . . . . . . . . . . . . 55, 64 GTK_GAMMACURVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 GTK_GAMMACURVE_CLASS. . . . . . . . . . . . . . . . . . . . . . . 55 gtk_gc_get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 gtk_gc_release . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 GTK_HBOX. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 GTK_HBOX_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 gtk_hbox_get_type . . . . . . . . . . . . . . . . . . . . . . . . . . 65 gtk_hbox_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 GTK_HBUTTON_BOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 GTK_HBUTTON_BOX_CLASS . . . . . . . . . . . . . . . . . . . . . 66

gtk_hbutton_box_get_layout_default . . . . . . . 66
gtk_hbutton_box_get_spacing_default . . . . . . 66
gtk_hbutton_box_get_type . . . . . . . . . . . . . . . . . . 66

gtk_hbutton_box_new. . . . . . . . . . . . . . . . . . . . . . . . 66

                                                gtk_hbutton_box_set_layout_default . . . . . . . 66
                                                gtk_hbutton_box_set_spacing_default . . . . . . 66

GTK_HPANED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 GTK_HPANED_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 gtk_hpaned_get_type. . . . . . . . . . . . . . . . . . . . . . . . 67 gtk_hpaned_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 GTK_HRULER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 GTK_HRULER_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 gtk_hruler_get_type. . . . . . . . . . . . . . . . . . . . . . . . 68 gtk_hruler_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 GTK_HSCALE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 GTK_HSCALE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 gtk_hscale_get_type. . . . . . . . . . . . . . . . . . . . . . . . 69 gtk_hscale_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 GTK_HSCROLLBAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 GTK_HSCROLLBAR_CLASS. . . . . . . . . . . . . . . . . . . . . . . 70

                                                gtk_hscrollbar_get_type . . . . . . . . . . . . . . . . . . . 70

gtk_hscrollbar_new . . . . . . . . . . . . . . . . . . . . . . . . . 70 GTK_HSEPARATOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 GTK_HSEPARATOR_CLASS. . . . . . . . . . . . . . . . . . . . . . . 71

                                                gtk_hseparator_get_type . . . . . . . . . . . . . . . . . . . 71

gtk_hseparator_new . . . . . . . . . . . . . . . . . . . . . . . . . 71 GTK_IMAGE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 GTK_IMAGE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 gtk_image_get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 gtk_image_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 72 gtk_image_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 gtk_image_set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 gtk_init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

                                                gtk_input_dialog_get_type . . . . . . . . . . . . . . . . . 73

gtk_input_dialog_new. . . . . . . . . . . . . . . . . . . . . . . 73 GTK_INPUTDIALOG . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 GTK_INPUTDIALOG_CLASS . . . . . . . . . . . . . . . . . . . . . 73 GTK_IS_<ObjectType>. . . . . . . . . . . . . . . . . . . . . . . 143 GTK_IS_ADJUSTMENT . . . . . . . . . . . . . . . . . . . . . . . . . 132 GTK_IS_ALIGNMENT . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 GTK_IS_ARROW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 GTK_IS_ASPECT_FRAME. . . . . . . . . . . . . . . . . . . . . . . . 29 GTK_IS_BIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 GTK_IS_BOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 GTK_IS_BUTTON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 GTK_IS_BUTTON_BOX . . . . . . . . . . . . . . . . . . . . . . . . . . 36 GTK_IS_CHECK_BUTTON. . . . . . . . . . . . . . . . . . . . . . . . 39

                                                GTK_IS_CHECK_MENU_ITEM . . . . . . . . . . . . . . . . . . . . 41

GTK_IS_CLIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

                                                GTK_IS_COLOR_SELECTION . . . . . . . . . . . . . . . . . . . . 47

GTK_IS_COMBO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

158 GTK

GTK_IS_CONTAINER . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 GTK_IS_CTREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 GTK_IS_CURVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 GTK_IS_DATA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 GTK_IS_DIALOG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 GTK_IS_DRAWING_AREA. . . . . . . . . . . . . . . . . . . . . . . . 57 GTK_IS_ENTRY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 GTK_IS_EVENT_BOX . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 GTK_IS_FILE_SELECTION . . . . . . . . . . . . . . . . . . . . . 61 GTK_IS_FIXED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 GTK_IS_FRAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 GTK_IS_GAMMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 GTK_IS_GAMMACURVE . . . . . . . . . . . . . . . . . . . . . . . . . . 55 GTK_IS_HBOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 GTK_IS_HBUTTON_BOX . . . . . . . . . . . . . . . . . . . . . . . . . 66 GTK_IS_HPANED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 GTK_IS_HRULER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 GTK_IS_HSCALE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 GTK_IS_HSCROLLBAR . . . . . . . . . . . . . . . . . . . . . . . . . . 70 GTK_IS_HSEPARATOR . . . . . . . . . . . . . . . . . . . . . . . . . . 71 GTK_IS_IMAGE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 GTK_IS_INPUTDIALOG . . . . . . . . . . . . . . . . . . . . . . . . . 73 GTK_IS_ITEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 GTK_IS_LABEL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 GTK_IS_LIST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 GTK_IS_LIST_ITEM . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 GTK_IS_MENU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 GTK_IS_MENU_BAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 GTK_IS_MENU_ITEM . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 GTK_IS_MENU_SHELL . . . . . . . . . . . . . . . . . . . . . . . . . . 83 GTK_IS_MISC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 GTK_IS_NOTEBOOK . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 GTK_IS_OPTION_MENU . . . . . . . . . . . . . . . . . . . . . . . . . 87 GTK_IS_PANED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 GTK_IS_PIXMAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 GTK_IS_PREVIEW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 GTK_IS_PROGRESS_BAR. . . . . . . . . . . . . . . . . . . . . . . . 92 GTK_IS_RADIO_BUTTON. . . . . . . . . . . . . . . . . . . . . . . . 93

GTK_IS_RADIO_MENU_ITEM . . . . . . . . . . . . . . . . . . . . 94

GTK_IS_RANGE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 GTK_IS_RULER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 GTK_IS_SCALE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 GTK_IS_SCROLLBAR . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

GTK_IS_SCROLLED_WINDOW . . . . . . . . . . . . . . . . . . . 100

GTK_IS_SEPARATOR . . . . . . . . . . . . . . . . . . . . . . . . . . 101 GTK_IS_STATUSBAR . . . . . . . . . . . . . . . . . . . . . . . . . . 102 GTK_IS_TABLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 GTK_IS_TEXT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 GTK_IS_TOGGLE_BUTTON. . . . . . . . . . . . . . . . . . . . . . 107 GTK_IS_TOOLBAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 GTK_IS_TOOLTIPS . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 GTK_IS_TREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 GTK_IS_TREE_ITEM . . . . . . . . . . . . . . . . . . . . . . . . . . 113 GTK_IS_VBOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 GTK_IS_VBUTTON_BOX. . . . . . . . . . . . . . . . . . . . . . . . 115 GTK_IS_VIEWPORT . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 GTK_IS_VPANED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 GTK_IS_VRULER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 GTK_IS_VSCALE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 GTK_IS_VSCROLLBAR . . . . . . . . . . . . . . . . . . . . . . . . . 120 GTK_IS_VSEPARATOR . . . . . . . . . . . . . . . . . . . . . . . . . 121 GTK_IS_WIDGET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 GTK_IS_WINDOW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 GTK_ITEM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 GTK_ITEM_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 gtk_item_deselect . . . . . . . . . . . . . . . . . . . . . . . . . . 74 gtk_item_get_type . . . . . . . . . . . . . . . . . . . . . . . . . . 74 gtk_item_select . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 gtk_item_toggle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 GTK_LABEL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 GTK_LABEL_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 gtk_label_get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 gtk_label_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 75 gtk_label_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 gtk_label_set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 GTK_LIST. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 gtk_list_append_items . . . . . . . . . . . . . . . . . . . . . 76

                                                gtk_list_child_position . . . . . . . . . . . . . . . . . . . 76

GTK_LIST_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 gtk_list_clear_items. . . . . . . . . . . . . . . . . . . . . . . 76 gtk_list_get_type . . . . . . . . . . . . . . . . . . . . . . . . . . 76 gtk_list_insert_items . . . . . . . . . . . . . . . . . . . . . 76 GTK_LIST_ITEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 GTK_LIST_ITEM_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 78

                                                gtk_list_item_deselect . . . . . . . . . . . . . . . . . . . . 78
                                                gtk_list_item_get_type . . . . . . . . . . . . . . . . . . . . 78

gtk_list_item_new . . . . . . . . . . . . . . . . . . . . . . . . . . 78

                                                gtk_list_item_new_with_label . . . . . . . . . . . . . . 78

gtk_list_item_select. . . . . . . . . . . . . . . . . . . . . . . 78 gtk_list_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

                                                gtk_list_prepend_items . . . . . . . . . . . . . . . . . . . . 76

gtk_list_remove_items . . . . . . . . . . . . . . . . . . . . . 76 gtk_list_select_child . . . . . . . . . . . . . . . . . . . . . 76 gtk_list_select_item. . . . . . . . . . . . . . . . . . . . . . . 76

                                                gtk_list_set_selection_mode . . . . . . . . . . . . . . . 76
                                                gtk_list_unselect_child . . . . . . . . . . . . . . . . . . . 76

gtk_list_unselect_item . . . . . . . . . . . . . . . . . . . . 76

gtk_main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 gtk_main_level . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 gtk_main_quit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 GTK_MENU. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 gtk_menu_append . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 GTK_MENU_BAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 gtk_menu_bar_append. . . . . . . . . . . . . . . . . . . . . . . . 80 GTK_MENU_BAR_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . 80 gtk_menu_bar_get_type . . . . . . . . . . . . . . . . . . . . . 80 gtk_menu_bar_insert. . . . . . . . . . . . . . . . . . . . . . . . 80 gtk_menu_bar_new . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 gtk_menu_bar_prepend. . . . . . . . . . . . . . . . . . . . . . . 80 GTK_MENU_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 gtk_menu_get_active. . . . . . . . . . . . . . . . . . . . . . . . 79 gtk_menu_get_type . . . . . . . . . . . . . . . . . . . . . . . . . . 79 gtk_menu_insert . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 GTK_MENU_ITEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

gtk_menu_item_accelerator_size . . . . . . . . . . . . 81
gtk_menu_item_accelerator_text . . . . . . . . . . . . 81
gtk_menu_item_activate . . . . . . . . . . . . . . . . . . . . 81

GTK_MENU_ITEM_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 82

gtk_menu_item_configure . . . . . . . . . . . . . . . . . . . 81
gtk_menu_item_deselect . . . . . . . . . . . . . . . . . . . . 81
gtk_menu_item_get_type . . . . . . . . . . . . . . . . . . . . 81

gtk_menu_item_new . . . . . . . . . . . . . . . . . . . . . . . . . . 81

gtk_menu_item_new_with_label . . . . . . . . . . . . . . 81

gtk_menu_item_select. . . . . . . . . . . . . . . . . . . . . . . 81

gtk_menu_item_set_placement . . . . . . . . . . . . . . . 81
gtk_menu_item_set_submenu . . . . . . . . . . . . . . . . . 81

gtk_menu_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 gtk_menu_popdown . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 gtk_menu_popup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 gtk_menu_prepend . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

gtk_menu_set_accelerator_table . . . . . . . . . . . . 79

gtk_menu_set_active. . . . . . . . . . . . . . . . . . . . . . . . 79 GTK_MENU_SHELL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 gtk_menu_shell_append . . . . . . . . . . . . . . . . . . . . . 83 GTK_MENU_SHELL_CLASS. . . . . . . . . . . . . . . . . . . . . . . 83

gtk_menu_shell_deactivate . . . . . . . . . . . . . . . . . 83
gtk_menu_shell_get_type . . . . . . . . . . . . . . . . . . . 83

gtk_menu_shell_insert . . . . . . . . . . . . . . . . . . . . . 83

gtk_menu_shell_prepend . . . . . . . . . . . . . . . . . . . . 83

GTK_MISC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 GTK_MISC_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 gtk_misc_get_type . . . . . . . . . . . . . . . . . . . . . . . . . . 84

gtk_misc_set_alignment . . . . . . . . . . . . . . . . . . . . 84

gtk_misc_set_padding. . . . . . . . . . . . . . . . . . . . . . . 84 GTK_NOTEBOOK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

                                                gtk_notebook_append_page . . . . . . . . . . . . . . . . . . 85

GTK_NOTEBOOK_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . 86 gtk_notebook_get_type . . . . . . . . . . . . . . . . . . . . . 85

                                                gtk_notebook_insert_page . . . . . . . . . . . . . . . . . . 85

gtk_notebook_new . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

                                                gtk_notebook_next_page . . . . . . . . . . . . . . . . . . . . 85
                                                gtk_notebook_prepend_page . . . . . . . . . . . . . . . . . 85
                                                gtk_notebook_prev_page . . . . . . . . . . . . . . . . . . . . 85
                                                gtk_notebook_remove_page . . . . . . . . . . . . . . . . . . 85

gtk_notebook_set_page . . . . . . . . . . . . . . . . . . . . . 85

                                                gtk_notebook_set_show_border . . . . . . . . . . . . . . 85
                                                gtk_notebook_set_show_tabs . . . . . . . . . . . . . . . . 85
                                                gtk_notebook_set_tab_pos . . . . . . . . . . . . . . . . . . 85
                                                gtk_object_add_arg_type . . . . . . . . . . . . . . . . . . . 15
                                                gtk_object_class_add_signals . . . . . . . . . . . . . . 15

gtk_object_destroy . . . . . . . . . . . . . . . . . . . . . . . . . 15

                                                gtk_object_get_arg_type . . . . . . . . . . . . . . . . . . . 15

gtk_object_get_data. . . . . . . . . . . . . . . . . . . . . . . . 16 gtk_object_get_type. . . . . . . . . . . . . . . . . . . . . . . . 15

                                                gtk_object_get_user_data . . . . . . . . . . . . . . . . . . 16

gtk_object_getv . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 gtk_object_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 gtk_object_newv . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 gtk_object_peek_value . . . . . . . . . . . . . . . . . . . . . 17 gtk_object_pop_value. . . . . . . . . . . . . . . . . . . . . . . 16 gtk_object_push_value . . . . . . . . . . . . . . . . . . . . . 16 gtk_object_query_args . . . . . . . . . . . . . . . . . . . . . 15 gtk_object_ref . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

                                                gtk_object_remove_data . . . . . . . . . . . . . . . . . . . . 16

gtk_object_set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 gtk_object_set_data. . . . . . . . . . . . . . . . . . . . . . . . 16

                                                gtk_object_set_user_data . . . . . . . . . . . . . . . . . . 16

gtk_object_setv . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 gtk_object_unref . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

                                                gtk_object_value_stack_new . . . . . . . . . . . . . . . . 16

GTK_OPTION_MENU . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 GTK_OPTION_MENU_CLASS . . . . . . . . . . . . . . . . . . . . . 87

                                                gtk_option_menu_get_menu . . . . . . . . . . . . . . . . . . 87
                                                gtk_option_menu_get_type . . . . . . . . . . . . . . . . . . 87

gtk_option_menu_new. . . . . . . . . . . . . . . . . . . . . . . . 87

                                                gtk_option_menu_remove_menu . . . . . . . . . . . . . . . 87
                                                gtk_option_menu_set_history . . . . . . . . . . . . . . . 87
                                                gtk_option_menu_set_menu . . . . . . . . . . . . . . . . . . 87

GTK_PANED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 gtk_paned_add1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 gtk_paned_add2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 GTK_PANED_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

160 GTK

gtk_paned_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 88 gtk_paned_gutter_size . . . . . . . . . . . . . . . . . . . . . 88 gtk_paned_handle_size . . . . . . . . . . . . . . . . . . . . . 88 GTK_PIXMAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 GTK_PIXMAP_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 gtk_pixmap_get . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 gtk_pixmap_get_type. . . . . . . . . . . . . . . . . . . . . . . . 89 gtk_pixmap_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 gtk_pixmap_set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 GTK_PREVIEW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 GTK_PREVIEW_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . 91 gtk_preview_draw_row. . . . . . . . . . . . . . . . . . . . . . . 90 gtk_preview_get_cmap. . . . . . . . . . . . . . . . . . . . . . . 91 gtk_preview_get_info. . . . . . . . . . . . . . . . . . . . . . . 91 gtk_preview_get_type. . . . . . . . . . . . . . . . . . . . . . . 90

gtk_preview_get_visual . . . . . . . . . . . . . . . . . . . . 91

gtk_preview_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 gtk_preview_put . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 gtk_preview_put_row. . . . . . . . . . . . . . . . . . . . . . . . 90

gtk_preview_set_color_cube . . . . . . . . . . . . . . . . 91
gtk_preview_set_expand . . . . . . . . . . . . . . . . . . . . 90

gtk_preview_set_gamma . . . . . . . . . . . . . . . . . . . . . 90

gtk_preview_set_install_cmap . . . . . . . . . . . . . . 91
gtk_preview_set_reserved . . . . . . . . . . . . . . . . . . 91

gtk_preview_size . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 gtk_preview_uninit . . . . . . . . . . . . . . . . . . . . . . . . . 90 GTK_PROGRESS_BAR . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

GTK_PROGRESS_BAR_CLASS . . . . . . . . . . . . . . . . . . . . 92
gtk_progress_bar_get_type . . . . . . . . . . . . . . . . . 92

gtk_progress_bar_new. . . . . . . . . . . . . . . . . . . . . . . 92

gtk_progress_bar_update . . . . . . . . . . . . . . . . . . . 92

GTK_RADIO_BUTTON . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

GTK_RADIO_BUTTON_CLASS . . . . . . . . . . . . . . . . . . . . 93
gtk_radio_button_get_type . . . . . . . . . . . . . . . . . 93
gtk_radio_button_group . . . . . . . . . . . . . . . . . . . . 93

gtk_radio_button_new. . . . . . . . . . . . . . . . . . . . . . . 93

gtk_radio_button_new_with_label . . . . . . . . . . . 93

GTK_RADIO_MENU_ITEM. . . . . . . . . . . . . . . . . . . . . . . . 94

GTK_RADIO_MENU_ITEM_CLASS . . . . . . . . . . . . . . . . . 94
gtk_radio_menu_item_get_type . . . . . . . . . . . . . . 94
gtk_radio_menu_item_group . . . . . . . . . . . . . . . . . 94
gtk_radio_menu_item_new . . . . . . . . . . . . . . . . . . . 94
gtk_radio_menu_item_new_with_label . . . . . . . 94

GTK_RANGE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 gtk_range_calc_value. . . . . . . . . . . . . . . . . . . . . . . 96 GTK_RANGE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

gtk_range_default_hmotion . . . . . . . . . . . . . . . . . 96
gtk_range_default_hslider_update. . . . . . . . . . 95

                                                gtk_range_default_htrough_click . . . . . . . . . . . 95
                                                gtk_range_default_vmotion . . . . . . . . . . . . . . . . . 96
                                                gtk_range_default_vslider_update. . . . . . . . . . 95
                                                gtk_range_default_vtrough_click . . . . . . . . . . . 95
                                                gtk_range_draw_background . . . . . . . . . . . . . . . . . 95

gtk_range_draw_slider . . . . . . . . . . . . . . . . . . . . . 95

                                                gtk_range_draw_step_back . . . . . . . . . . . . . . . . . . 95
                                                gtk_range_draw_step_forw . . . . . . . . . . . . . . . . . . 95

gtk_range_draw_trough . . . . . . . . . . . . . . . . . . . . . 95

                                                gtk_range_get_adjustment . . . . . . . . . . . . . . . . . . 95

gtk_range_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 95

                                                gtk_range_set_adjustment . . . . . . . . . . . . . . . . . . 95
                                                gtk_range_set_update_policy . . . . . . . . . . . . . . . 95
                                                gtk_range_slider_update . . . . . . . . . . . . . . . . . . . 95
                                                gtk_range_trough_click . . . . . . . . . . . . . . . . . . . . 95

gtk_rc_init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 gtk_rc_parse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 GTK_RULER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 GTK_RULER_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 gtk_ruler_draw_pos . . . . . . . . . . . . . . . . . . . . . . . . . 97 gtk_ruler_draw_ticks. . . . . . . . . . . . . . . . . . . . . . . 97 gtk_ruler_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 97 gtk_ruler_set_metric. . . . . . . . . . . . . . . . . . . . . . . 97 gtk_ruler_set_range. . . . . . . . . . . . . . . . . . . . . . . . 97 GTK_SCALE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 GTK_SCALE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 gtk_scale_draw_value. . . . . . . . . . . . . . . . . . . . . . . 98 gtk_scale_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 98 gtk_scale_set_digits. . . . . . . . . . . . . . . . . . . . . . . 98

                                                gtk_scale_set_draw_value . . . . . . . . . . . . . . . . . . 98
                                                gtk_scale_set_value_pos . . . . . . . . . . . . . . . . . . . 98

gtk_scale_value_width . . . . . . . . . . . . . . . . . . . . . 98 GTK_SCROLLBAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 GTK_SCROLLBAR_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 99

                                                gtk_scrollbar_get_type . . . . . . . . . . . . . . . . . . . . 99

GTK_SCROLLED_WINDOW. . . . . . . . . . . . . . . . . . . . . . . 100

                                                GTK_SCROLLED_WINDOW_CLASS . . . . . . . . . . . . . . . . 100
                                                gtk_scrolled_window_get_hadjustment . . . . . 100
                                                gtk_scrolled_window_get_type . . . . . . . . . . . . . 100
                                                gtk_scrolled_window_get_vadjustment . . . . . 100
                                                gtk_scrolled_window_new . . . . . . . . . . . . . . . . . . 100
                                                gtk_scrolled_window_set_policy . . . . . . . . . . . 100

GTK_SEPARATOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 GTK_SEPARATOR_CLASS. . . . . . . . . . . . . . . . . . . . . . . 101

                                                gtk_separator_get_type . . . . . . . . . . . . . . . . . . . 101

gtk_signal_connect . . . . . . . . . . . . . . . . . . . . . . . . . 21

                                                gtk_signal_connect_after . . . . . . . . . . . . . . . . . . 21
                                                gtk_signal_connect_interp . . . . . . . . . . . . . . . . . 22

gtk_signal_connect_object . . . . . . . . . . . . . . . . . 21
gtk_signal_connect_object_after . . . . . . . . . . . 22
gtk_signal_default_marshaller . . . . . . . . . . . . . 23

gtk_signal_disconnect . . . . . . . . . . . . . . . . . . . . . 22

gtk_signal_disconnect_by_data . . . . . . . . . . . . . 22

gtk_signal_emit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

gtk_signal_emit_by_name . . . . . . . . . . . . . . . . . . . 21

gtk_signal_emit_stop. . . . . . . . . . . . . . . . . . . . . . . 21

gtk_signal_emit_stop_by_name . . . . . . . . . . . . . . 21
gtk_signal_handler_block . . . . . . . . . . . . . . . . . . 22
gtk_signal_handler_block_by_data. . . . . . . . . . 22
gtk_signal_handler_unblock . . . . . . . . . . . . . . . . 23
gtk_signal_handler_unblock_by_data . . . . . . . 23
gtk_signal_handlers_destroy . . . . . . . . . . . . . . . 23

gtk_signal_lookup . . . . . . . . . . . . . . . . . . . . . . . . . . 20 gtk_signal_name . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 gtk_signal_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 gtk_signal_set_funcs. . . . . . . . . . . . . . . . . . . . . . . 23 GTK_STATUSBAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 GTK_STATUSBAR_CLASS. . . . . . . . . . . . . . . . . . . . . . . 102

gtk_statusbar_get_type . . . . . . . . . . . . . . . . . . . 102

gtk_statusbar_new . . . . . . . . . . . . . . . . . . . . . . . . . 102 gtk_statusbar_pop . . . . . . . . . . . . . . . . . . . . . . . . . 102 gtk_statusbar_push. . . . . . . . . . . . . . . . . . . . . . . . 102 GTK_TABLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 gtk_table_attach . . . . . . . . . . . . . . . . . . . . . . . . . . 103

gtk_table_attach_defaults . . . . . . . . . . . . . . . . 103

GTK_TABLE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 gtk_table_get_type. . . . . . . . . . . . . . . . . . . . . . . . 103 gtk_table_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

gtk_table_set_col_spacing . . . . . . . . . . . . . . . . 103
gtk_table_set_col_spacings . . . . . . . . . . . . . . . 103
gtk_table_set_row_spacing . . . . . . . . . . . . . . . . 103
gtk_table_set_row_spacings . . . . . . . . . . . . . . . 103

GTK_TEXT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

gtk_text_backward_delete . . . . . . . . . . . . . . . . . 105

GTK_TEXT_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

gtk_text_forward_delete . . . . . . . . . . . . . . . . . . 105

gtk_text_freeze . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 gtk_text_get_length. . . . . . . . . . . . . . . . . . . . . . . 105 gtk_text_get_point. . . . . . . . . . . . . . . . . . . . . . . . 105 gtk_text_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 105 gtk_text_insert . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 gtk_text_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

gtk_text_set_adjustments . . . . . . . . . . . . . . . . . 105

gtk_text_set_editable . . . . . . . . . . . . . . . . . . . . 105 gtk_text_set_point. . . . . . . . . . . . . . . . . . . . . . . . 105 gtk_text_thaw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 GTK_TOGGLE_BUTTON . . . . . . . . . . . . . . . . . . . . . . . . . 106

                                                GTK_TOGGLE_BUTTON_CLASS . . . . . . . . . . . . . . . . . . 106
                                                gtk_toggle_button_get_type . . . . . . . . . . . . . . . 106

gtk_toggle_button_new . . . . . . . . . . . . . . . . . . . . 106

                                                gtk_toggle_button_new_with_label. . . . . . . . . 106
                                                gtk_toggle_button_set_mode . . . . . . . . . . . . . . . 106
                                                gtk_toggle_button_set_state . . . . . . . . . . . . . . 106
                                                gtk_toggle_button_toggled . . . . . . . . . . . . . . . . 106

GTK_TOOLBAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

                                                gtk_toolbar_append_item . . . . . . . . . . . . . . . . . . 108
                                                gtk_toolbar_append_space . . . . . . . . . . . . . . . . . 108

GTK_TOOLBAR_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . 109 gtk_toolbar_get_type. . . . . . . . . . . . . . . . . . . . . . 108

                                                gtk_toolbar_insert_item . . . . . . . . . . . . . . . . . . 108
                                                gtk_toolbar_insert_space . . . . . . . . . . . . . . . . . 109

gtk_toolbar_new . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

                                                gtk_toolbar_prepend_item . . . . . . . . . . . . . . . . . 108
                                                gtk_toolbar_prepend_space . . . . . . . . . . . . . . . . 108
                                                gtk_toolbar_set_orientation . . . . . . . . . . . . . . 109
                                                gtk_toolbar_set_space_size . . . . . . . . . . . . . . . 109

gtk_toolbar_set_style . . . . . . . . . . . . . . . . . . . . 109

                                                gtk_toolbar_set_tooltips . . . . . . . . . . . . . . . . . 109

GTK_TOOLTIPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 GTK_TOOLTIPS_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 110 gtk_tooltips_disable. . . . . . . . . . . . . . . . . . . . . . 110 gtk_tooltips_enable. . . . . . . . . . . . . . . . . . . . . . . 110

                                                gtk_tooltips_free_string . . . . . . . . . . . . . . . . . 110

gtk_tooltips_new . . . . . . . . . . . . . . . . . . . . . . . . . . 110 gtk_tooltips_ref . . . . . . . . . . . . . . . . . . . . . . . . . . 110

                                                gtk_tooltips_set_colors . . . . . . . . . . . . . . . . . . 110
                                                gtk_tooltips_set_delay . . . . . . . . . . . . . . . . . . . 110

gtk_tooltips_unref. . . . . . . . . . . . . . . . . . . . . . . . 110 GTK_TREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 gtk_tree_append . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

                                                gtk_tree_child_position . . . . . . . . . . . . . . . . . . 111

GTK_TREE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 gtk_tree_clear_items. . . . . . . . . . . . . . . . . . . . . . 111 gtk_tree_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 111 gtk_tree_insert . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 GTK_TREE_ITEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 GTK_TREE_ITEM_CLASS. . . . . . . . . . . . . . . . . . . . . . . 113

                                                gtk_tree_item_collapse . . . . . . . . . . . . . . . . . . . 113
                                                gtk_tree_item_deselect . . . . . . . . . . . . . . . . . . . 113

gtk_tree_item_expand. . . . . . . . . . . . . . . . . . . . . . 113

                                                gtk_tree_item_get_type . . . . . . . . . . . . . . . . . . . 113

gtk_tree_item_new . . . . . . . . . . . . . . . . . . . . . . . . . 113

                                                gtk_tree_item_new_with_label . . . . . . . . . . . . . 113
                                                gtk_tree_item_remove_subtree . . . . . . . . . . . . . 113

162 GTK

gtk_tree_item_select. . . . . . . . . . . . . . . . . . . . . . 113

gtk_tree_item_set_subtree . . . . . . . . . . . . . . . . 113

gtk_tree_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 gtk_tree_prepend . . . . . . . . . . . . . . . . . . . . . . . . . . 111 gtk_tree_remove_items . . . . . . . . . . . . . . . . . . . . 111 gtk_tree_select_child . . . . . . . . . . . . . . . . . . . . 111 gtk_tree_select_item. . . . . . . . . . . . . . . . . . . . . . 111

gtk_tree_set_selection_mode . . . . . . . . . . . . . . 111
gtk_tree_set_view_lines . . . . . . . . . . . . . . . . . . 111
gtk_tree_set_view_mode . . . . . . . . . . . . . . . . . . . 111
gtk_tree_unselect_child . . . . . . . . . . . . . . . . . . 111
gtk_tree_unselect_item . . . . . . . . . . . . . . . . . . . 111

gtk_type_class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

gtk_type_describe_heritage . . . . . . . . . . . . . . . . 12
gtk_type_describe_tree . . . . . . . . . . . . . . . . . . . . 12

gtk_type_from_name . . . . . . . . . . . . . . . . . . . . . . . . . 11 gtk_type_is_a . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 gtk_type_name . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 gtk_type_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 gtk_type_parent . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 GTK_TYPE_SEQNO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 gtk_type_unique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 GTK_VBOX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 GTK_VBOX_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 gtk_vbox_get_type . . . . . . . . . . . . . . . . . . . . . . . . . 114 gtk_vbox_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 GTK_VBUTTON_BOX . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 GTK_VBUTTON_BOX_CLASS . . . . . . . . . . . . . . . . . . . . 115

gtk_vbutton_box_get_layout_default . . . . . . 115
gtk_vbutton_box_get_spacing_default . . . . . 115
gtk_vbutton_box_get_type . . . . . . . . . . . . . . . . . 115

gtk_vbutton_box_new. . . . . . . . . . . . . . . . . . . . . . . 115

gtk_vbutton_box_set_layout_default . . . . . . 115
gtk_vbutton_box_set_spacing_default . . . . . 115

GTK_VIEWPORT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 GTK_VIEWPORT_CLASS. . . . . . . . . . . . . . . . . . . . . . . . 116

gtk_viewport_get_hadjustment . . . . . . . . . . . . . 116

gtk_viewport_get_type . . . . . . . . . . . . . . . . . . . . 116

gtk_viewport_get_vadjustment . . . . . . . . . . . . . 116

gtk_viewport_new . . . . . . . . . . . . . . . . . . . . . . . . . . 116

gtk_viewport_set_hadjustment . . . . . . . . . . . . . 116
gtk_viewport_set_shadow_type . . . . . . . . . . . . . 116
gtk_viewport_set_vadjustment . . . . . . . . . . . . . 116

GTK_VPANED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 GTK_VPANED_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . 117 gtk_vpaned_get_type. . . . . . . . . . . . . . . . . . . . . . . 117 gtk_vpaned_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 GTK_VRULER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 GTK_VRULER_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . 118 gtk_vruler_get_type. . . . . . . . . . . . . . . . . . . . . . . 118 gtk_vruler_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 GTK_VSCALE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 GTK_VSCALE_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . 119 gtk_vscale_get_type. . . . . . . . . . . . . . . . . . . . . . . 119 gtk_vscale_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 GTK_VSCROLLBAR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 GTK_VSCROLLBAR_CLASS. . . . . . . . . . . . . . . . . . . . . . 120

                                                gtk_vscrollbar_get_type . . . . . . . . . . . . . . . . . . 120

gtk_vscrollbar_new. . . . . . . . . . . . . . . . . . . . . . . . 120 GTK_VSEPARATOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 GTK_VSEPARATOR_CLASS. . . . . . . . . . . . . . . . . . . . . . 121

                                                gtk_vseparator_get_type . . . . . . . . . . . . . . . . . . 121

gtk_vseparator_new. . . . . . . . . . . . . . . . . . . . . . . . 121 GTK_WIDGET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 GTK_WIDGET_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . 126 gtk_widget_class_init . . . . . . . . . . . . . . . . . . . . 124 gtk_widget_destroy. . . . . . . . . . . . . . . . . . . . . . . . 124 gtk_widget_draw . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

                                                gtk_widget_draw_children . . . . . . . . . . . . . . . . . 124

gtk_widget_draw_focus . . . . . . . . . . . . . . . . . . . . 124 gtk_widget_event . . . . . . . . . . . . . . . . . . . . . . . . . . 125

                                                gtk_widget_get_ancestor . . . . . . . . . . . . . . . . . . 125
                                                gtk_widget_get_colormap . . . . . . . . . . . . . . . . . . 125

gtk_widget_get_style. . . . . . . . . . . . . . . . . . . . . . 125

                                                gtk_widget_get_toplevel . . . . . . . . . . . . . . . . . . 125

gtk_widget_get_type. . . . . . . . . . . . . . . . . . . . . . . 124 gtk_widget_get_visual . . . . . . . . . . . . . . . . . . . . 125

                                                gtk_widget_grab_default . . . . . . . . . . . . . . . . . . 125

gtk_widget_grab_focus . . . . . . . . . . . . . . . . . . . . 125 gtk_widget_hide . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 gtk_widget_init . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

                                                gtk_widget_install_accelerator . . . . . . . . . . . 124

gtk_widget_intersect. . . . . . . . . . . . . . . . . . . . . . 125 gtk_widget_map . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 gtk_widget_popup . . . . . . . . . . . . . . . . . . . . . . . . . . 125 gtk_widget_realize. . . . . . . . . . . . . . . . . . . . . . . . 124

                                                gtk_widget_remove_accelerator . . . . . . . . . . . . 124

gtk_widget_reparent. . . . . . . . . . . . . . . . . . . . . . . 125

                                                gtk_widget_restore_state . . . . . . . . . . . . . . . . . 125

gtk_widget_set_name. . . . . . . . . . . . . . . . . . . . . . . 125 gtk_widget_set_parent . . . . . . . . . . . . . . . . . . . . 125

                                                gtk_widget_set_sensitive . . . . . . . . . . . . . . . . . 125

gtk_widget_set_state. . . . . . . . . . . . . . . . . . . . . . 125 gtk_widget_set_style. . . . . . . . . . . . . . . . . . . . . . 125

                                                gtk_widget_set_uposition . . . . . . . . . . . . . . . . . 125

gtk_widget_set_usize. . . . . . . . . . . . . . . . . . . . . . 125 gtk_widget_show . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

gtk_widget_size_allocate . . . . . . . . . . . . . . . . . 124
gtk_widget_size_request . . . . . . . . . . . . . . . . . . 124

gtk_widget_unmap . . . . . . . . . . . . . . . . . . . . . . . . . . 124 gtk_widget_unrealize. . . . . . . . . . . . . . . . . . . . . . 124 GTK_WINDOW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

gtk_window_add_accelerator_table. . . . . . . . . 128

GTK_WINDOW_CLASS . . . . . . . . . . . . . . . . . . . . . . . . . . 129 gtk_window_get_type. . . . . . . . . . . . . . . . . . . . . . . 128 gtk_window_new . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 gtk_window_position. . . . . . . . . . . . . . . . . . . . . . . 129

gtk_window_remove_accelerator_table . . . . . 128
gtk_window_set_default . . . . . . . . . . . . . . . . . . . 128

gtk_window_set_focus. . . . . . . . . . . . . . . . . . . . . . 128 gtk_window_set_policy . . . . . . . . . . . . . . . . . . . . 128 gtk_window_set_title. . . . . . . . . . . . . . . . . . . . . . 128 GtkButton::clicked . . . . . . . . . . . . . . . . . . . . . . . . . 37 GtkButton::enter . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 GtkButton::leave . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 GtkButton::pressed . . . . . . . . . . . . . . . . . . . . . . . . . 37 GtkButton::released. . . . . . . . . . . . . . . . . . . . . . . . 37

GtkCheckMenuItem::toggled . . . . . . . . . . . . . . . . . 40

GtkContainer::add . . . . . . . . . . . . . . . . . . . . . . . . . . 49 GtkContainer::focus. . . . . . . . . . . . . . . . . . . . . . . . 49 GtkContainer::foreach . . . . . . . . . . . . . . . . . . . . . 49

GtkContainer::need_resize . . . . . . . . . . . . . . . . . 49

GtkContainer::remove. . . . . . . . . . . . . . . . . . . . . . . 49

GtkCTree::tree_collapse . . . . . . . . . . . . . . . . . . . 51

GtkCTree::tree_expand . . . . . . . . . . . . . . . . . . . . . 51 GtkCTree::tree_move. . . . . . . . . . . . . . . . . . . . . . . . 51

GtkCTree::tree_select_row . . . . . . . . . . . . . . . . . 51
GtkCTree::tree_unselect_row . . . . . . . . . . . . . . . 51

GtkEntry::activate . . . . . . . . . . . . . . . . . . . . . . . . . 58 GtkEntry::changed . . . . . . . . . . . . . . . . . . . . . . . . . . 58 GtkEntry::delete_text . . . . . . . . . . . . . . . . . . . . . 58 GtkEntry::insert_text . . . . . . . . . . . . . . . . . . . . . 58 GtkEntry::set_text . . . . . . . . . . . . . . . . . . . . . . . . . 58

GtkInputDialog::disable_device . . . . . . . . . . . . 73
GtkInputDialog::enable_device . . . . . . . . . . . . . 73

GtkItem::deselect . . . . . . . . . . . . . . . . . . . . . . . . . . 74 GtkItem::select . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 GtkItem::toggle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 GtkList::select_child . . . . . . . . . . . . . . . . . . . . . 76

GtkList::selection_changed . . . . . . . . . . . . . . . . 76

                                                GtkList::unselect_child . . . . . . . . . . . . . . . . . . . 76

GtkMenuItem::activate . . . . . . . . . . . . . . . . . . . . . 81

                                                GtkMenuShell::deactivate . . . . . . . . . . . . . . . . . . 83
                                                GtkToggleButton::toggled . . . . . . . . . . . . . . . . . 106
                                                GtkWidget::button_press_event . . . . . . . . . . . . 122
                                                GtkWidget::button_release_event. . . . . . . . . . 122
                                                GtkWidget::configure_event . . . . . . . . . . . . . . . 123
                                                GtkWidget::delete_event . . . . . . . . . . . . . . . . . . 123
                                                GtkWidget::destroy_event . . . . . . . . . . . . . . . . . 123
                                                GtkWidget::drag_begin_event . . . . . . . . . . . . . . 124

GtkWidget::draw . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

                                                GtkWidget::draw_default . . . . . . . . . . . . . . . . . . 122

GtkWidget::draw_focus . . . . . . . . . . . . . . . . . . . . 122 GtkWidget::drop_event . . . . . . . . . . . . . . . . . . . . 123

                                                GtkWidget::enter_notify_event . . . . . . . . . . . . 123

GtkWidget::event . . . . . . . . . . . . . . . . . . . . . . . . . . 122

                                                GtkWidget::expose_event . . . . . . . . . . . . . . . . . . 123
                                                GtkWidget::focus_in_event . . . . . . . . . . . . . . . . 123
                                                GtkWidget::focus_out_event . . . . . . . . . . . . . . . 123

GtkWidget::hide . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

                                                GtkWidget::install_accelerator . . . . . . . . . . . 122
                                                GtkWidget::key_press_event . . . . . . . . . . . . . . . 123
                                                GtkWidget::key_release_event . . . . . . . . . . . . . 123
                                                GtkWidget::leave_notify_event . . . . . . . . . . . . 123

GtkWidget::map . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 GtkWidget::map_event. . . . . . . . . . . . . . . . . . . . . . 123

                                                GtkWidget::motion_notify_event . . . . . . . . . . . 122
                                                GtkWidget::other_event . . . . . . . . . . . . . . . . . . . 124
                                                GtkWidget::property_notify_event. . . . . . . . . 123

GtkWidget::realize. . . . . . . . . . . . . . . . . . . . . . . . 122

                                                GtkWidget::remove_accelerator . . . . . . . . . . . . 122
                                                GtkWidget::selection_clear_event. . . . . . . . . 123
                                                GtkWidget::selection_notify_event . . . . . . . 123
                                                GtkWidget::selection_request_event . . . . . . 123

GtkWidget::show . . . . . . . . . . . . . . . . . . . . . . . . . . . 122

                                                GtkWidget::size_allocate . . . . . . . . . . . . . . . . . 122
                                                GtkWidget::size_request . . . . . . . . . . . . . . . . . . 122
                                                GtkWidget::state_changed . . . . . . . . . . . . . . . . . 122

GtkWidget::unmap . . . . . . . . . . . . . . . . . . . . . . . . . . 122

                                                GtkWidget::unmap_event . . . . . . . . . . . . . . . . . . . 123

GtkWidget::unrealize. . . . . . . . . . . . . . . . . . . . . . 122

                                                GtkWindow::move_resize . . . . . . . . . . . . . . . . . . . 128

GtkWindow::set_focus. . . . . . . . . . . . . . . . . . . . . . 128

164 GTK Concept Index 165

Concept Index

C

class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 Copying. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

O

Object Implementation. . . . . . . . . . . . . . . . . . . . . . 149 Overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

S

Signal Implementation . . . . . . . . . . . . . . . . . . . . . . 151 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

T

type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 type system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

U

Using GTK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

W

Widget Implementation . . . . . . . . . . . . . . . . . . . . . 153 Widgets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

166 GTK

Short Contents

The GIMP Toolkit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2 What is GTK? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 3 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 4 Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 5 Signals Overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 6 Widget Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 7 Utility objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 8 Initialization, exit and other features . . . . . . . . . . . . . . . . 137 9 Using GTK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 10 Object internals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 11 Signal internals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 12 Widget internals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 Function Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Concept Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165

Table of Contents

The GIMP Toolkit . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1 Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 What is GTK? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

3.1 Introduction to the Type System . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.2 Basic Concepts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 3.3 Simple Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 3.4 Enumerations and Flags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.5 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.6 Boxed Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.7 Callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.8 Composite Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

4 Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

4.1 Object functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

5 Signals Overview . . . . . . . . . . . . . . . . . . . . . . . . . 19

6 Widget Overview . . . . . . . . . . . . . . . . . . . . . . . . . 25

6.1 The alignment widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 6.1.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 6.1.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 6.1.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 6.1.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

6.2 The arrow widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 6.2.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 6.2.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 6.2.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 6.2.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6.3 The aspect frame widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 6.3.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 6.3.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 6.3.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 6.3.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

6.4 The bin widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 6.4.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 6.4.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 6.4.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

6.4.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 6.5 The box widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

6.5.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 6.5.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 6.5.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 6.5.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

6.6 The button box widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 6.6.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 6.6.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 6.6.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 6.6.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

6.7 The button widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.7.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.7.2 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.7.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

6.8 The check button widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6.8.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6.8.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6.8.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6.8.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

6.9 The check menu item widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.9.1 Description. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.9.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.9.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.9.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

6.10 The compound list widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 6.10.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 6.10.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 6.10.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 6.10.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

6.11 The color selector widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 6.11.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 6.11.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 6.11.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 6.11.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6.12 The combo widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 6.12.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 6.12.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 6.12.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 6.12.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

6.13 The container widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 6.13.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 6.13.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 6.13.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 6.13.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

6.14 The multi-column tree widget . . . . . . . . . . . . . . . . . . . . . . . . . . 51 6.14.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 6.14.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 6.14.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 6.14.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6.15 The curve widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6.15.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6.15.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6.15.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 6.15.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

6.16 The gamma curve widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 6.16.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 6.16.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 6.16.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 6.16.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6.17 The dialog widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.17.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.17.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.17.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.17.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

6.18 The drawing area widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 6.18.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 6.18.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 6.18.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 6.18.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

6.19 The entry widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.19.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.19.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.19.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 6.19.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6.20 The event box widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 6.20.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 6.20.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 6.20.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 6.20.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6.21 The file selection dialog widget . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.21.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.21.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.21.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 6.21.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

6.22 The fixed widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.22.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.22.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.22.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 6.22.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

6.23 The frame widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 6.23.1 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 6.23.2 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 6.23.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 6.23.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63

6.24 The gamma widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 6.24.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 6.24.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 6.24.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 6.24.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

6.25 The horizontal box widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.25.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.25.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.25.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 6.25.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

6.26 The horizontal button box widget . . . . . . . . . . . . . . . . . . . . . . 66 6.26.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 6.26.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 6.26.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 6.26.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

6.27 The horizontal paned widget . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.27.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.27.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.27.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 6.27.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

6.28 The horizontal ruler widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 6.28.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 6.28.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 6.28.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 6.28.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

6.29 The horizontal scale widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6.29.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6.29.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6.29.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6.29.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

6.30 The horizontal scrollbar widget. . . . . . . . . . . . . . . . . . . . . . . . . 70 6.30.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 6.30.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 6.30.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 6.30.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

6.31 The horizontal separator widget . . . . . . . . . . . . . . . . . . . . . . . . 71 6.31.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 6.31.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 6.31.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 6.31.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

6.32 The image widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 6.32.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 6.32.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 6.32.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 6.32.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

6.33 The input dialog widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 6.33.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 6.33.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 6.33.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

6.33.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 6.34 The item widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

6.34.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 6.34.2 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 6.34.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

6.35 The label widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 6.35.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 6.35.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 6.35.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 6.35.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

6.36 The list widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 6.36.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 6.36.2 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 6.36.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

6.37 The list item widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 6.37.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 6.37.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 6.37.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 6.37.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

6.38 The menu widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 6.38.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 6.38.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 6.38.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 6.38.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

6.39 The menu bar widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 6.39.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 6.39.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 6.39.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 6.39.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

6.40 The menu item widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 6.40.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 6.40.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 6.40.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 6.40.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

6.41 The menu shell widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 6.41.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 6.41.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 6.41.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 6.41.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

6.42 The misc widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 6.42.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 6.42.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 6.42.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 6.42.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

6.43 The notebook widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 6.43.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 6.43.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 6.43.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

6.43.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85 6.44 The option menu widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.44.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 6.44.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 6.44.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87 6.44.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

6.45 The paned widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 6.45.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 6.45.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 6.45.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 6.45.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

6.46 The pixmap widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 6.46.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 6.46.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 6.46.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 6.46.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

6.47 The preview widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 6.47.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 6.47.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 6.47.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 6.47.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

6.48 The progress bar widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 6.48.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 6.48.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 6.48.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 6.48.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

6.49 The radio button widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 6.49.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 6.49.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 6.49.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 6.49.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

6.50 The radio button widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 6.50.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 6.50.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 6.50.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 6.50.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

6.51 The range widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 6.51.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 6.51.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 6.51.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 6.51.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

6.52 The ruler widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 6.52.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 6.52.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 6.52.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 6.52.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

6.53 The scale widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 6.53.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 6.53.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 6.53.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 6.53.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

6.54 The scrollbar widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 6.54.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 6.54.2 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 6.54.3 Signals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 6.54.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

6.55 The scrolled window widget . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 6.55.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 6.55.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 6.55.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 6.55.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

6.56 The separator widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.56.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.56.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.56.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.56.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

6.57 The statusbar widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 6.57.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 6.57.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 6.57.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 6.57.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

6.58 The table widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.58.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.58.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.58.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.58.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

6.59 The text widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6.59.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6.59.2 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 6.59.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

6.60 The toggle button widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.60.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.60.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.60.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.60.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

6.61 The tool bar widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 6.61.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 6.61.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 6.61.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 6.61.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

6.62 The tool tips widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.62.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.62.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.62.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.62.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

6.63 The tree widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 6.63.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 6.63.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 6.63.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 6.63.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

6.64 The tree item widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 6.64.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 6.64.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 6.64.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 6.64.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

6.65 The vertical box widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 6.65.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 6.65.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 6.65.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 6.65.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

6.66 The vertical button box widget. . . . . . . . . . . . . . . . . . . . . . . . 115 6.66.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 6.66.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 6.66.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 6.66.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

6.67 The viewport widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 6.67.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 6.67.2 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 6.67.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

6.68 The vertical paned widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6.68.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6.68.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6.68.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6.68.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

6.69 The vertical ruler widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 6.69.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 6.69.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 6.69.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 6.69.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

6.70 The vertical ruler widget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 6.70.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 6.70.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 6.70.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 6.70.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

6.71 The vertical scrollbar widget . . . . . . . . . . . . . . . . . . . . . . . . . . 120 6.71.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 6.71.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 6.71.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 6.71.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

6.72 The vertical separator widget . . . . . . . . . . . . . . . . . . . . . . . . . 121 6.72.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 6.72.2 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 6.72.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

6.73 The base widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 6.73.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 6.73.2 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 6.73.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

6.74 The window widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 6.74.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 6.74.2 Options. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 6.74.3 Signals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 6.74.4 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

7 Utility objects . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.1 The accelerator table object. . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 7.1.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 7.1.2 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.2 The adjustment object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 7.2.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 7.2.2 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

7.3 The GC object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 7.3.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 7.3.2 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

7.4 The data object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 7.4.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 7.4.2 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

7.5 The style object. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 7.5.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 7.5.2 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

8 Initialization, exit and other features. . . . . . 137

8.1 Initializing and exiting GTK . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 8.1.1 Initializing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 8.1.2 Exiting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 8.1.3 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137

8.2 Customization of the library . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 8.2.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138 8.2.2 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

8.3 Simplified menu creation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 8.4 Simplified tree creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 8.5 Pop up help mechanism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

8.5.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 8.6 Resource Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 8.7 Macros defined by all objects. . . . . . . . . . . . . . . . . . . . . . . . . . . 143

9 Using GTK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

9.1 The simplest GTK program . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 9.2 Hello world in GTK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 9.3 An enhanced hello world. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 9.4 Making Hello World II robust . . . . . . . . . . . . . . . . . . . . . . . . . . 147

10 Object internals . . . . . . . . . . . . . . . . . . . . . . . . 149 11 Signal internals . . . . . . . . . . . . . . . . . . . . . . . . . 151 12 Widget internals. . . . . . . . . . . . . . . . . . . . . . . . 153 Function Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 Concept Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165