Actions are organised into groups. An action group is essentially a map from names to GtkAction objects.

All actions that would make sense to use in a particular context should be in a single group. Multiple action groups may be used for a particular user interface. In fact, it is expected that most nontrivial applications will make use of multiple groups. For example, in an application that can edit multiple documents, one group holding global actions (e.g. quit, about, new), and one group per document holding actions that act on that document (eg. save, cut/copy/paste, etc). Each window’s menus would be constructed from a combination of two action groups.

Accelerators ##

Accelerators are handled by the GTK+ accelerator map. All actions are assigned an accelerator path (which normally has the form <Actions>/group-name/action-name) and a shortcut is associated with this accelerator path. All menuitems and toolitems take on this accelerator path. The GTK+ accelerator map code makes sure that the correct shortcut is displayed next to the menu item.

GtkActionGroup as GtkBuildable #

The GtkActionGroup implementation of the GtkBuildable interface accepts GtkAction objects as <child> elements in UI definitions.

Note that it is probably more common to define actions and action groups in the code, since they are directly related to what the code can do.

The GtkActionGroup implementation of the GtkBuildable interface supports a custom <accelerator> element, which has attributes named “key“ and “modifiers“ and allows to specify accelerators. This is similar to the <accelerator> element of GtkWidget, the main difference is that it doesn’t allow you to specify a signal.

A GtkDialog UI definition fragment.

<object class="GtkActionGroup" id="actiongroup">
  <child>
      <object class="GtkAction" id="About">
          <property name="name">About</property>
          <property name="stock_id">gtk-about</property>
          <signal handler="about_activate" name="activate"/>
      </object>
      <accelerator key="F1" modifiers="GDK_CONTROL_MASK | GDK_SHIFT_MASK"/>
  </child>
</object>

The ActionGroupProtocol protocol exposes the methods and properties of an underlying GtkActionGroup instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActionGroup. Alternatively, use ActionGroupRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkApplication is a class that handles many important aspects of a GTK+ application in a convenient fashion, without enforcing a one-size-fits-all application model.

Currently, GtkApplication handles GTK+ initialization, application uniqueness, session management, provides some basic scriptability and desktop shell integration by exporting actions and menus and manages a list of toplevel windows whose life-cycle is automatically tied to the life-cycle of your application.

While GtkApplication works fine with plain GtkWindows, it is recommended to use it together with GtkApplicationWindow.

When GDK threads are enabled, GtkApplication will acquire the GDK lock when invoking actions that arrive from other processes. The GDK lock is not touched for local action invocations. In order to have actions invoked in a predictable context it is therefore recommended that the GDK lock be held while invoking actions locally with g_action_group_activate_action(). The same applies to actions associated with GtkApplicationWindow and to the “activate” and “open” GApplication methods.

Automatic resources ##

GtkApplication will automatically load menus from the GtkBuilder resource located at “gtk/menus.ui”, relative to the application’s resource base path (see g_application_set_resource_base_path()). The menu with the ID “app-menu” is taken as the application’s app menu and the menu with the ID “menubar” is taken as the application’s menubar. Additional menus (most interesting submenus) can be named and accessed via gtk_application_get_menu_by_id() which allows for dynamic population of a part of the menu structure.

If the resources “gtk/menus-appmenu.ui” or “gtk/menus-traditional.ui” are present then these files will be used in preference, depending on the value of gtk_application_prefers_app_menu(). If the resource “gtk/menus-common.ui” is present it will be loaded as well. This is useful for storing items that are referenced from both “gtk/menus-appmenu.ui” and “gtk/menus-traditional.ui”.

It is also possible to provide the menus manually using gtk_application_set_app_menu() and gtk_application_set_menubar().

GtkApplication will also automatically setup an icon search path for the default icon theme by appending “icons” to the resource base path. This allows your application to easily store its icons as resources. See gtk_icon_theme_add_resource_path() for more information.

If there is a resource located at “gtk/help-overlay.ui” which defines a GtkShortcutsWindow with ID “help_overlay” then GtkApplication associates an instance of this shortcuts window with each GtkApplicationWindow and sets up keyboard accelerators (Control-F1 and Control-?) to open it. To create a menu item that displays the shortcuts window, associate the item with the action win.show-help-overlay.

A simple application ##

A simple example

GtkApplication optionally registers with a session manager of the users session (if you set the GtkApplication:register-session property) and offers various functionality related to the session life-cycle.

An application can block various ways to end the session with the gtk_application_inhibit() function. Typical use cases for this kind of inhibiting are long-running, uninterruptible operations, such as burning a CD or performing a disk backup. The session manager may not honor the inhibitor, but it can be expected to inform the user about the negative consequences of ending the session while inhibitors are present.

See Also ##

HowDoI: Using GtkApplication, Getting Started with GTK+: Basics

The ApplicationProtocol protocol exposes the methods and properties of an underlying GtkApplication instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Application. Alternatively, use ApplicationRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkBox widget arranges child widgets into a single row or column, depending upon the value of its GtkOrientable:orientation property. Within the other dimension, all children are allocated the same size. Of course, the GtkWidget:halign and GtkWidget:valign properties can be used on the children to influence their allocation.

GtkBox uses a notion of packing. Packing refers to adding widgets with reference to a particular position in a GtkContainer. For a GtkBox, there are two reference positions: the start and the end of the box. For a vertical GtkBox, the start is defined as the top of the box and the end is defined as the bottom. For a horizontal GtkBox the start is defined as the left side and the end is defined as the right side.

Use repeated calls to gtk_box_pack_start() to pack widgets into a GtkBox from start to end. Use gtk_box_pack_end() to add widgets from end to start. You may intersperse these calls and add widgets from both ends of the same GtkBox.

Because GtkBox is a GtkContainer, you may also use gtk_container_add() to insert widgets into the box, and they will be packed with the default values for expand and fill child properties. Use gtk_container_remove() to remove widgets from the GtkBox.

Use gtk_box_set_homogeneous() to specify whether or not all children of the GtkBox are forced to get the same amount of space.

Use gtk_box_set_spacing() to determine how much space will be minimally placed between all children in the GtkBox. Note that spacing is added between the children, while padding added by gtk_box_pack_start() or gtk_box_pack_end() is added on either side of the widget it belongs to.

Use gtk_box_reorder_child() to move a GtkBox child to a different place in the box.

Use gtk_box_set_child_packing() to reset the expand, fill and padding child properties. Use gtk_box_query_child_packing() to query these fields.

CSS nodes

GtkBox uses a single CSS node with name box.

In horizontal orientation, the nodes of the children are always arranged from left to right. So :first-child will always select the leftmost child, regardless of text direction.

The BoxProtocol protocol exposes the methods and properties of an underlying GtkBox instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Box. Alternatively, use BoxRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCssProvider is an object implementing the GtkStyleProvider interface. It is able to parse CSS-like input in order to style widgets.

An application can make GTK+ parse a specific CSS style sheet by calling gtk_css_provider_load_from_file() or gtk_css_provider_load_from_resource() and adding the provider with gtk_style_context_add_provider() or gtk_style_context_add_provider_for_screen().

In addition, certain files will be read when GTK+ is initialized. First, the file $XDG_CONFIG_HOME/gtk-3.0/gtk.css is loaded if it exists. Then, GTK+ loads the first existing file among XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk.css, $HOME/.themes/THEME/gtk-VERSION/gtk.css, $XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk.css and DATADIR/share/themes/THEME/gtk-VERSION/gtk.css, where THEME is the name of the current theme (see the GtkSettings:gtk-theme-name setting), DATADIR is the prefix configured when GTK+ was compiled (unless overridden by the GTK_DATA_PREFIX environment variable), and VERSION is the GTK+ version number. If no file is found for the current version, GTK+ tries older versions all the way back to 3.0.

In the same way, GTK+ tries to load a gtk-keys.css file for the current key theme, as defined by GtkSettings:gtk-key-theme-name.

The CssProviderProtocol protocol exposes the methods and properties of an underlying GtkCssProvider instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CssProvider. Alternatively, use CssProviderRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GTK+ user interface is constructed by nesting widgets inside widgets. Container widgets are the inner nodes in the resulting tree of widgets: they contain other widgets. So, for example, you might have a GtkWindow containing a GtkFrame containing a GtkLabel. If you wanted an image instead of a textual label inside the frame, you might replace the GtkLabel widget with a GtkImage widget.

There are two major kinds of container widgets in GTK+. Both are subclasses of the abstract GtkContainer base class.

The first type of container widget has a single child widget and derives from GtkBin. These containers are decorators, which add some kind of functionality to the child. For example, a GtkButton makes its child into a clickable button; a GtkFrame draws a frame around its child and a GtkWindow places its child widget inside a top-level window.

The second type of container can have more than one child; its purpose is to manage layout. This means that these containers assign sizes and positions to their children. For example, a GtkHBox arranges its children in a horizontal row, and a GtkGrid arranges the widgets it contains in a two-dimensional grid.

For implementations of GtkContainer the virtual method GtkContainerClass.forall() is always required, since it’s used for drawing and other internal operations on the children. If the GtkContainer implementation expect to have non internal children it’s needed to implement both GtkContainerClass.add() and GtkContainerClass.remove(). If the GtkContainer implementation has internal children, they should be added with gtk_widget_set_parent() on init() and removed with gtk_widget_unparent() in the GtkWidgetClass.destroy() implementation. See more about implementing custom widgets at https://wiki.gnome.org/HowDoI/CustomWidgets

Height for width geometry management

GTK+ uses a height-for-width (and width-for-height) geometry management system. Height-for-width means that a widget can change how much vertical space it needs, depending on the amount of horizontal space that it is given (and similar for width-for-height).

There are some things to keep in mind when implementing container widgets that make use of GTK+’s height for width geometry management system. First, it’s important to note that a container must prioritize one of its dimensions, that is to say that a widget or container can only have a GtkSizeRequestMode that is GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT. However, every widget and container must be able to respond to the APIs for both dimensions, i.e. even if a widget has a request mode that is height-for-width, it is possible that its parent will request its sizes using the width-for-height APIs.

To ensure that everything works properly, here are some guidelines to follow when implementing height-for-width (or width-for-height) containers.

Each request mode involves 2 virtual methods. Height-for-width apis run through gtk_widget_get_preferred_width() and then through gtk_widget_get_preferred_height_for_width(). When handling requests in the opposite GtkSizeRequestMode it is important that every widget request at least enough space to display all of its content at all times.

When gtk_widget_get_preferred_height() is called on a container that is height-for-width, the container must return the height for its minimum width. This is easily achieved by simply calling the reverse apis implemented for itself as follows:

(C Language Example):

static void
foo_container_get_preferred_height (GtkWidget *widget,
                                    gint *min_height,
                                    gint *nat_height)
{
   if (i_am_in_height_for_width_mode)
     {
       gint min_width;

       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           &min_width,
                                                           NULL);
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
                                                          (widget,
                                                           min_width,
                                                           min_height,
                                                           nat_height);
     }
   else
     {
       ... many containers support both request modes, execute the
       real width-for-height request here by returning the
       collective heights of all widgets that are stacked
       vertically (or whatever is appropriate for this container)
       ...
     }
}

Similarly, when gtk_widget_get_preferred_width_for_height() is called for a container or widget that is height-for-width, it then only needs to return the base minimum width like so:

(C Language Example):

static void
foo_container_get_preferred_width_for_height (GtkWidget *widget,
                                              gint for_height,
                                              gint *min_width,
                                              gint *nat_width)
{
   if (i_am_in_height_for_width_mode)
     {
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           min_width,
                                                           nat_width);
     }
   else
     {
       ... execute the real width-for-height request here based on
       the required width of the children collectively if the
       container were to be allocated the said height ...
     }
}

Height for width requests are generally implemented in terms of a virtual allocation of widgets in the input orientation. Assuming an height-for-width request mode, a container would implement the get_preferred_height_for_width() virtual function by first calling gtk_widget_get_preferred_width() for each of its children.

For each potential group of children that are lined up horizontally, the values returned by gtk_widget_get_preferred_width() should be collected in an array of GtkRequestedSize structures. Any child spacing should be removed from the input for_width and then the collective size should be allocated using the gtk_distribute_natural_allocation() convenience function.

The container will then move on to request the preferred height for each child by using gtk_widget_get_preferred_height_for_width() and using the sizes stored in the GtkRequestedSize array.

To allocate a height-for-width container, it’s again important to consider that a container must prioritize one dimension over the other. So if a container is a height-for-width container it must first allocate all widgets horizontally using a GtkRequestedSize array and gtk_distribute_natural_allocation() and then add any extra space (if and where appropriate) for the widget to expand.

After adding all the expand space, the container assumes it was allocated sufficient height to fit all of its content. At this time, the container must use the total horizontal sizes of each widget to request the height-for-width of each of its children and store the requests in a GtkRequestedSize array for any widgets that stack vertically (for tabular containers this can be generalized into the heights and widths of rows and columns). The vertical space must then again be distributed using gtk_distribute_natural_allocation() while this time considering the allocated height of the widget minus any vertical spacing that the container adds. Then vertical expand space should be added where appropriate and available and the container should go on to actually allocating the child widgets.

See GtkWidget’s geometry management section to learn more about implementing height-for-width geometry management for widgets.

Child properties

GtkContainer introduces child properties. These are object properties that are not specific to either the container or the contained widget, but rather to their relation. Typical examples of child properties are the position or pack-type of a widget which is contained in a GtkBox.

Use gtk_container_class_install_child_property() to install child properties for a container class and gtk_container_class_find_child_property() or gtk_container_class_list_child_properties() to get information about existing child properties.

To set the value of a child property, use gtk_container_child_set_property(), gtk_container_child_set() or gtk_container_child_set_valist(). To obtain the value of a child property, use gtk_container_child_get_property(), gtk_container_child_get() or gtk_container_child_get_valist(). To emit notification about child property changes, use gtk_widget_child_notify().

GtkContainer as GtkBuildable

The GtkContainer implementation of the GtkBuildable interface supports a <packing> element for children, which can contain multiple <property> elements that specify child properties for the child.

