Enumerations and Flags

Strings

Boxed Types

Callbacks

Composite Types

Objects

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 section Object internals.

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 section Signals Overview.

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.

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)

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 GtkWidget structure, but often have contain additional information. See section Object internals.

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

The alignment widget

Description

The alignment widget is a container (see section The container widget) derived from the bin widget (see section The bin widget). 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 The container widget 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.

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.

Signals

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

@gtkstdmacros{Alignment, ALIGNMENT}

The arrow widget

Description

The arrow widget is derived from the misc widget (see section The misc widget) 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.

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.

Signals

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

@gtkstdmacros{Arrow, ARROW}

The aspect frame widget

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 The frame widget).

Options

User Option: label

User Option: xalign

User Option: yalign

User Option: ratio

User Option: obey_child

Signals

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)

@gtkstdmacros{AspectFrame, ASPECT_FRAME}

The bin widget

Description

The bin widget is a container (see section The container widget) 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 The alignment widget), frames (see section The frame widget), items (see section The item widget), viewports (see section The viewport widget) and windows (see section The window widget)

Options

Signals

Functions

Function: guint gtk_bin_get_type (void)

Returns the GtkBin type identifier.

@gtkstdmacros{Bin, BIN}

The box widget

Description

The box widget is a container (see section The container widget) derived from the container widget. It is an abstract base class used by the horizontal box (see section The horizontal box widget), the vertical box (see section The vertical box widget) and the (see section The button box widget) 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 The alignment widget) 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 The horizontal box widget, and section The vertical box widget, for code examples of using horizontal and vertical boxes.

Options

User Option: expand

User Option: fill

User Option: padding

User Option: expand

Signals

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)

@gtkstdmacros{Box, BOX}

The button box widget

Description

The button box widget is a container (see section The container widget) derived from the (see section The box widget) widget. It is an abstract base class used by the horizontal button box (see section The horizontal button box widget) and the vertical button box (see section The vertical button box widget) widgets to provide a base of common functionality.

The button box, like the box widget, (see section The box widget) 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 The button widget). 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.

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

Signals

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

@gtkstdmacros{ButtonBox, BUTTON_BOX}

The button widget

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 The container widget.

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)

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)

@gtkstdmacros{Button, BUTTON}

The check button widget

Description

Another form of toggle button (see section The toggle button widget) with an indicator. Contains a widget to the right of the indicator. Changes its appearance (hilites) when it gets the focus.

Options

Signals

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)

@gtkstdmacros{CheckButton, CHECK_BUTTON}

The check menu item widget

Description

Derived from see section The menu item widget. Very similar to a checkbutton (see section The check button widget), 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.

Options

User Option: label

User Option: state

Signals

Signal: void GtkCheckMenuItem::toggled (GtkCheckMenuItem *check_menu_item)

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)

@gtkstdmacros{CheckMenuItem, CHECK_MENU_ITEM}

The compound list widget

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 The container widget. Cells can be empty, have a text and/or pixmap, or be a widget.

Options

Signals

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.

@gtkstdmacros{CList, CLIST}

The color selector widget

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 The vertical box widget.

Options

User Option: policy

• GTK_UPDATE_CONTINUOUS
• GTK_UPDATE_DISCONTINUOUS
• GTK_UPDATE_DELAYED

User Option: color

User Option: use_opacity

User Option: title

Signals

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.

@gtkstdmacros{ColorSelection, COLOR_SELECTION}

The combo widget

Description

Text input box which also lets you choose from pre-defined values from a drop-down menu. Derived from see section The horizontal box widget.

Options

Signals

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)

@gtkstdmacros{Combo, COMBO}

The container widget

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.

Options

User Option: border_width

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)

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)

@gtkstdmacros{Container, CONTAINER}

The multi-column tree widget

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 The compound list widget. 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.

Options

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)

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

@gtkstdmacros{CTree, CTREE}

The curve widget

Description

Derived from see section The drawing area widget.

Options

User Option: type

• GTK_CURVE_TYPE_LINEAR
• GTK_CURVE_TYPE_SPLINE
• GTK_CURVE_TYPE_FREE

Signals

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)

@gtkstdmacros{Curve, CURVE}