Since 2.16, child properties can also be marked as translatable using the same “translatable”, “comments” and “context” attributes that are used for regular properties.

Since 3.16, containers can have a <focus-chain> element containing multiple <widget> elements, one for each child that should be added to the focus chain. The ”name” attribute gives the id of the widget.

An example of these properties in UI definitions:

<object class="GtkBox">
  <child>
    <object class="GtkEntry" id="entry1"/>
    <packing>
      <property name="pack-type">start</property>
    </packing>
  </child>
  <child>
    <object class="GtkEntry" id="entry2"/>
  </child>
  <focus-chain>
    <widget name="entry1"/>
    <widget name="entry2"/>
  </focus-chain>
</object>

The ContainerProtocol protocol exposes the methods and properties of an underlying GtkContainer instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Container. Alternatively, use ContainerRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkWidget is the base class all widgets in GTK+ derive from. It manages the widget lifecycle, states and style.

Height-for-width Geometry Management #

GTK+ uses a height-for-width (and width-for-height) geometry management system. Height-for-width means that a widget can change how much vertical space it needs, depending on the amount of horizontal space that it is given (and similar for width-for-height). The most common example is a label that reflows to fill up the available width, wraps to fewer lines, and therefore needs less height.

Height-for-width geometry management is implemented in GTK+ by way of five virtual methods:

• GtkWidgetClass.get_request_mode()
• GtkWidgetClass.get_preferred_width()
• GtkWidgetClass.get_preferred_height()
• GtkWidgetClass.get_preferred_height_for_width()
• GtkWidgetClass.get_preferred_width_for_height()
• GtkWidgetClass.get_preferred_height_and_baseline_for_width()

There are some important things to keep in mind when implementing height-for-width and when using it in container implementations.

The geometry management system will query a widget hierarchy in only one orientation at a time. When widgets are initially queried for their minimum sizes it is generally done in two initial passes in the GtkSizeRequestMode chosen by the toplevel.

For example, when queried in the normal GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode: First, the default minimum and natural width for each widget in the interface will be computed using gtk_widget_get_preferred_width(). Because the preferred widths for each container depend on the preferred widths of their children, this information propagates up the hierarchy, and finally a minimum and natural width is determined for the entire toplevel. Next, the toplevel will use the minimum width to query for the minimum height contextual to that width using gtk_widget_get_preferred_height_for_width(), which will also be a highly recursive operation. The minimum height for the minimum width is normally used to set the minimum size constraint on the toplevel (unless gtk_window_set_geometry_hints() is explicitly used instead).

After the toplevel window has initially requested its size in both dimensions it can go on to allocate itself a reasonable size (or a size previously specified with gtk_window_set_default_size()). During the recursive allocation process it’s important to note that request cycles will be recursively executed while container widgets allocate their children. Each container widget, once allocated a size, will go on to first share the space in one orientation among its children and then request each child’s height for its target allocated width or its width for allocated height, depending. In this way a GtkWidget will typically be requested its size a number of times before actually being allocated a size. The size a widget is finally allocated can of course differ from the size it has requested. For this reason, GtkWidget caches a small number of results to avoid re-querying for the same sizes in one allocation cycle.

See GtkContainer’s geometry management section to learn more about how height-for-width allocations are performed by container widgets.

If a widget does move content around to intelligently use up the allocated size then it must support the request in both GtkSizeRequestModes even if the widget in question only trades sizes in a single orientation.

For instance, a GtkLabel that does height-for-width word wrapping will not expect to have GtkWidgetClass.get_preferred_height() called because that call is specific to a width-for-height request. In this case the label must return the height required for its own minimum possible width. By following this rule any widget that handles height-for-width or width-for-height requests will always be allocated at least enough space to fit its own content.

Here are some examples of how a GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget generally deals with width-for-height requests, for GtkWidgetClass.get_preferred_height() it will do:

(C Language Example):

static void
foo_widget_get_preferred_height (GtkWidget *widget,
                                 gint *min_height,
                                 gint *nat_height)
{
   if (i_am_in_height_for_width_mode)
     {
       gint min_width, nat_width;

       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           &min_width,
                                                           &nat_width);
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
                                                          (widget,
                                                           min_width,
                                                           min_height,
                                                           nat_height);
     }
   else
     {
        ... some widgets do both. For instance, if a GtkLabel is
        rotated to 90 degrees it will return the minimum and
        natural height for the rotated label here.
     }
}

And in GtkWidgetClass.get_preferred_width_for_height() it will simply return the minimum and natural width: (C Language Example):

static void
foo_widget_get_preferred_width_for_height (GtkWidget *widget,
                                           gint for_height,
                                           gint *min_width,
                                           gint *nat_width)
{
   if (i_am_in_height_for_width_mode)
     {
       GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
                                                           min_width,
                                                           nat_width);
     }
   else
     {
        ... again if a widget is sometimes operating in
        width-for-height mode (like a rotated GtkLabel) it can go
        ahead and do its real width for height calculation here.
     }
}

Often a widget needs to get its own request during size request or allocation. For example, when computing height it may need to also compute width. Or when deciding how to use an allocation, the widget may need to know its natural size. In these cases, the widget should be careful to call its virtual methods directly, like this:

(C Language Example):

GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget,
                                                   &min,
                                                   &natural);

It will not work to use the wrapper functions, such as gtk_widget_get_preferred_width() inside your own size request implementation. These return a request adjusted by GtkSizeGroup and by the GtkWidgetClass.adjust_size_request() virtual method. If a widget used the wrappers inside its virtual method implementations, then the adjustments (such as widget margins) would be applied twice. GTK+ therefore does not allow this and will warn if you try to do it.

Of course if you are getting the size request for another widget, such as a child of a container, you must use the wrapper APIs. Otherwise, you would not properly consider widget margins, GtkSizeGroup, and so forth.

Since 3.10 GTK+ also supports baseline vertical alignment of widgets. This means that widgets are positioned such that the typographical baseline of widgets in the same row are aligned. This happens if a widget supports baselines, has a vertical alignment of GTK_ALIGN_BASELINE, and is inside a container that supports baselines and has a natural “row” that it aligns to the baseline, or a baseline assigned to it by the grandparent.

Baseline alignment support for a widget is done by the GtkWidgetClass.get_preferred_height_and_baseline_for_width() virtual function. It allows you to report a baseline in combination with the minimum and natural height. If there is no baseline you can return -1 to indicate this. The default implementation of this virtual function calls into the GtkWidgetClass.get_preferred_height() and GtkWidgetClass.get_preferred_height_for_width(), so if baselines are not supported it doesn’t need to be implemented.

If a widget ends up baseline aligned it will be allocated all the space in the parent as if it was GTK_ALIGN_FILL, but the selected baseline can be found via gtk_widget_get_allocated_baseline(). If this has a value other than -1 you need to align the widget such that the baseline appears at the position.

Style Properties

GtkWidget introduces “style properties” - these are basically object properties that are stored not on the object, but in the style object associated to the widget. Style properties are set in resource files. This mechanism is used for configuring such things as the location of the scrollbar arrows through the theme, giving theme authors more control over the look of applications without the need to write a theme engine in C.

Use gtk_widget_class_install_style_property() to install style properties for a widget class, gtk_widget_class_find_style_property() or gtk_widget_class_list_style_properties() to get information about existing style properties and gtk_widget_style_get_property(), gtk_widget_style_get() or gtk_widget_style_get_valist() to obtain the value of a style property.

GtkWidget as GtkBuildable

The GtkWidget implementation of the GtkBuildable interface supports a custom <accelerator> element, which has attributes named ”key”, ”modifiers” and ”signal” and allows to specify accelerators.

An example of a UI definition fragment specifying an accelerator:

<object class="GtkButton">
  <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>
</object>

In addition to accelerators, GtkWidget also support a custom <accessible> element, which supports actions and relations. Properties on the accessible implementation of an object can be set by accessing the internal child “accessible” of a GtkWidget.

An example of a UI definition fragment specifying an accessible:

<object class="GtkLabel" id="label1"/>
  <property name="label">I am a Label for a Button</property>
</object>
<object class="GtkButton" id="button1">
  <accessibility>
    <action action_name="click" translatable="yes">Click the button.</action>
    <relation target="label1" type="labelled-by"/>
  </accessibility>
  <child internal-child="accessible">
    <object class="AtkObject" id="a11y-button1">
      <property name="accessible-name">Clickable Button</property>
    </object>
  </child>
</object>

Finally, GtkWidget allows style information such as style classes to be associated with widgets, using the custom <style> element:

<object class="GtkButton" id="button1">
  <style>
    <class name="my-special-button-class"/>
    <class name="dark-button"/>
  </style>
</object>

Building composite widgets from template XML ##

GtkWidget exposes some facilities to automate the procedure of creating composite widgets using GtkBuilder interface description language.

To create composite widgets with GtkBuilder XML, one must associate the interface description with the widget class at class initialization time using gtk_widget_class_set_template().

The interface description semantics expected in composite template descriptions is slightly different from regular GtkBuilder XML.

Unlike regular interface descriptions, gtk_widget_class_set_template() will expect a <template> tag as a direct child of the toplevel <interface> tag. The <template> tag must specify the “class” attribute which must be the type name of the widget. Optionally, the “parent” attribute may be specified to specify the direct parent type of the widget type, this is ignored by the GtkBuilder but required for Glade to introspect what kind of properties and internal children exist for a given type when the actual type does not exist.

The XML which is contained inside the <template> tag behaves as if it were added to the <object> tag defining widget itself. You may set properties on widget by inserting <property> tags into the <template> tag, and also add <child> tags to add children and extend widget in the normal way you would with <object> tags.

Additionally, <object> tags can also be added before and after the initial <template> tag in the normal way, allowing one to define auxiliary objects which might be referenced by other widgets declared as children of the <template> tag.

An example of a GtkBuilder Template Definition:

<interface>
  <template class="FooWidget" parent="GtkBox">
    <property name="orientation">GTK_ORIENTATION_HORIZONTAL</property>
    <property name="spacing">4</property>
    <child>
      <object class="GtkButton" id="hello_button">
        <property name="label">Hello World</property>
        <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
      </object>
    </child>
    <child>
      <object class="GtkButton" id="goodbye_button">
        <property name="label">Goodbye World</property>
      </object>
    </child>
  </template>
</interface>

Typically, you’ll place the template fragment into a file that is bundled with your project, using GResource. In order to load the template, you need to call gtk_widget_class_set_template_from_resource() from the class initialization of your GtkWidget type:

(C Language Example):

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...

  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
}

You will also need to call gtk_widget_init_template() from the instance initialization function:

(C Language Example):

static void
foo_widget_init (FooWidget *self)
{
  // ...
  gtk_widget_init_template (GTK_WIDGET (self));
}

You can access widgets defined in the template using the gtk_widget_get_template_child() function, but you will typically declare a pointer in the instance private data structure of your type using the same name as the widget in the template definition, and call gtk_widget_class_bind_template_child_private() with that name, e.g.

(C Language Example):

typedef struct {
  GtkWidget *hello_button;
  GtkWidget *goodbye_button;
} FooWidgetPrivate;

G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...
  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
                                                FooWidget, hello_button);
  gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
                                                FooWidget, goodbye_button);
}

static void
foo_widget_init (FooWidget *widget)
{

}

You can also use gtk_widget_class_bind_template_callback() to connect a signal callback defined in the template with a function visible in the scope of the class, e.g.

(C Language Example):

// the signal handler has the instance and user data swapped
// because of the swapped="yes" attribute in the template XML
static void
hello_button_clicked (FooWidget *self,
                      GtkButton *button)
{
  g_print ("Hello, world!\n");
}

static void
foo_widget_class_init (FooWidgetClass *klass)
{
  // ...
  gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
                                               "/com/example/ui/foowidget.ui");
  gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
}

The WidgetProtocol protocol exposes the methods and properties of an underlying GtkWidget instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Widget. Alternatively, use WidgetRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkAboutDialog offers a simple way to display information about a program like its logo, name, copyright, website and license. It is also possible to give credits to the authors, documenters, translators and artists who have worked on the program. An about dialog is typically opened when the user selects the About option from the Help menu. All parts of the dialog are optional.

About dialogs often contain links and email addresses. GtkAboutDialog displays these as clickable links. By default, it calls gtk_show_uri_on_window() when a user clicks one. The behaviour can be overridden with the GtkAboutDialog::activate-link signal.

To specify a person with an email address, use a string like “Edgar Allan Poe <edgar`poe.com`>”. To specify a website with a title, use a string like “GTK+ team http://www.gtk.org”.

To make constructing a GtkAboutDialog as convenient as possible, you can use the function gtk_show_about_dialog() which constructs and shows a dialog and keeps it around so that it can be shown again.

Note that GTK+ sets a default title of _("About %s") on the dialog window (where `s` is replaced by the name of the application, but in order to ensure proper translation of the title, applications should set the title property explicitly when constructing a GtkAboutDialog, as shown in the following example: (C Language Example):

GdkPixbuf *example_logo = gdk_pixbuf_new_from_file ("./logo.png", NULL);
gtk_show_about_dialog (NULL,
                       "program-name", "ExampleCode",
                       "logo", example_logo,
                       "title", _("About ExampleCode"),
                       NULL);

It is also possible to show a GtkAboutDialog like any other GtkDialog, e.g. using gtk_dialog_run(). In this case, you might need to know that the “Close” button returns the GTK_RESPONSE_CANCEL response id.

The AboutDialogProtocol protocol exposes the methods and properties of an underlying GtkAboutDialog instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AboutDialog. Alternatively, use AboutDialogRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkAccelGroup represents a group of keyboard accelerators, typically attached to a toplevel GtkWindow (with gtk_window_add_accel_group()). Usually you won’t need to create a GtkAccelGroup directly; instead, when using GtkUIManager, GTK+ automatically sets up the accelerators for your menus in the ui manager’s GtkAccelGroup.

Note that “accelerators” are different from “mnemonics”. Accelerators are shortcuts for activating a menu item; they appear alongside the menu item they’re a shortcut for. For example “Ctrl+Q” might appear alongside the “Quit” menu item. Mnemonics are shortcuts for GUI elements such as text entries or buttons; they appear as underlined characters. See gtk_label_new_with_mnemonic(). Menu items can have both accelerators and mnemonics, of course.

The AccelGroupProtocol protocol exposes the methods and properties of an underlying GtkAccelGroup instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelGroup. Alternatively, use AccelGroupRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkAccelLabel widget is a subclass of GtkLabel that also displays an accelerator key on the right of the label text, e.g. “Ctrl+S”. It is commonly used in menus to show the keyboard short-cuts for commands.

The accelerator key to display is typically not set explicitly (although it can be, with gtk_accel_label_set_accel()). Instead, the GtkAccelLabel displays the accelerators which have been added to a particular widget. This widget is set by calling gtk_accel_label_set_accel_widget().

For example, a GtkMenuItem widget may have an accelerator added to emit the “activate” signal when the “Ctrl+S” key combination is pressed. A GtkAccelLabel is created and added to the GtkMenuItem, and gtk_accel_label_set_accel_widget() is called with the GtkMenuItem as the second argument. The GtkAccelLabel will now display “Ctrl+S” after its label.

Note that creating a GtkMenuItem with gtk_menu_item_new_with_label() (or one of the similar functions for GtkCheckMenuItem and GtkRadioMenuItem) automatically adds a GtkAccelLabel to the GtkMenuItem and calls gtk_accel_label_set_accel_widget() to set it up for you.

A GtkAccelLabel will only display accelerators which have GTK_ACCEL_VISIBLE set (see GtkAccelFlags). A GtkAccelLabel can display multiple accelerators and even signal names, though it is almost always used to display just one accelerator key.

Creating a simple menu item with an accelerator key.

(C Language Example):

  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  GtkWidget *menu = gtk_menu_new ();
  GtkWidget *save_item;
  GtkAccelGroup *accel_group;

  // Create a GtkAccelGroup and add it to the window.
  accel_group = gtk_accel_group_new ();
  gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);

  // Create the menu item using the convenience function.
  save_item = gtk_menu_item_new_with_label ("Save");
  gtk_widget_show (save_item);
  gtk_container_add (GTK_CONTAINER (menu), save_item);

  // Now add the accelerator to the GtkMenuItem. Note that since we
  // called gtk_menu_item_new_with_label() to create the GtkMenuItem
  // the GtkAccelLabel is automatically set up to display the
  // GtkMenuItem accelerators. We just need to make sure we use
  // GTK_ACCEL_VISIBLE here.
  gtk_widget_add_accelerator (save_item, "activate", accel_group,
                              GDK_KEY_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);

CSS nodes

(plain Language Example):

label
╰── accelerator

Like GtkLabel, GtkAccelLabel has a main CSS node with the name label. It adds a subnode with name accelerator.

The AccelLabelProtocol protocol exposes the methods and properties of an underlying GtkAccelLabel instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelLabel. Alternatively, use AccelLabelRef as a lighweight, unowned reference if you already have an instance you just want to use.

Accelerator maps are used to define runtime configurable accelerators. Functions for manipulating them are are usually used by higher level convenience mechanisms like GtkUIManager and are thus considered “low-level”. You’ll want to use them if you’re manually creating menus that should have user-configurable accelerators.

An accelerator is uniquely defined by:

• accelerator path
• accelerator key
• accelerator modifiers

The accelerator path must consist of “<WINDOWTYPE>/Category1/Category2/…/Action”, where WINDOWTYPE should be a unique application-specific identifier that corresponds to the kind of window the accelerator is being used in, e.g. “Gimp-Image”, “Abiword-Document” or “Gnumeric-Settings”. The “Category1/…/Action” portion is most appropriately chosen by the action the accelerator triggers, i.e. for accelerators on menu items, choose the item’s menu path, e.g. “File/Save As”, “Image/View/Zoom” or “Edit/Select All”. So a full valid accelerator path may look like: “<Gimp-Toolbox>/File/Dialogs/Tool Options…”.

All accelerators are stored inside one global GtkAccelMap that can be obtained using gtk_accel_map_get(). See Monitoring changes for additional details.

Manipulating accelerators

New accelerators can be added using gtk_accel_map_add_entry(). To search for specific accelerator, use gtk_accel_map_lookup_entry(). Modifications of existing accelerators should be done using gtk_accel_map_change_entry().

In order to avoid having some accelerators changed, they can be locked using gtk_accel_map_lock_path(). Unlocking is done using gtk_accel_map_unlock_path().

Saving and loading accelerator maps

Accelerator maps can be saved to and loaded from some external resource. For simple saving and loading from file, gtk_accel_map_save() and gtk_accel_map_load() are provided. Saving and loading can also be done by providing file descriptor to gtk_accel_map_save_fd() and gtk_accel_map_load_fd().

Monitoring changes

GtkAccelMap object is only useful for monitoring changes of accelerators. By connecting to GtkAccelMap::changed signal, one can monitor changes of all accelerators. It is also possible to monitor only single accelerator path by using it as a detail of the GtkAccelMap::changed signal.

The AccelMapProtocol protocol exposes the methods and properties of an underlying GtkAccelMap instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelMap. Alternatively, use AccelMapRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkAccessible class is the base class for accessible implementations for GtkWidget subclasses. It is a thin wrapper around AtkObject, which adds facilities for associating a widget with its accessible object.

An accessible implementation for a third-party widget should derive from GtkAccessible and implement the suitable interfaces from ATK, such as AtkText or AtkSelection. To establish the connection between the widget class and its corresponding acccessible implementation, override the get_accessible vfunc in GtkWidgetClass.

The AccessibleProtocol protocol exposes the methods and properties of an underlying GtkAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Accessible. Alternatively, use AccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

> In GTK+ 3.10, GtkAction has been deprecated. Use GAction > instead, and associate actions with GtkActionable widgets. Use > GMenuModel for creating menus with gtk_menu_new_from_model().

Actions represent operations that the user can be perform, along with some information how it should be presented in the interface. Each action provides methods to create icons, menu items and toolbar items representing itself.

As well as the callback that is called when the action gets activated, the following also gets associated with the action:

• a name (not translated, for path lookup)

• a label (translated, for display)

• an accelerator

• whether label indicates a stock id

• a tooltip (optional, translated)

• a toolbar label (optional, shorter than label)

The action will also have some state information:

• visible (shown/hidden)

• sensitive (enabled/disabled)

Apart from regular actions, there are toggle actions, which can be toggled between two states and radio actions, of which only one in a group can be in the “active” state. Other actions can be implemented as GtkAction subclasses.

Each action can have one or more proxy widgets. To act as an action proxy, widget needs to implement GtkActivatable interface. Proxies mirror the state of the action and should change when the action’s state changes. Properties that are always mirrored by proxies are GtkAction:sensitive and GtkAction:visible. GtkAction:gicon, GtkAction:icon-name, GtkAction:label, GtkAction:short-label and GtkAction:stock-id properties are only mirorred if proxy widget has GtkActivatable:use-action-appearance property set to true.

When the proxy is activated, it should activate its action.

The ActionProtocol protocol exposes the methods and properties of an underlying GtkAction instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Action. Alternatively, use ActionRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkActionBar is designed to present contextual actions. It is expected to be displayed below the content and expand horizontally to fill the area.

It allows placing children at the start or the end. In addition, it contains an internal centered box which is centered with respect to the full width of the box, even if the children at either side take up different amounts of space.

CSS nodes

GtkActionBar has a single CSS node with name actionbar.

The ActionBarProtocol protocol exposes the methods and properties of an underlying GtkActionBar instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActionBar. Alternatively, use ActionBarRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkAdjustment object represents a value which has an associated lower and upper bound, together with step and page increments, and a page size. It is used within several GTK+ widgets, including GtkSpinButton, GtkViewport, and GtkRange (which is a base class for GtkScrollbar and GtkScale).

The GtkAdjustment object does not update the value itself. Instead it is left up to the owner of the GtkAdjustment to control the value.

The AdjustmentProtocol protocol exposes the methods and properties of an underlying GtkAdjustment instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Adjustment. Alternatively, use AdjustmentRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkAlignment widget controls the alignment and size of its child widget. It has four settings: xscale, yscale, xalign, and yalign.

The scale settings are used to specify how much the child widget should expand to fill the space allocated to the GtkAlignment. The values can range from 0 (meaning the child doesn’t expand at all) to 1 (meaning the child expands to fill all of the available space).

The align settings are used to place the child widget within the available area. The values range from 0 (top or left) to 1 (bottom or right). Of course, if the scale settings are both set to 1, the alignment settings have no effect.

GtkAlignment has been deprecated in 3.14 and should not be used in newly-written code. The desired effect can be achieved by using the GtkWidget:halign, GtkWidget:valign and GtkWidget:margin properties on the child widget.

The AlignmentProtocol protocol exposes the methods and properties of an underlying GtkAlignment instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Alignment. Alternatively, use AlignmentRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkAppChooserButton is a widget that lets the user select an application. It implements the GtkAppChooser interface.

Initially, a GtkAppChooserButton selects the first application in its list, which will either be the most-recently used application or, if GtkAppChooserButton:show-default-item is true, the default application.

The list of applications shown in a GtkAppChooserButton includes the recommended applications for the given content type. When GtkAppChooserButton:show-default-item is set, the default application is also included. To let the user chooser other applications, you can set the GtkAppChooserButton:show-dialog-item property, which allows to open a full GtkAppChooserDialog.

It is possible to add custom items to the list, using gtk_app_chooser_button_append_custom_item(). These items cause the GtkAppChooserButton::custom-item-activated signal to be emitted when they are selected.

To track changes in the selected application, use the GtkComboBox::changed signal.

The AppChooserButtonProtocol protocol exposes the methods and properties of an underlying GtkAppChooserButton instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AppChooserButton. Alternatively, use AppChooserButtonRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkAppChooserDialog shows a GtkAppChooserWidget inside a GtkDialog.

Note that GtkAppChooserDialog does not have any interesting methods of its own. Instead, you should get the embedded GtkAppChooserWidget using gtk_app_chooser_dialog_get_widget() and call its methods if the generic GtkAppChooser interface is not sufficient for your needs.

To set the heading that is shown above the GtkAppChooserWidget, use gtk_app_chooser_dialog_set_heading().

The AppChooserDialogProtocol protocol exposes the methods and properties of an underlying GtkAppChooserDialog instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AppChooserDialog. Alternatively, use AppChooserDialogRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkAppChooserWidget is a widget for selecting applications. It is the main building block for GtkAppChooserDialog. Most applications only need to use the latter; but you can use this widget as part of a larger widget if you have special needs.

GtkAppChooserWidget offers detailed control over what applications are shown, using the GtkAppChooserWidget:show-default, GtkAppChooserWidget:show-recommended, GtkAppChooserWidget:show-fallback, GtkAppChooserWidget:show-other and GtkAppChooserWidget:show-all properties. See the GtkAppChooser documentation for more information about these groups of applications.

To keep track of the selected application, use the GtkAppChooserWidget::application-selected and GtkAppChooserWidget::application-activated signals.

CSS nodes

GtkAppChooserWidget has a single CSS node with name appchooser.

The AppChooserWidgetProtocol protocol exposes the methods and properties of an underlying GtkAppChooserWidget instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AppChooserWidget. Alternatively, use AppChooserWidgetRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkApplicationWindow is a GtkWindow subclass that offers some extra functionality for better integration with GtkApplication features. Notably, it can handle both the application menu as well as the menubar. See gtk_application_set_app_menu() and gtk_application_set_menubar().

This class implements the GActionGroup and GActionMap interfaces, to let you add window-specific actions that will be exported by the associated GtkApplication, together with its application-wide actions. Window-specific actions are prefixed with the “win.” prefix and application-wide actions are prefixed with the “app.” prefix. Actions must be addressed with the prefixed name when referring to them from a GMenuModel.

Note that widgets that are placed inside a GtkApplicationWindow can also activate these actions, if they implement the GtkActionable interface.

As with GtkApplication, the GDK lock will be acquired when processing actions arriving from other processes and should therefore be held when activating actions locally (if GDK threads are enabled).

The settings GtkSettings:gtk-shell-shows-app-menu and GtkSettings:gtk-shell-shows-menubar tell GTK+ whether the desktop environment is showing the application menu and menubar models outside the application as part of the desktop shell. For instance, on OS X, both menus will be displayed remotely; on Windows neither will be. gnome-shell (starting with version 3.4) will display the application menu, but not the menubar.

If the desktop environment does not display the menubar, then GtkApplicationWindow will automatically show a GtkMenuBar for it. This behaviour can be overridden with the GtkApplicationWindow:show-menubar property. If the desktop environment does not display the application menu, then it will automatically be included in the menubar or in the windows client-side decorations.

A GtkApplicationWindow with a menubar

(C Language Example):

GtkApplication *app = gtk_application_new ("org.gtk.test", 0);

GtkBuilder *builder = gtk_builder_new_from_string (
    "<interface>"
    "  <menu id='menubar'>"
    "    <submenu label='_Edit'>"
    "      <item label='_Copy' action='win.copy'/>"
    "      <item label='_Paste' action='win.paste'/>"
    "    </submenu>"
    "  </menu>"
    "</interface>",
    -1);

GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder,
                                                            "menubar"));
gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
g_object_unref (builder);

// ...

GtkWidget *window = gtk_application_window_new (app);

Handling fallback yourself

A simple example

The XML format understood by GtkBuilder for GMenuModel consists of a toplevel <menu> element, which contains one or more <item> elements. Each <item> element contains <attribute> and <link> elements with a mandatory name attribute. <link> elements have the same content model as <menu>. Instead of <link name="submenu> or <link name="section">, you can use <submenu> or <section> elements.

Attribute values can be translated using gettext, like other GtkBuilder content. <attribute> elements can be marked for translation with a translatable="yes" attribute. It is also possible to specify message context and translator comments, using the context and comments attributes. To make use of this, the GtkBuilder must have been given the gettext domain to use.