The gamma curve widget

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 The vertical box widget. Makes use of see section The curve widget to draw the curve.

Options

Signals

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.

@gtkstdmacros{GammaCurve, GAMMACURVE}

The dialog widget

Description

The dialog widget is a window (see section The window widget) that has a vertical box (see section The vertical box widget), a horizontal box (see section The horizontal box widget), separated with a horizontal separator (see section The horizontal separator widget).

Options

Signals

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.

@gtkstdmacros{Dialog, DIALOG}

The drawing area widget

Description

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

Options

User Option: width

User Option: height

Signals

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.

@gtkstdmacros{DrawingArea, DRAWING_AREA}

The entry widget

Description

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

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.

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)

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.

@gtkstdmacros{Entry, ENTRY}

The event box widget

Description

Derived from see section The bin widget. Used by see section The tree item widget.

Options

Signals

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.

@gtkstdmacros{GtkEventBox, EVENT_BOX}

The file selection dialog widget

Description

Options

User Option: title

User Option: filename

Signals

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)

@gtkstdmacros{FileSelection, FILE_SELECTION}

The fixed widget

Description

Options

Signals

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)

@gtkstdmacros{Fixed, FIXED}

The frame widget

Options

User Option: label

User Option: xalign

User Option: yalign

User Option: type

Description

Signals

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)

@gtkstdmacros{Frame, FRAME}

The gamma widget

Description

Options

Signals

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.

@gtkstdmacros{Gamma, GAMMA}

The horizontal box widget

Description

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 The box widget) 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.

Signals

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.

@gtkstdmacros{HBox, HBOX}

The horizontal button box widget

Description

Options

User Option: spacing

User Option: layout

Signals

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)

@gtkstdmacros {HButtonBox, HBUTTON_BOX}

The horizontal paned widget

Description

Options

Signals

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.

@gtkstdmacros{HPaned, HPANED}

The horizontal ruler widget

Description

Options

Signals

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.

@gtkstdmacros{HRuler, HRULER}

The horizontal scale widget

Description

Options

Signals

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.

@gtkstdmacros{HScale, HSCALE}

The horizontal scrollbar widget

Description

Options

Signals

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.

@gtkstdmacros{HScrollbar, HSCROLLBAR}

The horizontal separator widget

Description

Options

Signals

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.

@gtkstdmacros{HSeparator, HSEPARATOR}

The image widget

Description

Options

Signals

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)

@gtkstdmacros{Image, IMAGE}

The input dialog widget

Description

Options

Signals

Signal: void GtkInputDialog::enable_device (GtkInputDialog *inputd, guint32 devid, gpointer *data)

Signal: void GtkInputDialog::disable_device (GtkInputDialog *inputd, guint32 devid, gpointer *data)

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.

@gtkstdmacros{InputDialog, INPUTDIALOG}

The item widget

Description

Signals

Signal: void GtkItem::select (GtkItem *item)

Signal: void GtkItem::deselect (GtkItem *item)

Signal: void GtkItem::toggle (GtkItem *toggle)

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)

@gtkstdmacros{Item, ITEM}

The label widget

Description

Options

User Option: str

Signals

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.

@gtkstdmacros{Label, LABEL}

The list widget

Description

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)

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)

@gtkstdmacros{List, LIST}

The list item widget

Description

Options

Signals

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)

@gtkstdmacros{ListItem, LIST_ITEM}

The menu widget

Description

Options

Signals

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)

@gtkstdmacros{Menu, MENU}

The menu bar widget

Description

Options

User Option: position

Signals

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)

@gtkstdmacros{MenuBar, MENU_BAR}

The menu item widget

Description

Options

Signals

Signal: void GtkMenuItem::activate (GtkMenuItem *menu_item)

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)

@gtkstdmacros{MenuItem, MENU_ITEM}

The menu shell widget

Description

Options

Signals

Signal: void GtkMenuShell::deactivate (GtkMenuShell *menu_shell)

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)

@gtkstdmacros{MenuShell, MENU_SHELL}

The misc widget

Description

Options

User Option: xalign

User Option: yalign

User Option: xpad

User Option: ypad

Signals

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)