The following attributes are used when constructing menu items:

• “label”: a user-visible string to display
• “action”: the prefixed name of the action to trigger
• “target”: the parameter to use when activating the action
• “icon” and “verb-icon”: names of icons that may be displayed
• “submenu-action”: name of an action that may be used to determine if a submenu can be opened
• “hidden-when”: a string used to determine when the item will be hidden. Possible values include “action-disabled”, “action-missing”, “macos-menubar”.

The following attributes are used when constructing sections:

• “label”: a user-visible string to use as section heading
• “display-hint”: a string used to determine special formatting for the section. Possible values include “horizontal-buttons”.
• “text-direction”: a string used to determine the GtkTextDirection to use when “display-hint” is set to “horizontal-buttons”. Possible values include “rtl”, “ltr”, and “none”.

The following attributes are used when constructing submenus:

• “label”: a user-visible string to display
• “icon”: icon name to display

The ApplicationWindowProtocol protocol exposes the methods and properties of an underlying GtkApplicationWindow instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ApplicationWindow. Alternatively, use ApplicationWindowRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkArrow should be used to draw simple arrows that need to point in one of the four cardinal directions (up, down, left, or right). The style of the arrow can be one of shadow in, shadow out, etched in, or etched out. Note that these directions and style types may be amended in versions of GTK+ to come.

GtkArrow will fill any space alloted to it, but since it is inherited from GtkMisc, it can be padded and/or aligned, to fill exactly the space the programmer desires.

Arrows are created with a call to gtk_arrow_new(). The direction or style of an arrow can be changed after creation by using gtk_arrow_set().

GtkArrow has been deprecated; you can simply use a GtkImage with a suitable icon name, such as “pan-down-symbolic“. When replacing GtkArrow by an image, pay attention to the fact that GtkArrow is doing automatic flipping between GTK_ARROW_LEFT and GTK_ARROW_RIGHT, depending on the text direction. To get the same effect with an image, use the icon names “pan-start-symbolic“ and “pan-end-symbolic“, which react to the text direction.

The ArrowProtocol protocol exposes the methods and properties of an underlying GtkArrow instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Arrow. Alternatively, use ArrowRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ArrowAccessibleProtocol protocol exposes the methods and properties of an underlying GtkArrowAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ArrowAccessible. Alternatively, use ArrowAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkAspectFrame is useful when you want pack a widget so that it can resize but always retains the same aspect ratio. For instance, one might be drawing a small preview of a larger image. GtkAspectFrame derives from GtkFrame, so it can draw a label and a frame around the child. The frame will be “shrink-wrapped” to the size of the child.

CSS nodes

GtkAspectFrame uses a CSS node with name frame.

The AspectFrameProtocol protocol exposes the methods and properties of an underlying GtkAspectFrame instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AspectFrame. Alternatively, use AspectFrameRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkAssistant is a widget used to represent a generally complex operation splitted in several steps, guiding the user through its pages and controlling the page flow to collect the necessary data.

The design of GtkAssistant is that it controls what buttons to show and to make sensitive, based on what it knows about the page sequence and the type of each page, in addition to state information like the page completion and committed status.

If you have a case that doesn’t quite fit in GtkAssistants way of handling buttons, you can use the GTK_ASSISTANT_PAGE_CUSTOM page type and handle buttons yourself.

GtkAssistant as GtkBuildable

The GtkAssistant implementation of the GtkBuildable interface exposes the action_area as internal children with the name “action_area”.

To add pages to an assistant in GtkBuilder, simply add it as a child to the GtkAssistant object, and set its child properties as necessary.

CSS nodes

GtkAssistant has a single CSS node with the name assistant.

The AssistantProtocol protocol exposes the methods and properties of an underlying GtkAssistant instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Assistant. Alternatively, use AssistantRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkBin widget is a container with just one child. It is not very useful itself, but it is useful for deriving subclasses, since it provides common code needed for handling a single child widget.

Many GTK+ widgets are subclasses of GtkBin, including GtkWindow, GtkButton, GtkFrame, GtkHandleBox or GtkScrolledWindow.

The BinProtocol protocol exposes the methods and properties of an underlying GtkBin instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Bin. Alternatively, use BinRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AboutDialogClassProtocol protocol exposes the methods and properties of an underlying GtkAboutDialogClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AboutDialogClass. Alternatively, use AboutDialogClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AccelGroupClassProtocol protocol exposes the methods and properties of an underlying GtkAccelGroupClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelGroupClass. Alternatively, use AccelGroupClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AccelGroupEntryProtocol protocol exposes the methods and properties of an underlying GtkAccelGroupEntry instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelGroupEntry. Alternatively, use AccelGroupEntryRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AccelKeyProtocol protocol exposes the methods and properties of an underlying GtkAccelKey instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelKey. Alternatively, use AccelKeyRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AccelLabelClassProtocol protocol exposes the methods and properties of an underlying GtkAccelLabelClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelLabelClass. Alternatively, use AccelLabelClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AccelMapClassProtocol protocol exposes the methods and properties of an underlying GtkAccelMapClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccelMapClass. Alternatively, use AccelMapClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AccessibleClass. Alternatively, use AccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ActionBarClassProtocol protocol exposes the methods and properties of an underlying GtkActionBarClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActionBarClass. Alternatively, use ActionBarClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ActionClassProtocol protocol exposes the methods and properties of an underlying GtkActionClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActionClass. Alternatively, use ActionClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkActionEntry structs are used with gtk_action_group_add_actions() to construct actions.

The ActionEntryProtocol protocol exposes the methods and properties of an underlying GtkActionEntry instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActionEntry. Alternatively, use ActionEntryRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ActionGroupClassProtocol protocol exposes the methods and properties of an underlying GtkActionGroupClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActionGroupClass. Alternatively, use ActionGroupClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The interface vtable for GtkActionable.

The ActionableInterfaceProtocol protocol exposes the methods and properties of an underlying GtkActionableInterface instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActionableInterface. Alternatively, use ActionableInterfaceRef as a lighweight, unowned reference if you already have an instance you just want to use.

> This method can be called with a nil action at times.

The ActivatableIfaceProtocol protocol exposes the methods and properties of an underlying GtkActivatableIface instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ActivatableIface. Alternatively, use ActivatableIfaceRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AdjustmentClassProtocol protocol exposes the methods and properties of an underlying GtkAdjustmentClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AdjustmentClass. Alternatively, use AdjustmentClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AlignmentClassProtocol protocol exposes the methods and properties of an underlying GtkAlignmentClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AlignmentClass. Alternatively, use AlignmentClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AppChooserButtonClassProtocol protocol exposes the methods and properties of an underlying GtkAppChooserButtonClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AppChooserButtonClass. Alternatively, use AppChooserButtonClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AppChooserDialogClassProtocol protocol exposes the methods and properties of an underlying GtkAppChooserDialogClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AppChooserDialogClass. Alternatively, use AppChooserDialogClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AppChooserWidgetClassProtocol protocol exposes the methods and properties of an underlying GtkAppChooserWidgetClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AppChooserWidgetClass. Alternatively, use AppChooserWidgetClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ApplicationClassProtocol protocol exposes the methods and properties of an underlying GtkApplicationClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ApplicationClass. Alternatively, use ApplicationClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ApplicationWindowClassProtocol protocol exposes the methods and properties of an underlying GtkApplicationWindowClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ApplicationWindowClass. Alternatively, use ApplicationWindowClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ArrowAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkArrowAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ArrowAccessibleClass. Alternatively, use ArrowAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ArrowClassProtocol protocol exposes the methods and properties of an underlying GtkArrowClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ArrowClass. Alternatively, use ArrowClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AspectFrameClassProtocol protocol exposes the methods and properties of an underlying GtkAspectFrameClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AspectFrameClass. Alternatively, use AspectFrameClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The AssistantClassProtocol protocol exposes the methods and properties of an underlying GtkAssistantClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AssistantClass. Alternatively, use AssistantClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The BinClassProtocol protocol exposes the methods and properties of an underlying GtkBinClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BinClass. Alternatively, use BinClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

This interface provides a convenient way of associating widgets with actions on a GtkApplicationWindow or GtkApplication.

It primarily consists of two properties: GtkActionable:action-name and GtkActionable:action-target. There are also some convenience APIs for setting these properties.

The action will be looked up in action groups that are found among the widgets ancestors. Most commonly, these will be the actions with the “win.” or “app.” prefix that are associated with the GtkApplicationWindow or GtkApplication, but other action groups that are added with gtk_widget_insert_action_group() will be consulted as well.

The ActionableProtocol protocol exposes the methods and properties of an underlying GtkActionable instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Actionable. Alternatively, use ActionableRef as a lighweight, unowned reference if you already have an instance you just want to use.

Activatable widgets can be connected to a GtkAction and reflects the state of its action. A GtkActivatable can also provide feedback through its action, as they are responsible for activating their related actions.

Implementing GtkActivatable

When extending a class that is already GtkActivatable; it is only necessary to implement the GtkActivatable->sync_action_properties() and GtkActivatable->update() methods and chain up to the parent implementation, however when introducing a new GtkActivatable class; the GtkActivatable:related-action and GtkActivatable:use-action-appearance properties need to be handled by the implementor. Handling these properties is mostly a matter of installing the action pointer and boolean flag on your instance, and calling gtk_activatable_do_set_related_action() and gtk_activatable_sync_action_properties() at the appropriate times.

A class fragment implementing GtkActivatable

(C Language Example):

enum {
...

PROP_ACTIVATABLE_RELATED_ACTION,
PROP_ACTIVATABLE_USE_ACTION_APPEARANCE
}

struct _FooBarPrivate
{

  ...

  GtkAction      *action;
  gboolean        use_action_appearance;
};

...

static void foo_bar_activatable_interface_init         (GtkActivatableIface  *iface);
static void foo_bar_activatable_update                 (GtkActivatable       *activatable,
                                   GtkAction            *action,
                                   const gchar          *property_name);
static void foo_bar_activatable_sync_action_properties (GtkActivatable       *activatable,
                                   GtkAction            *action);
...


static void
foo_bar_class_init (FooBarClass *klass)
{

  ...

  g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_RELATED_ACTION, "related-action");
  g_object_class_override_property (gobject_class, PROP_ACTIVATABLE_USE_ACTION_APPEARANCE, "use-action-appearance");

  ...
}


static void
foo_bar_activatable_interface_init (GtkActivatableIface  *iface)
{
  iface->update = foo_bar_activatable_update;
  iface->sync_action_properties = foo_bar_activatable_sync_action_properties;
}

... Break the reference using gtk_activatable_do_set_related_action()...

static void
foo_bar_dispose (GObject *object)
{
  FooBar *bar = FOO_BAR (object);
  FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);

  ...

  if (priv->action)
    {
      gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (bar), NULL);
      priv->action = NULL;
    }
  G_OBJECT_CLASS (foo_bar_parent_class)->dispose (object);
}

... Handle the “related-action” and “use-action-appearance” properties ...

static void
foo_bar_set_property (GObject         *object,
                      guint            prop_id,
                      const GValue    *value,
                      GParamSpec      *pspec)
{
  FooBar *bar = FOO_BAR (object);
  FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);

  switch (prop_id)
    {

      ...

    case PROP_ACTIVATABLE_RELATED_ACTION:
      foo_bar_set_related_action (bar, g_value_get_object (value));
      break;
    case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:
      foo_bar_set_use_action_appearance (bar, g_value_get_boolean (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}

static void
foo_bar_get_property (GObject         *object,
                         guint            prop_id,
                         GValue          *value,
                         GParamSpec      *pspec)
{
  FooBar *bar = FOO_BAR (object);
  FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);

  switch (prop_id)
    {

      ...

    case PROP_ACTIVATABLE_RELATED_ACTION:
      g_value_set_object (value, priv->action);
      break;
    case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:
      g_value_set_boolean (value, priv->use_action_appearance);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
    }
}


static void
foo_bar_set_use_action_appearance (FooBar   *bar,
                   gboolean  use_appearance)
{
  FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);

  if (priv->use_action_appearance != use_appearance)
    {
      priv->use_action_appearance = use_appearance;

      gtk_activatable_sync_action_properties (GTK_ACTIVATABLE (bar), priv->action);
    }
}

... call gtk_activatable_do_set_related_action() and then assign the action pointer,
no need to reference the action here since gtk_activatable_do_set_related_action() already
holds a reference here for you...
static void
foo_bar_set_related_action (FooBar    *bar,
                GtkAction *action)
{
  FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (bar);

  if (priv->action == action)
    return;

  gtk_activatable_do_set_related_action (GTK_ACTIVATABLE (bar), action);

  priv->action = action;
}

... Selectively reset and update activatable depending on the use-action-appearance property ...
static void
gtk_button_activatable_sync_action_properties (GtkActivatable       *activatable,
                                          GtkAction            *action)
{
  GtkButtonPrivate *priv = GTK_BUTTON_GET_PRIVATE (activatable);

  if (!action)
    return;

  if (gtk_action_is_visible (action))
    gtk_widget_show (GTK_WIDGET (activatable));
  else
    gtk_widget_hide (GTK_WIDGET (activatable));

  gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));

  ...

  if (priv->use_action_appearance)
    {
      if (gtk_action_get_stock_id (action))
    foo_bar_set_stock (button, gtk_action_get_stock_id (action));
      else if (gtk_action_get_label (action))
    foo_bar_set_label (button, gtk_action_get_label (action));

      ...

    }
}

static void
foo_bar_activatable_update (GtkActivatable       *activatable,
                   GtkAction            *action,
                   const gchar          *property_name)
{
  FooBarPrivate *priv = FOO_BAR_GET_PRIVATE (activatable);

  if (strcmp (property_name, "visible") == 0)
    {
      if (gtk_action_is_visible (action))
    gtk_widget_show (GTK_WIDGET (activatable));
      else
    gtk_widget_hide (GTK_WIDGET (activatable));
    }
  else if (strcmp (property_name, "sensitive") == 0)
    gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));

  ...

  if (!priv->use_action_appearance)
    return;

  if (strcmp (property_name, "stock-id") == 0)
    foo_bar_set_stock (button, gtk_action_get_stock_id (action));
  else if (strcmp (property_name, "label") == 0)
    foo_bar_set_label (button, gtk_action_get_label (action));

  ...
}

The ActivatableProtocol protocol exposes the methods and properties of an underlying GtkActivatable instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Activatable. Alternatively, use ActivatableRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkAppChooser is an interface that can be implemented by widgets which allow the user to choose an application (typically for the purpose of opening a file). The main objects that implement this interface are GtkAppChooserWidget, GtkAppChooserDialog and GtkAppChooserButton.

Applications are represented by GIO GAppInfo objects here. GIO has a concept of recommended and fallback applications for a given content type. Recommended applications are those that claim to handle the content type itself, while fallback also includes applications that handle a more generic content type. GIO also knows the default and last-used application for a given content type. The GtkAppChooserWidget provides detailed control over whether the shown list of applications should include default, recommended or fallback applications.

To obtain the application that has been selected in a GtkAppChooser, use gtk_app_chooser_get_app_info().

The AppChooserProtocol protocol exposes the methods and properties of an underlying GtkAppChooser instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see AppChooser. Alternatively, use AppChooserRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkBuildable allows objects to extend and customize their deserialization from GtkBuilder UI descriptions. The interface includes methods for setting names and properties of objects, parsing custom tags and constructing child objects.

The GtkBuildable interface is implemented by all widgets and many of the non-widget objects that are provided by GTK+. The main user of this interface is GtkBuilder. There should be very little need for applications to call any of these functions directly.

An object only needs to implement this interface if it needs to extend the GtkBuilder format or run any extra routines at deserialization time.

The BuildableProtocol protocol exposes the methods and properties of an underlying GtkBuildable instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Buildable. Alternatively, use BuildableRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkBindingArg holds the data associated with an argument for a key binding signal emission as stored in GtkBindingSignal.

The BindingArgProtocol protocol exposes the methods and properties of an underlying GtkBindingArg instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BindingArg. Alternatively, use BindingArgRef as a lighweight, unowned reference if you already have an instance you just want to use.

Each key binding element of a binding sets binding list is represented by a GtkBindingEntry.

The BindingEntryProtocol protocol exposes the methods and properties of an underlying GtkBindingEntry instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BindingEntry. Alternatively, use BindingEntryRef as a lighweight, unowned reference if you already have an instance you just want to use.

A binding set maintains a list of activatable key bindings. A single binding set can match multiple types of widgets. Similar to style contexts, can be matched by any information contained in a widgets GtkWidgetPath. When a binding within a set is matched upon activation, an action signal is emitted on the target widget to carry out the actual activation.

The BindingSetProtocol protocol exposes the methods and properties of an underlying GtkBindingSet instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BindingSet. Alternatively, use BindingSetRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkBindingSignal stores the necessary information to activate a widget in response to a key press via a signal emission.

The BindingSignalProtocol protocol exposes the methods and properties of an underlying GtkBindingSignal instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BindingSignal. Alternatively, use BindingSignalRef as a lighweight, unowned reference if you already have an instance you just want to use.

The BooleanCellAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkBooleanCellAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BooleanCellAccessibleClass. Alternatively, use BooleanCellAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

A struct that specifies a border around a rectangular area that can be of different width on each side.

The BorderProtocol protocol exposes the methods and properties of an underlying GtkBorder instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Border. Alternatively, use BorderRef as a lighweight, unowned reference if you already have an instance you just want to use.

The BoxClassProtocol protocol exposes the methods and properties of an underlying GtkBoxClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BoxClass. Alternatively, use BoxClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkBuildableIface interface contains method that are necessary to allow GtkBuilder to construct an object from a GtkBuilder UI definition.

The BuildableIfaceProtocol protocol exposes the methods and properties of an underlying GtkBuildableIface instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BuildableIface. Alternatively, use BuildableIfaceRef as a lighweight, unowned reference if you already have an instance you just want to use.

The BuilderClassProtocol protocol exposes the methods and properties of an underlying GtkBuilderClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BuilderClass. Alternatively, use BuilderClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ButtonAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkButtonAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ButtonAccessibleClass. Alternatively, use ButtonAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ButtonBoxClassProtocol protocol exposes the methods and properties of an underlying GtkButtonBoxClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ButtonBoxClass. Alternatively, use ButtonBoxClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ButtonClassProtocol protocol exposes the methods and properties of an underlying GtkButtonClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ButtonClass. Alternatively, use ButtonClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CalendarClassProtocol protocol exposes the methods and properties of an underlying GtkCalendarClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CalendarClass. Alternatively, use CalendarClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The BooleanCellAccessibleProtocol protocol exposes the methods and properties of an underlying GtkBooleanCellAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see BooleanCellAccessible. Alternatively, use BooleanCellAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkBuilder is an auxiliary object that reads textual descriptions of a user interface and instantiates the described objects. To create a GtkBuilder from a user interface description, call gtk_builder_new_from_file(), gtk_builder_new_from_resource() or gtk_builder_new_from_string().

In the (unusual) case that you want to add user interface descriptions from multiple sources to the same GtkBuilder you can call gtk_builder_new() to get an empty builder and populate it by (multiple) calls to gtk_builder_add_from_file(), gtk_builder_add_from_resource() or gtk_builder_add_from_string().

A GtkBuilder holds a reference to all objects that it has constructed and drops these references when it is finalized. This finalization can cause the destruction of non-widget objects or widgets which are not contained in a toplevel window. For toplevel windows constructed by a builder, it is the responsibility of the user to call gtk_widget_destroy() to get rid of them and all the widgets they contain.

The functions gtk_builder_get_object() and gtk_builder_get_objects() can be used to access the widgets in the interface by the names assigned to them inside the UI description. Toplevel windows returned by these functions will stay around until the user explicitly destroys them with gtk_widget_destroy(). Other widgets will either be part of a larger hierarchy constructed by the builder (in which case you should not have to worry about their lifecycle), or without a parent, in which case they have to be added to some container to make use of them. Non-widget objects need to be reffed with g_object_ref() to keep them beyond the lifespan of the builder.

The function gtk_builder_connect_signals() and variants thereof can be used to connect handlers to the named signals in the description.

GtkBuilder UI Definitions #

GtkBuilder parses textual descriptions of user interfaces which are specified in an XML format which can be roughly described by the RELAX NG schema below. We refer to these descriptions as “GtkBuilder UI definitions” or just “UI definitions” if the context is clear. Do not confuse GtkBuilder UI Definitions with GtkUIManager UI Definitions, which are more limited in scope. It is common to use .ui as the filename extension for files containing GtkBuilder UI definitions.

RELAX NG Compact Syntax

The toplevel element is <interface>. It optionally takes a “domain” attribute, which will make the builder look for translated strings using dgettext() in the domain specified. This can also be done by calling gtk_builder_set_translation_domain() on the builder. Objects are described by <object> elements, which can contain <property> elements to set properties, <signal> elements which connect signals to handlers, and <child> elements, which describe child objects (most often widgets inside a container, but also e.g. actions in an action group, or columns in a tree model). A <child> element contains an <object> element which describes the child object. The target toolkit version(s) are described by <requires> elements, the “lib” attribute specifies the widget library in question (currently the only supported value is “gtk+”) and the “version” attribute specifies the target version in the form “<major>.<minor>”. The builder will error out if the version requirements are not met.

Typically, the specific kind of object represented by an <object> element is specified by the “class” attribute. If the type has not been loaded yet, GTK+ tries to find the get_type() function from the class name by applying heuristics. This works in most cases, but if necessary, it is possible to specify the name of the get_type() function explictly with the “type-func” attribute. As a special case, GtkBuilder allows to use an object that has been constructed by a GtkUIManager in another part of the UI definition by specifying the id of the GtkUIManager in the “constructor” attribute and the name of the object in the “id” attribute.

Objects may be given a name with the “id” attribute, which allows the application to retrieve them from the builder with gtk_builder_get_object(). An id is also necessary to use the object as property value in other parts of the UI definition. GTK+ reserves ids starting and ending with ___ (3 underscores) for its own purposes.

Setting properties of objects is pretty straightforward with the <property> element: the “name” attribute specifies the name of the property, and the content of the element specifies the value. If the “translatable” attribute is set to a true value, GTK+ uses gettext() (or dgettext() if the builder has a translation domain set) to find a translation for the value. This happens before the value is parsed, so it can be used for properties of any type, but it is probably most useful for string properties. It is also possible to specify a context to disambiguate short strings, and comments which may help the translators.

GtkBuilder can parse textual representations for the most common property types: characters, strings, integers, floating-point numbers, booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted as true, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted as false), enumerations (can be specified by their name, nick or integer value), flags (can be specified by their name, nick, integer value, optionally combined with “|”, e.g. “GTK_VISIBLE|GTK_REALIZED”) and colors (in a format understood by gdk_rgba_parse()).

GVariants can be specified in the format understood by g_variant_parse(), and pixbufs can be specified as a filename of an image file to load.

Objects can be referred to by their name and by default refer to objects declared in the local xml fragment and objects exposed via gtk_builder_expose_object(). In general, GtkBuilder allows forward references to objects — declared in the local xml; an object doesn’t have to be constructed before it can be referred to. The exception to this rule is that an object has to be constructed before it can be used as the value of a construct-only property.

It is also possible to bind a property value to another object’s property value using the attributes “bind-source” to specify the source object of the binding, “bind-property” to specify the source property and optionally “bind-flags” to specify the binding flags. Internally builder implements this using GBinding objects. For more information see g_object_bind_property()

Signal handlers are set up with the <signal> element. The “name” attribute specifies the name of the signal, and the “handler” attribute specifies the function to connect to the signal. By default, GTK+ tries to find the handler using g_module_symbol(), but this can be changed by passing a custom GtkBuilderConnectFunc to gtk_builder_connect_signals_full(). The remaining attributes, “after”, “swapped” and “object”, have the same meaning as the corresponding parameters of the g_signal_connect_object() or g_signal_connect_data() functions. A “last_modification_time” attribute is also allowed, but it does not have a meaning to the builder.

Sometimes it is necessary to refer to widgets which have implicitly been constructed by GTK+ as part of a composite widget, to set properties on them or to add further children (e.g. the vbox of a GtkDialog). This can be achieved by setting the “internal-child” property of the <child> element to a true value. Note that GtkBuilder still requires an <object> element for the internal child, even if it has already been constructed.

A number of widgets have different places where a child can be added (e.g. tabs vs. page content in notebooks). This can be reflected in a UI definition by specifying the “type” attribute on a <child> The possible values for the “type” attribute are described in the sections describing the widget-specific portions of UI definitions.

A GtkBuilder UI Definition

<interface>
  <object class="GtkDialog" id="dialog1">
    <child internal-child="vbox">
      <object class="GtkBox" id="vbox1">
        <property name="border-width">10</property>
        <child internal-child="action_area">
          <object class="GtkButtonBox" id="hbuttonbox1">
            <property name="border-width">20</property>
            <child>
              <object class="GtkButton" id="ok_button">
                <property name="label">gtk-ok</property>
                <property name="use-stock">TRUE</property>
                <signal name="clicked" handler="ok_button_clicked"/>
              </object>
            </child>
          </object>
        </child>
      </object>
    </child>
  </object>
</interface>

Beyond this general structure, several object classes define their own XML DTD fragments for filling in the ANY placeholders in the DTD above. Note that a custom element in a <child> element gets parsed by the custom tag handler of the parent object, while a custom element in an <object> element gets parsed by the custom tag handler of the object.

These XML fragments are explained in the documentation of the respective objects.

Additionally, since 3.10 a special <template> tag has been added to the format allowing one to define a widget class’s components. See the GtkWidget documentation for details.

The BuilderProtocol protocol exposes the methods and properties of an underlying GtkBuilder instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Builder. Alternatively, use BuilderRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkButton widget is generally used to trigger a callback function that is called when the button is pressed. The various signals and how to use them are outlined below.

The GtkButton widget can hold any valid child widget. That is, it can hold almost any other standard GtkWidget. The most commonly used child is the GtkLabel.

CSS nodes

GtkButton has a single CSS node with name button. The node will get the style classes .image-button or .text-button, if the content is just an image or label, respectively. It may also receive the .flat style class.

Other style classes that are commonly used with GtkButton include .suggested-action and .destructive-action. In special cases, buttons can be made round by adding the .circular style class.

Button-like widgets like GtkToggleButton, GtkMenuButton, GtkVolumeButton, GtkLockButton, GtkColorButton, GtkFontButton or GtkFileChooserButton use style classes such as .toggle, .popup, .scale, .lock, .color, .font, .file to differentiate themselves from a plain GtkButton.

The ButtonProtocol protocol exposes the methods and properties of an underlying GtkButton instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Button. Alternatively, use ButtonRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ButtonAccessibleProtocol protocol exposes the methods and properties of an underlying GtkButtonAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ButtonAccessible. Alternatively, use ButtonAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ButtonBoxProtocol protocol exposes the methods and properties of an underlying GtkButtonBox instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ButtonBox. Alternatively, use ButtonBoxRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCalendar is a widget that displays a Gregorian calendar, one month at a time. It can be created with gtk_calendar_new().

The month and year currently displayed can be altered with gtk_calendar_select_month(). The exact day can be selected from the displayed month using gtk_calendar_select_day().

To place a visual marker on a particular day, use gtk_calendar_mark_day() and to remove the marker, gtk_calendar_unmark_day(). Alternative, all marks can be cleared with gtk_calendar_clear_marks().

The way in which the calendar itself is displayed can be altered using gtk_calendar_set_display_options().

The selected date can be retrieved from a GtkCalendar using gtk_calendar_get_date().