@gtkstdmacros{Misc, MISC}

The notebook widget

Description

Options

Signals

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)

@gtkstdmacros{Notebook, NOTEBOOK}

The option menu widget

Description

Options

User Option: index

Signals

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)

@gtkstdmacros{OptionMenu, OPTION_MENU}

The paned widget

Description

Options

Signals

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)

@gtkstdmacros{Paned, PANED}

The pixmap widget

Description

Options

Signals

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)

@gtkstdmacros{Pixmap, PIXMAP}

The preview widget

Description

Options

User Option: type

User Option: width

User Option: height

Signals

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)

@gtkstdmacros{Preview, PREVIEW}

The progress bar widget

Description

Options

User Option: percentage

Signals

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.

@gtkstdmacros{ProgressBar, PROGRESS_BAR}

The radio button widget

Description

Options

User Option: group

User Option: label

Signals

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)

@gtkstdmacros{RadioButton, RADIO_BUTTON}

The radio button widget

Description

Options

User Option: group

User Option: label

Signals

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)

@gtkstdmacros{RadioMenuItem, RADIO_MENU_ITEM}

The range widget

Description

Options

Signals

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)

@gtkstdmacros{Range, RANGE}

The ruler widget

Description

Options

User Option: metric

User Option: lower

User Option: upper

User Option: position

User Option: max_size

Signals

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)

@gtkstdmacros{Ruler, RULER}

The scale widget

Description

Options

User Option: digits

User Option: draw_value

User Option: pos

Signals

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)

@gtkstdmacros{Scale, SCALE}

The scrollbar widget

Description

Options

Signals

Functions

Function: guint gtk_scrollbar_get_type (void)a

Returns the GtkScrollbar type identifier.

@gtkstdmacros{Scrollbar, SCROLLBAR}

The scrolled window widget

Description

Options

Signals

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)

@gtkstdmacros{ScrolledWindow, SCROLLED_WINDOW}

The separator widget

Description

Options

Signals

Functions

Function: guint gtk_separator_get_type (void)

Returns the GtkSeparator type identifier.

@gtkstdmacros{Separator, SEPARATOR}

The statusbar widget

Description

Options

Signals

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)

@gtkstdmacros{Statusbar, STATUSBAR}

The table widget

Description

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.

Signals

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)

@gtkstdmacros{Table, TABLE}

The text widget

Description

Signals

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)

@gtkstdmacros{Text, TEXT}

The toggle button widget

Description

Another form of button (see section The button widget) 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.

Options

User Option: state

Signals

Signal: void GtkToggleButton::toggled (GtkToggleButton *toggle_button)

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)

@gtkstdmacros{ToggleButton, TOGGLE_BUTTON}

The tool bar widget

Description

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

Signals

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)

@gtkstdmacros{Toolbar, TOOLBAR}

The tool tips widget

Description

Options

Signals

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)

@gtkstdmacros{Tooltips, TOOLTIPS}

The tree widget

Description

Options

Signals

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)

@gtkstdmacros{Tree, TREE}

The tree item widget

Description

Options

Signals

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)

@gtkstdmacros{TreeItem, TREE_ITEM}

The vertical box widget

Description

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 The box widget) 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.

Signals

This widget does not define any new signals.

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.

@gtkstdmacros{VBox, VBOX}

The vertical button box widget

Description

Options

User Option: spacing

User Option: layout

Signals

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)

@gtkstdmacros{VButtonBox, VBUTTON_BOX}

The viewport widget

Description

Signals

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)

@gtkstdmacros{Viewport, VIEWPORT}

The vertical paned widget

Description

Options

Signals

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.

@gtkstdmacros{VPaned, VPANED}

The vertical ruler widget

Description

Options

Signals

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.

@gtkstdmacros{VRuler, VRULER}

The vertical ruler widget

Description

Options

Signals

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.

@gtkstdmacros{VScale, VSCALE}

The vertical scrollbar widget

Description

Options

Signals

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.

@gtkstdmacros{VScrollbar, VSCROLLBAR}

The vertical separator widget

Description

Signals

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.

@gtkstdmacros{VSeparator, VSEPARATOR}

The base widget

Description

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)

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)