Users should be aware that, although the Gregorian calendar is the legal calendar in most countries, it was adopted progressively between 1582 and 1929. Display before these dates is likely to be historically incorrect.

The CalendarProtocol protocol exposes the methods and properties of an underlying GtkCalendar instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Calendar. Alternatively, use CalendarRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellAccessibleProtocol protocol exposes the methods and properties of an underlying GtkCellAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAccessible. Alternatively, use CellAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkCellArea is an abstract class for GtkCellLayout widgets (also referred to as “layouting widgets”) to interface with an arbitrary number of GtkCellRenderers and interact with the user for a given GtkTreeModel row.

The cell area handles events, focus navigation, drawing and size requests and allocations for a given row of data.

Usually users dont have to interact with the GtkCellArea directly unless they are implementing a cell-layouting widget themselves.

Requesting area sizes

As outlined in GtkWidget’s geometry management section, GTK+ uses a height-for-width geometry management system to compute the sizes of widgets and user interfaces. GtkCellArea uses the same semantics to calculate the size of an area for an arbitrary number of GtkTreeModel rows.

When requesting the size of a cell area one needs to calculate the size for a handful of rows, and this will be done differently by different layouting widgets. For instance a GtkTreeViewColumn always lines up the areas from top to bottom while a GtkIconView on the other hand might enforce that all areas received the same width and wrap the areas around, requesting height for more cell areas when allocated less width.

It’s also important for areas to maintain some cell alignments with areas rendered for adjacent rows (cells can appear “columnized” inside an area even when the size of cells are different in each row). For this reason the GtkCellArea uses a GtkCellAreaContext object to store the alignments and sizes along the way (as well as the overall largest minimum and natural size for all the rows which have been calculated with the said context).

The GtkCellAreaContext is an opaque object specific to the GtkCellArea which created it (see gtk_cell_area_create_context()). The owning cell-layouting widget can create as many contexts as it wishes to calculate sizes of rows which should receive the same size in at least one orientation (horizontally or vertically), However, it’s important that the same GtkCellAreaContext which was used to request the sizes for a given GtkTreeModel row be used when rendering or processing events for that row.

In order to request the width of all the rows at the root level of a GtkTreeModel one would do the following:

(C Language Example):

GtkTreeIter iter;
gint        minimum_width;
gint        natural_width;

valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid)
  {
    gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
    gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);

    valid = gtk_tree_model_iter_next (model, &iter);
  }
gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);

Note that in this example it’s not important to observe the returned minimum and natural width of the area for each row unless the cell-layouting object is actually interested in the widths of individual rows. The overall width is however stored in the accompanying GtkCellAreaContext object and can be consulted at any time.

This can be useful since GtkCellLayout widgets usually have to support requesting and rendering rows in treemodels with an exceedingly large amount of rows. The GtkCellLayout widget in that case would calculate the required width of the rows in an idle or timeout source (see g_timeout_add()) and when the widget is requested its actual width in GtkWidgetClass.get_preferred_width() it can simply consult the width accumulated so far in the GtkCellAreaContext object.

A simple example where rows are rendered from top to bottom and take up the full width of the layouting widget would look like:

(C Language Example):

static void
foo_get_preferred_width (GtkWidget       *widget,
                         gint            *minimum_size,
                         gint            *natural_size)
{
  Foo        *foo  = FOO (widget);
  FooPrivate *priv = foo->priv;

  foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo);

  gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
}

In the above example the Foo widget has to make sure that some row sizes have been calculated (the amount of rows that Foo judged was appropriate to request space for in a single timeout iteration) before simply returning the amount of space required by the area via the GtkCellAreaContext.

Requesting the height for width (or width for height) of an area is a similar task except in this case the GtkCellAreaContext does not store the data (actually, it does not know how much space the layouting widget plans to allocate it for every row. It’s up to the layouting widget to render each row of data with the appropriate height and width which was requested by the GtkCellArea).

In order to request the height for width of all the rows at the root level of a GtkTreeModel one would do the following:

(C Language Example):

GtkTreeIter iter;
gint        minimum_height;
gint        natural_height;
gint        full_minimum_height = 0;
gint        full_natural_height = 0;

valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid)
  {
    gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
    gtk_cell_area_get_preferred_height_for_width (area, context, widget,
                                                  width, &minimum_height, &natural_height);

    if (width_is_for_allocation)
       cache_row_height (&iter, minimum_height, natural_height);

    full_minimum_height += minimum_height;
    full_natural_height += natural_height;

    valid = gtk_tree_model_iter_next (model, &iter);
  }

Note that in the above example we would need to cache the heights returned for each row so that we would know what sizes to render the areas for each row. However we would only want to really cache the heights if the request is intended for the layouting widgets real allocation.

In some cases the layouting widget is requested the height for an arbitrary for_width, this is a special case for layouting widgets who need to request size for tens of thousands of rows. For this case it’s only important that the layouting widget calculate one reasonably sized chunk of rows and return that height synchronously. The reasoning here is that any layouting widget is at least capable of synchronously calculating enough height to fill the screen height (or scrolled window height) in response to a single call to GtkWidgetClass.get_preferred_height_for_width(). Returning a perfect height for width that is larger than the screen area is inconsequential since after the layouting receives an allocation from a scrolled window it simply continues to drive the scrollbar values while more and more height is required for the row heights that are calculated in the background.

Rendering Areas

Once area sizes have been aquired at least for the rows in the visible area of the layouting widget they can be rendered at GtkWidgetClass.draw() time.

A crude example of how to render all the rows at the root level runs as follows:

(C Language Example):

GtkAllocation allocation;
GdkRectangle  cell_area = { 0, };
GtkTreeIter   iter;
gint          minimum_width;
gint          natural_width;

gtk_widget_get_allocation (widget, &allocation);
cell_area.width = allocation.width;

valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid)
  {
    cell_area.height = get_cached_height_for_row (&iter);

    gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
    gtk_cell_area_render (area, context, widget, cr,
                          &cell_area, &cell_area, state_flags, FALSE);

    cell_area.y += cell_area.height;

    valid = gtk_tree_model_iter_next (model, &iter);
  }

Note that the cached height in this example really depends on how the layouting widget works. The layouting widget might decide to give every row its minimum or natural height or, if the model content is expected to fit inside the layouting widget without scrolling, it would make sense to calculate the allocation for each row at GtkWidget::size-allocate time using gtk_distribute_natural_allocation().

Handling Events and Driving Keyboard Focus

Passing events to the area is as simple as handling events on any normal widget and then passing them to the gtk_cell_area_event() API as they come in. Usually GtkCellArea is only interested in button events, however some customized derived areas can be implemented who are interested in handling other events. Handling an event can trigger the GtkCellArea::focus-changed signal to fire; as well as GtkCellArea::add-editable in the case that an editable cell was clicked and needs to start editing. You can call gtk_cell_area_stop_editing() at any time to cancel any cell editing that is currently in progress.

The GtkCellArea drives keyboard focus from cell to cell in a way similar to GtkWidget. For layouting widgets that support giving focus to cells it’s important to remember to pass GTK_CELL_RENDERER_FOCUSED to the area functions for the row that has focus and to tell the area to paint the focus at render time.

Layouting widgets that accept focus on cells should implement the GtkWidgetClass.focus() virtual method. The layouting widget is always responsible for knowing where GtkTreeModel rows are rendered inside the widget, so at GtkWidgetClass.focus() time the layouting widget should use the GtkCellArea methods to navigate focus inside the area and then observe the GtkDirectionType to pass the focus to adjacent rows and areas.

A basic example of how the GtkWidgetClass.focus() virtual method should be implemented:

(C Language Example):

static gboolean
foo_focus (GtkWidget       *widget,
           GtkDirectionType direction)
{
  Foo        *foo  = FOO (widget);
  FooPrivate *priv = foo->priv;
  gint        focus_row;
  gboolean    have_focus = FALSE;

  focus_row = priv->focus_row;

  if (!gtk_widget_has_focus (widget))
    gtk_widget_grab_focus (widget);

  valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
  while (valid)
    {
      gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);

      if (gtk_cell_area_focus (priv->area, direction))
        {
           priv->focus_row = focus_row;
           have_focus = TRUE;
           break;
        }
      else
        {
          if (direction == GTK_DIR_RIGHT ||
              direction == GTK_DIR_LEFT)
            break;
          else if (direction == GTK_DIR_UP ||
                   direction == GTK_DIR_TAB_BACKWARD)
           {
              if (focus_row == 0)
                break;
              else
               {
                  focus_row--;
                  valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
               }
            }
          else
            {
              if (focus_row == last_row)
                break;
              else
                {
                  focus_row++;
                  valid = gtk_tree_model_iter_next (priv->model, &iter);
                }
            }
        }
    }
    return have_focus;
}

Note that the layouting widget is responsible for matching the GtkDirectionType values to the way it lays out its cells.

Cell Properties

The GtkCellArea introduces cell properties for GtkCellRenderers in very much the same way that GtkContainer introduces child properties for GtkWidgets. This provides some general interfaces for defining the relationship cell areas have with their cells. For instance in a GtkCellAreaBox a cell might “expand” and receive extra space when the area is allocated more than its full natural request, or a cell might be configured to “align” with adjacent rows which were requested and rendered with the same GtkCellAreaContext.

Use gtk_cell_area_class_install_cell_property() to install cell properties for a cell area class and gtk_cell_area_class_find_cell_property() or gtk_cell_area_class_list_cell_properties() to get information about existing cell properties.

To set the value of a cell property, use gtk_cell_area_cell_set_property(), gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain the value of a cell property, use gtk_cell_area_cell_get_property(), gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist().

The CellAreaProtocol protocol exposes the methods and properties of an underlying GtkCellArea instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellArea. Alternatively, use CellAreaRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkCellAreaBox renders cell renderers into a row or a column depending on its GtkOrientation.

GtkCellAreaBox uses a notion of packing. Packing refers to adding cell renderers with reference to a particular position in a GtkCellAreaBox. There are two reference positions: the start and the end of the box. When the GtkCellAreaBox is oriented in the GTK_ORIENTATION_VERTICAL orientation, the start is defined as the top of the box and the end is defined as the bottom. In the GTK_ORIENTATION_HORIZONTAL orientation start is defined as the left side and the end is defined as the right side.

Alignments of GtkCellRenderers rendered in adjacent rows can be configured by configuring the GtkCellAreaBox align child cell property with gtk_cell_area_cell_set_property() or by specifying the “align” argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().

The CellAreaBoxProtocol protocol exposes the methods and properties of an underlying GtkCellAreaBox instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAreaBox. Alternatively, use CellAreaBoxRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkCellAreaContext object is created by a given GtkCellArea implementation via its GtkCellAreaClass.create_context() virtual method and is used to store cell sizes and alignments for a series of GtkTreeModel rows that are requested and rendered in the same context.

GtkCellLayout widgets can create any number of contexts in which to request and render groups of data rows. However, it’s important that the same context which was used to request sizes for a given GtkTreeModel row also be used for the same row when calling other GtkCellArea APIs such as gtk_cell_area_render() and gtk_cell_area_event().

The CellAreaContextProtocol protocol exposes the methods and properties of an underlying GtkCellAreaContext instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAreaContext. Alternatively, use CellAreaContextRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkCellRenderer is a base class of a set of objects used for rendering a cell to a cairo_t. These objects are used primarily by the GtkTreeView widget, though they aren’t tied to them in any specific way. It is worth noting that GtkCellRenderer is not a GtkWidget and cannot be treated as such.

The primary use of a GtkCellRenderer is for drawing a certain graphical elements on a cairo_t. Typically, one cell renderer is used to draw many cells on the screen. To this extent, it isn’t expected that a CellRenderer keep any permanent state around. Instead, any state is set just prior to use using GObjects property system. Then, the cell is measured using gtk_cell_renderer_get_size(). Finally, the cell is rendered in the correct location using gtk_cell_renderer_render().

There are a number of rules that must be followed when writing a new GtkCellRenderer. First and foremost, it’s important that a certain set of properties will always yield a cell renderer of the same size, barring a GtkStyle change. The GtkCellRenderer also has a number of generic properties that are expected to be honored by all children.

Beyond merely rendering a cell, cell renderers can optionally provide active user interface elements. A cell renderer can be “activatable” like GtkCellRendererToggle, which toggles when it gets activated by a mouse click, or it can be “editable” like GtkCellRendererText, which allows the user to edit the text using a widget implementing the GtkCellEditable interface, e.g. GtkEntry. To make a cell renderer activatable or editable, you have to implement the GtkCellRendererClass.activate or GtkCellRendererClass.start_editing virtual functions, respectively.

Many properties of GtkCellRenderer and its subclasses have a corresponding “set” property, e.g. “cell-background-set” corresponds to “cell-background”. These “set” properties reflect whether a property has been set or not. You should not set them independently.

The CellRendererProtocol protocol exposes the methods and properties of an underlying GtkCellRenderer instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRenderer. Alternatively, use CellRendererRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCellRendererAccel displays a keyboard accelerator (i.e. a key combination like Control + a). If the cell renderer is editable, the accelerator can be changed by simply typing the new combination.

The GtkCellRendererAccel cell renderer was added in GTK+ 2.10.

The CellRendererAccelProtocol protocol exposes the methods and properties of an underlying GtkCellRendererAccel instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererAccel. Alternatively, use CellRendererAccelRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCellRendererCombo renders text in a cell like GtkCellRendererText from which it is derived. But while GtkCellRendererText offers a simple entry to edit the text, GtkCellRendererCombo offers a GtkComboBox widget to edit the text. The values to display in the combo box are taken from the tree model specified in the GtkCellRendererCombo:model property.

The combo cell renderer takes care of adding a text cell renderer to the combo box and sets it to display the column specified by its GtkCellRendererCombo:text-column property. Further properties of the combo box can be set in a handler for the GtkCellRenderer::editing-started signal.

The GtkCellRendererCombo cell renderer was added in GTK+ 2.6.

The CellRendererComboProtocol protocol exposes the methods and properties of an underlying GtkCellRendererCombo instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererCombo. Alternatively, use CellRendererComboRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkCellRendererPixbuf can be used to render an image in a cell. It allows to render either a given GdkPixbuf (set via the GtkCellRendererPixbuf:pixbuf property) or a named icon (set via the GtkCellRendererPixbuf:icon-name property).

To support the tree view, GtkCellRendererPixbuf also supports rendering two alternative pixbufs, when the GtkCellRenderer:is-expander property is true. If the GtkCellRenderer:is-expanded property is true and the GtkCellRendererPixbuf:pixbuf-expander-open property is set to a pixbuf, it renders that pixbuf, if the GtkCellRenderer:is-expanded property is false and the GtkCellRendererPixbuf:pixbuf-expander-closed property is set to a pixbuf, it renders that one.

The CellRendererPixbufProtocol protocol exposes the methods and properties of an underlying GtkCellRendererPixbuf instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererPixbuf. Alternatively, use CellRendererPixbufRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCellRendererProgress renders a numeric value as a progress par in a cell. Additionally, it can display a text on top of the progress bar.

The GtkCellRendererProgress cell renderer was added in GTK+ 2.6.

The CellRendererProgressProtocol protocol exposes the methods and properties of an underlying GtkCellRendererProgress instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererProgress. Alternatively, use CellRendererProgressRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCellRendererSpin renders text in a cell like GtkCellRendererText from which it is derived. But while GtkCellRendererText offers a simple entry to edit the text, GtkCellRendererSpin offers a GtkSpinButton widget. Of course, that means that the text has to be parseable as a floating point number.

The range of the spinbutton is taken from the adjustment property of the cell renderer, which can be set explicitly or mapped to a column in the tree model, like all properties of cell renders. GtkCellRendererSpin also has properties for the GtkCellRendererSpin:climb-rate and the number of GtkCellRendererSpin:digits to display. Other GtkSpinButton properties can be set in a handler for the GtkCellRenderer::editing-started signal.

The GtkCellRendererSpin cell renderer was added in GTK+ 2.10.

The CellRendererSpinProtocol protocol exposes the methods and properties of an underlying GtkCellRendererSpin instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererSpin. Alternatively, use CellRendererSpinRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCellRendererSpinner renders a spinning animation in a cell, very similar to GtkSpinner. It can often be used as an alternative to a GtkCellRendererProgress for displaying indefinite activity, instead of actual progress.

To start the animation in a cell, set the GtkCellRendererSpinner:active property to true and increment the GtkCellRendererSpinner:pulse property at regular intervals. The usual way to set the cell renderer properties for each cell is to bind them to columns in your tree model using e.g. gtk_tree_view_column_add_attribute().

The CellRendererSpinnerProtocol protocol exposes the methods and properties of an underlying GtkCellRendererSpinner instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererSpinner. Alternatively, use CellRendererSpinnerRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkCellRendererText renders a given text in its cell, using the font, color and style information provided by its properties. The text will be ellipsized if it is too long and the GtkCellRendererText:ellipsize property allows it.

If the GtkCellRenderer:mode is GTK_CELL_RENDERER_MODE_EDITABLE, the GtkCellRendererText allows to edit its text using an entry.

The CellRendererTextProtocol protocol exposes the methods and properties of an underlying GtkCellRendererText instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererText. Alternatively, use CellRendererTextRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCellRendererToggle renders a toggle button in a cell. The button is drawn as a radio or a checkbutton, depending on the GtkCellRendererToggle:radio property. When activated, it emits the GtkCellRendererToggle::toggled signal.

The CellRendererToggleProtocol protocol exposes the methods and properties of an underlying GtkCellRendererToggle instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererToggle. Alternatively, use CellRendererToggleRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkCellView displays a single row of a GtkTreeModel using a GtkCellArea and GtkCellAreaContext. A GtkCellAreaContext can be provided to the GtkCellView at construction time in order to keep the cellview in context of a group of cell views, this ensures that the renderers displayed will be properly aligned with eachother (like the aligned cells in the menus of GtkComboBox).

GtkCellView is GtkOrientable in order to decide in which orientation the underlying GtkCellAreaContext should be allocated. Taking the GtkComboBox menu as an example, cellviews should be oriented horizontally if the menus are listed top-to-bottom and thus all share the same width but may have separate individual heights (left-to-right menus should be allocated vertically since they all share the same height but may have variable widths).

CSS nodes

GtkCellView has a single CSS node with name cellview.

The CellViewProtocol protocol exposes the methods and properties of an underlying GtkCellView instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellView. Alternatively, use CellViewRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkCheckButton places a discrete GtkToggleButton next to a widget, (usually a GtkLabel). See the section on GtkToggleButton widgets for more information about toggle/check buttons.

The important signal ( GtkToggleButton::toggled ) is also inherited from GtkToggleButton.

CSS nodes

(plain Language Example):

checkbutton
├── check
╰── <child>

A GtkCheckButton with indicator (see gtk_toggle_button_set_mode()) has a main CSS node with name checkbutton and a subnode with name check.

(plain Language Example):

button.check
├── check
╰── <child>

A GtkCheckButton without indicator changes the name of its main node to button and adds a .check style class to it. The subnode is invisible in this case.

The CheckButtonProtocol protocol exposes the methods and properties of an underlying GtkCheckButton instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CheckButton. Alternatively, use CheckButtonRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkCheckMenuItem is a menu item that maintains the state of a boolean value in addition to a GtkMenuItem usual role in activating application code.

A check box indicating the state of the boolean value is displayed at the left side of the GtkMenuItem. Activating the GtkMenuItem toggles the value.

CSS nodes

(plain Language Example):

menuitem
├── check.left
╰── <child>

GtkCheckMenuItem has a main CSS node with name menuitem, and a subnode with name check, which gets the .left or .right style class.

The CheckMenuItemProtocol protocol exposes the methods and properties of an underlying GtkCheckMenuItem instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CheckMenuItem. Alternatively, use CheckMenuItemRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CheckMenuItemAccessibleProtocol protocol exposes the methods and properties of an underlying GtkCheckMenuItemAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CheckMenuItemAccessible. Alternatively, use CheckMenuItemAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ClipboardProtocol protocol exposes the methods and properties of an underlying GtkClipboard instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Clipboard. Alternatively, use ClipboardRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkColorButton is a button which displays the currently selected color and allows to open a color selection dialog to change the color. It is suitable widget for selecting a color in a preference dialog.

CSS nodes

GtkColorButton has a single CSS node with name button. To differentiate it from a plain GtkButton, it gets the .color style class.

The ColorButtonProtocol protocol exposes the methods and properties of an underlying GtkColorButton instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorButton. Alternatively, use ColorButtonRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkColorChooserDialog widget is a dialog for choosing a color. It implements the GtkColorChooser interface.

The ColorChooserDialogProtocol protocol exposes the methods and properties of an underlying GtkColorChooserDialog instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorChooserDialog. Alternatively, use ColorChooserDialogRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkColorChooserWidget widget lets the user select a color. By default, the chooser presents a predefined palette of colors, plus a small number of settable custom colors. It is also possible to select a different color with the single-color editor. To enter the single-color editing mode, use the context menu of any color of the palette, or use the ‘+’ button to add a new custom color.

The chooser automatically remembers the last selection, as well as custom colors.

To change the initially selected color, use gtk_color_chooser_set_rgba(). To get the selected color use gtk_color_chooser_get_rgba().

The GtkColorChooserWidget is used in the GtkColorChooserDialog to provide a dialog for selecting colors.

CSS names

GtkColorChooserWidget has a single CSS node with name colorchooser.

The ColorChooserWidgetProtocol protocol exposes the methods and properties of an underlying GtkColorChooserWidget instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorChooserWidget. Alternatively, use ColorChooserWidgetRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorSelectionProtocol protocol exposes the methods and properties of an underlying GtkColorSelection instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorSelection. Alternatively, use ColorSelectionRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorSelectionDialogProtocol protocol exposes the methods and properties of an underlying GtkColorSelectionDialog instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorSelectionDialog. Alternatively, use ColorSelectionDialogRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkComboBox is a widget that allows the user to choose from a list of valid choices. The GtkComboBox displays the selected choice. When activated, the GtkComboBox displays a popup which allows the user to make a new choice. The style in which the selected value is displayed, and the style of the popup is determined by the current theme. It may be similar to a Windows-style combo box.

The GtkComboBox uses the model-view pattern; the list of valid choices is specified in the form of a tree model, and the display of the choices can be adapted to the data in the model by using cell renderers, as you would in a tree view. This is possible since GtkComboBox implements the GtkCellLayout interface. The tree model holding the valid choices is not restricted to a flat list, it can be a real tree, and the popup will reflect the tree structure.

To allow the user to enter values not in the model, the “has-entry” property allows the GtkComboBox to contain a GtkEntry. This entry can be accessed by calling gtk_bin_get_child() on the combo box.

For a simple list of textual choices, the model-view API of GtkComboBox can be a bit overwhelming. In this case, GtkComboBoxText offers a simple alternative. Both GtkComboBox and GtkComboBoxText can contain an entry.

CSS nodes

(plain Language Example):

combobox
├── box.linked
│   ╰── button.combo
│       ╰── box
│           ├── cellview
│           ╰── arrow
╰── window.popup

A normal combobox contains a box with the .linked class, a button with the .combo class and inside those buttons, there are a cellview and an arrow.

(plain Language Example):

combobox
├── box.linked
│   ├── entry.combo
│   ╰── button.combo
│       ╰── box
│           ╰── arrow
╰── window.popup

A GtkComboBox with an entry has a single CSS node with name combobox. It contains a box with the .linked class. That box contains an entry and a button, both with the .combo class added. The button also contains another node with name arrow.

The ComboBoxProtocol protocol exposes the methods and properties of an underlying GtkComboBox instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ComboBox. Alternatively, use ComboBoxRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ComboBoxAccessibleProtocol protocol exposes the methods and properties of an underlying GtkComboBoxAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ComboBoxAccessible. Alternatively, use ComboBoxAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

A GtkComboBoxText is a simple variant of GtkComboBox that hides the model-view complexity for simple text-only use cases.

To create a GtkComboBoxText, use gtk_combo_box_text_new() or gtk_combo_box_text_new_with_entry().

You can add items to a GtkComboBoxText with gtk_combo_box_text_append_text(), gtk_combo_box_text_insert_text() or gtk_combo_box_text_prepend_text() and remove options with gtk_combo_box_text_remove().

If the GtkComboBoxText contains an entry (via the “has-entry” property), its contents can be retrieved using gtk_combo_box_text_get_active_text(). The entry itself can be accessed by calling gtk_bin_get_child() on the combo box.

You should not call gtk_combo_box_set_model() or attempt to pack more cells into this combo box via its GtkCellLayout interface.

GtkComboBoxText as GtkBuildable

The GtkComboBoxText implementation of the GtkBuildable interface supports adding items directly using the <items> element and specifying <item> elements for each item. Each <item> element can specify the “id” corresponding to the appended text and also supports the regular translation attributes “translatable”, “context” and “comments”.

Here is a UI definition fragment specifying GtkComboBoxText items:

<object class="GtkComboBoxText">
  <items>
    <item translatable="yes" id="factory">Factory</item>
    <item translatable="yes" id="home">Home</item>
    <item translatable="yes" id="subway">Subway</item>
  </items>
</object>

CSS nodes

(plain Language Example):

combobox
╰── box.linked
    ├── entry.combo
    ├── button.combo
    ╰── window.popup

GtkComboBoxText has a single CSS node with name combobox. It adds the style class .combo to the main CSS nodes of its entry and button children, and the .linked class to the node of its internal box.

The ComboBoxTextProtocol protocol exposes the methods and properties of an underlying GtkComboBoxText instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ComboBoxText. Alternatively, use ComboBoxTextRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ContainerAccessibleProtocol protocol exposes the methods and properties of an underlying GtkContainerAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ContainerAccessible. Alternatively, use ContainerAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ContainerCellAccessibleProtocol protocol exposes the methods and properties of an underlying GtkContainerCellAccessible instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ContainerCellAccessible. Alternatively, use ContainerCellAccessibleRef as a lighweight, unowned reference if you already have an instance you just want to use.

Dialog boxes are a convenient way to prompt the user for a small amount of input, e.g. to display a message, ask a question, or anything else that does not require extensive effort on the user’s part.

GTK+ treats a dialog as a window split vertically. The top section is a GtkVBox, and is where widgets such as a GtkLabel or a GtkEntry should be packed. The bottom area is known as the “action area”. This is generally used for packing buttons into the dialog which may perform functions such as cancel, ok, or apply.

GtkDialog boxes are created with a call to gtk_dialog_new() or gtk_dialog_new_with_buttons(). gtk_dialog_new_with_buttons() is recommended; it allows you to set the dialog title, some convenient flags, and add simple buttons.

If “dialog” is a newly created dialog, the two primary areas of the window can be accessed through gtk_dialog_get_content_area() and gtk_dialog_get_action_area(), as can be seen from the example below.

A “modal” dialog (that is, one which freezes the rest of the application from user input), can be created by calling gtk_window_set_modal() on the dialog. Use the GTK_WINDOW() macro to cast the widget returned from gtk_dialog_new() into a GtkWindow. When using gtk_dialog_new_with_buttons() you can also pass the GTK_DIALOG_MODAL flag to make a dialog modal.

If you add buttons to GtkDialog using gtk_dialog_new_with_buttons(), gtk_dialog_add_button(), gtk_dialog_add_buttons(), or gtk_dialog_add_action_widget(), clicking the button will emit a signal called GtkDialog::response with a response ID that you specified. GTK+ will never assign a meaning to positive response IDs; these are entirely user-defined. But for convenience, you can use the response IDs in the GtkResponseType enumeration (these all have values less than zero). If a dialog receives a delete event, the GtkDialog::response signal will be emitted with a response ID of GTK_RESPONSE_DELETE_EVENT.

If you want to block waiting for a dialog to return before returning control flow to your code, you can call gtk_dialog_run(). This function enters a recursive main loop and waits for the user to respond to the dialog, returning the response ID corresponding to the button the user clicked.

For the simple dialog in the following example, in reality you’d probably use GtkMessageDialog to save yourself some effort. But you’d need to create the dialog contents manually if you had more than a simple message in the dialog.

An example for simple GtkDialog usage: (C Language Example):

// Function to open a dialog box with a message
void
quick_message (GtkWindow *parent, gchar *message)
{
 GtkWidget *dialog, *label, *content_area;
 GtkDialogFlags flags;

 // Create the widgets
 flags = GTK_DIALOG_DESTROY_WITH_PARENT;
 dialog = gtk_dialog_new_with_buttons ("Message",
                                       parent,
                                       flags,
                                       _("_OK"),
                                       GTK_RESPONSE_NONE,
                                       NULL);
 content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
 label = gtk_label_new (message);

 // Ensure that the dialog box is destroyed when the user responds

 g_signal_connect_swapped (dialog,
                           "response",
                           G_CALLBACK (gtk_widget_destroy),
                           dialog);

 // Add the label, and show everything we’ve added

 gtk_container_add (GTK_CONTAINER (content_area), label);
 gtk_widget_show_all (dialog);
}

GtkDialog as GtkBuildable

The GtkDialog implementation of the GtkBuildable interface exposes the vbox and action_area as internal children with the names “vbox” and “action_area”.

GtkDialog supports a custom <action-widgets> element, which can contain multiple <action-widget> elements. The “response” attribute specifies a numeric response, and the content of the element is the id of widget (which should be a child of the dialogs action_area). To mark a response as default, set the “default“ attribute of the <action-widget> element to true.

GtkDialog supports adding action widgets by specifying “action“ as the “type“ attribute of a <child> element. The widget will be added either to the action area or the headerbar of the dialog, depending on the “use-header-bar“ property. The response id has to be associated with the action widget using the <action-widgets> element.

An example of a GtkDialog UI definition fragment:

<object class="GtkDialog" id="dialog1">
  <child type="action">
    <object class="GtkButton" id="button_cancel"/>
  </child>
  <child type="action">
    <object class="GtkButton" id="button_ok">
      <property name="can-default">True</property>
    </object>
  </child>
  <action-widgets>
    <action-widget response="cancel">button_cancel</action-widget>
    <action-widget response="ok" default="true">button_ok</action-widget>
  </action-widgets>
</object>

The DialogProtocol protocol exposes the methods and properties of an underlying GtkDialog instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Dialog. Alternatively, use DialogRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkCellAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAccessibleClass. Alternatively, use CellAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellAccessibleParentIfaceProtocol protocol exposes the methods and properties of an underlying GtkCellAccessibleParentIface instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAccessibleParentIface. Alternatively, use CellAccessibleParentIfaceRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellAreaBoxClassProtocol protocol exposes the methods and properties of an underlying GtkCellAreaBoxClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAreaBoxClass. Alternatively, use CellAreaBoxClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellAreaClassProtocol protocol exposes the methods and properties of an underlying GtkCellAreaClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAreaClass. Alternatively, use CellAreaClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellAreaContextClassProtocol protocol exposes the methods and properties of an underlying GtkCellAreaContextClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAreaContextClass. Alternatively, use CellAreaContextClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellEditableIfaceProtocol protocol exposes the methods and properties of an underlying GtkCellEditableIface instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellEditableIface. Alternatively, use CellEditableIfaceRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellLayoutIfaceProtocol protocol exposes the methods and properties of an underlying GtkCellLayoutIface instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellLayoutIface. Alternatively, use CellLayoutIfaceRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererAccelClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererAccelClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererAccelClass. Alternatively, use CellRendererAccelClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererClass. Alternatively, use CellRendererClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererClassPrivateProtocol protocol exposes the methods and properties of an underlying GtkCellRendererClassPrivate instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererClassPrivate. Alternatively, use CellRendererClassPrivateRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererComboClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererComboClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererComboClass. Alternatively, use CellRendererComboClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererPixbufClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererPixbufClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererPixbufClass. Alternatively, use CellRendererPixbufClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererProgressClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererProgressClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererProgressClass. Alternatively, use CellRendererProgressClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererSpinClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererSpinClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererSpinClass. Alternatively, use CellRendererSpinClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererSpinnerClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererSpinnerClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererSpinnerClass. Alternatively, use CellRendererSpinnerClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererTextClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererTextClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererTextClass. Alternatively, use CellRendererTextClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellRendererToggleClassProtocol protocol exposes the methods and properties of an underlying GtkCellRendererToggleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellRendererToggleClass. Alternatively, use CellRendererToggleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellViewClassProtocol protocol exposes the methods and properties of an underlying GtkCellViewClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellViewClass. Alternatively, use CellViewClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CheckButtonClassProtocol protocol exposes the methods and properties of an underlying GtkCheckButtonClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CheckButtonClass. Alternatively, use CheckButtonClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CheckMenuItemAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkCheckMenuItemAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CheckMenuItemAccessibleClass. Alternatively, use CheckMenuItemAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CheckMenuItemClassProtocol protocol exposes the methods and properties of an underlying GtkCheckMenuItemClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CheckMenuItemClass. Alternatively, use CheckMenuItemClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorButtonClassProtocol protocol exposes the methods and properties of an underlying GtkColorButtonClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorButtonClass. Alternatively, use ColorButtonClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorChooserDialogClassProtocol protocol exposes the methods and properties of an underlying GtkColorChooserDialogClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorChooserDialogClass. Alternatively, use ColorChooserDialogClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorChooserInterfaceProtocol protocol exposes the methods and properties of an underlying GtkColorChooserInterface instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorChooserInterface. Alternatively, use ColorChooserInterfaceRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorChooserWidgetClassProtocol protocol exposes the methods and properties of an underlying GtkColorChooserWidgetClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorChooserWidgetClass. Alternatively, use ColorChooserWidgetClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorSelectionClassProtocol protocol exposes the methods and properties of an underlying GtkColorSelectionClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorSelectionClass. Alternatively, use ColorSelectionClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ColorSelectionDialogClassProtocol protocol exposes the methods and properties of an underlying GtkColorSelectionDialogClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorSelectionDialogClass. Alternatively, use ColorSelectionDialogClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ComboBoxAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkComboBoxAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ComboBoxAccessibleClass. Alternatively, use ComboBoxAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ComboBoxClassProtocol protocol exposes the methods and properties of an underlying GtkComboBoxClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ComboBoxClass. Alternatively, use ComboBoxClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ComboBoxTextClassProtocol protocol exposes the methods and properties of an underlying GtkComboBoxTextClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ComboBoxTextClass. Alternatively, use ComboBoxTextClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ContainerAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkContainerAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ContainerAccessibleClass. Alternatively, use ContainerAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The ContainerCellAccessibleClassProtocol protocol exposes the methods and properties of an underlying GtkContainerCellAccessibleClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ContainerCellAccessibleClass. Alternatively, use ContainerCellAccessibleClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

Base class for containers.

The ContainerClassProtocol protocol exposes the methods and properties of an underlying GtkContainerClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ContainerClass. Alternatively, use ContainerClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CssProviderClassProtocol protocol exposes the methods and properties of an underlying GtkCssProviderClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CssProviderClass. Alternatively, use CssProviderClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

Defines a part of a CSS document. Because sections are nested into one another, you can use gtk_css_section_get_parent() to get the containing region.

The CssSectionProtocol protocol exposes the methods and properties of an underlying GtkCssSection instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CssSection. Alternatively, use CssSectionRef as a lighweight, unowned reference if you already have an instance you just want to use.

The DialogClassProtocol protocol exposes the methods and properties of an underlying GtkDialogClass instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see DialogClass. Alternatively, use DialogClassRef as a lighweight, unowned reference if you already have an instance you just want to use.

The CellAccessibleParentProtocol protocol exposes the methods and properties of an underlying GtkCellAccessibleParent instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellAccessibleParent. Alternatively, use CellAccessibleParentRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkCellEditable interface must be implemented for widgets to be usable to edit the contents of a GtkTreeView cell. It provides a way to specify how temporary widgets should be configured for editing, get the new value, etc.

The CellEditableProtocol protocol exposes the methods and properties of an underlying GtkCellEditable instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellEditable. Alternatively, use CellEditableRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkCellLayout is an interface to be implemented by all objects which want to provide a GtkTreeViewColumn like API for packing cells, setting attributes and data funcs.

One of the notable features provided by implementations of GtkCellLayout are attributes. Attributes let you set the properties in flexible ways. They can just be set to constant values like regular properties. But they can also be mapped to a column of the underlying tree model with gtk_cell_layout_set_attributes(), which means that the value of the attribute can change from cell to cell as they are rendered by the cell renderer. Finally, it is possible to specify a function with gtk_cell_layout_set_cell_data_func() that is called to determine the value of the attribute for each cell that is rendered.

GtkCellLayouts as GtkBuildable

Implementations of GtkCellLayout which also implement the GtkBuildable interface (GtkCellView, GtkIconView, GtkComboBox, GtkEntryCompletion, GtkTreeViewColumn) accept GtkCellRenderer objects as <child> elements in UI definitions. They support a custom <attributes> element for their children, which can contain multiple <attribute> elements. Each <attribute> element has a name attribute which specifies a property of the cell renderer; the content of the element is the attribute value.

This is an example of a UI definition fragment specifying attributes:

<object class="GtkCellView">
  <child>
    <object class="GtkCellRendererText"/>
    <attributes>
      <attribute name="text">0</attribute>
    </attributes>
  </child>"
</object>

Furthermore for implementations of GtkCellLayout that use a GtkCellArea to lay out cells (all GtkCellLayouts in GTK+ use a GtkCellArea) cell properties can also be defined in the format by specifying the custom <cell-packing> attribute which can contain multiple <property> elements defined in the normal way.

Here is a UI definition fragment specifying cell properties:

<object class="GtkTreeViewColumn">
  <child>
    <object class="GtkCellRendererText"/>
    <cell-packing>
      <property name="align">True</property>
      <property name="expand">False</property>
    </cell-packing>
  </child>"
</object>

Subclassing GtkCellLayout implementations

When subclassing a widget that implements GtkCellLayout like GtkIconView or GtkComboBox, there are some considerations related to the fact that these widgets internally use a GtkCellArea. The cell area is exposed as a construct-only property by these widgets. This means that it is possible to e.g. do

(C Language Example):

combo = g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL);

to use a custom cell area with a combo box. But construct properties are only initialized after instance init() functions have run, which means that using functions which rely on the existence of the cell area in your subclass’ init() function will cause the default cell area to be instantiated. In this case, a provided construct property value will be ignored (with a warning, to alert you to the problem).

(C Language Example):

static void
my_combo_box_init (MyComboBox *b)
{
  GtkCellRenderer *cell;

  cell = gtk_cell_renderer_pixbuf_new ();
  // The following call causes the default cell area for combo boxes,
  // a GtkCellAreaBox, to be instantiated
  gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE);
  ...
}

GtkWidget *
my_combo_box_new (GtkCellArea *area)
{
  // This call is going to cause a warning about area being ignored
  return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL);
}

If supporting alternative cell areas with your derived widget is not important, then this does not have to concern you. If you want to support alternative cell areas, you can do so by moving the problematic calls out of init() and into a constructor() for your class.

The CellLayoutProtocol protocol exposes the methods and properties of an underlying GtkCellLayout instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see CellLayout. Alternatively, use CellLayoutRef as a lighweight, unowned reference if you already have an instance you just want to use.

GtkColorChooser is an interface that is implemented by widgets for choosing colors. Depending on the situation, colors may be allowed to have alpha (translucency).

In GTK+, the main widgets that implement this interface are GtkColorChooserWidget, GtkColorChooserDialog and GtkColorButton.

The ColorChooserProtocol protocol exposes the methods and properties of an underlying GtkColorChooser instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see ColorChooser. Alternatively, use ColorChooserRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkEditable interface is an interface which should be implemented by text editing widgets, such as GtkEntry and GtkSpinButton. It contains functions for generically manipulating an editable widget, a large number of action signals used for key bindings, and several signals that an application can connect to to modify the behavior of a widget.

As an example of the latter usage, by connecting the following handler to GtkEditable::insert-text, an application can convert all entry into a widget into uppercase.

Forcing entry to uppercase.

(C Language Example):

#include <ctype.h>;

void
insert_text_handler (GtkEditable *editable,
                     const gchar *text,
                     gint         length,
                     gint        *position,
                     gpointer     data)
{
  gchar *result = g_utf8_strup (text, length);

  g_signal_handlers_block_by_func (editable,
                               (gpointer) insert_text_handler, data);
  gtk_editable_insert_text (editable, result, length, position);
  g_signal_handlers_unblock_by_func (editable,
                                     (gpointer) insert_text_handler, data);

  g_signal_stop_emission_by_name (editable, "insert_text");

  g_free (result);
}

The EditableProtocol protocol exposes the methods and properties of an underlying GtkEditable instance. The default implementation of these can be found in the protocol extension below. For a concrete class that implements these methods and properties, see Editable. Alternatively, use EditableRef as a lighweight, unowned reference if you already have an instance you just want to use.

The GtkDrawingArea widget is used for creating custom user interface elements. It’s essentially a blank widget; you can draw on it. After creating a drawing area, the application may want to connect to:

• Mouse and button press signals to respond to input from the user. (Use gtk_widget_add_events() to enable events you wish to receive.)

• The GtkWidget::realize signal to take any necessary actions when the widget is instantiated on a particular display. (Create GDK resources in response to this signal.)

• The GtkWidget::size-allocate signal to take any necessary actions when the widget changes size.

• The GtkWidget::draw signal to handle redrawing the contents of the widget.