GtkATContext is an abstract class provided by GTK to communicate to platform-specific assistive technologies API.

Each platform supported by GTK implements a GtkATContext subclass, and is responsible for updating the accessible state in response to state changes in GtkAccessible.

The ATContextRef type acts as a lightweight Swift reference to an underlying GtkATContext instance. It exposes methods that can operate on this data type through ATContextProtocol conformance. Use ATContextRef only as an unowned reference to an existing GtkATContext instance.

The GtkAboutDialog offers a simple way to display information about a program.

The shown information includes the programs’ 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 [funcGtk.show_uri] when a user clicks one. The behaviour can be overridden with the [signalGtk.AboutDialog::activate-link] signal.

To specify a person with an email address, use a string like Edgar Allan Poe <edgarpoe.com>. To specify a website with a title, use a string like GTK team https://www.gtk.org.

To make constructing a GtkAboutDialog as convenient as possible, you can use the function [funcGtk.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:

GFile *logo_file = g_file_new_for_path ("./logo.png");
GdkTexture *example_logo = gdk_texture_new_from_file (logo_file, NULL);
g_object_unref (logo_file);

gtk_show_about_dialog (NULL,
                       "program-name", "ExampleCode",
                       "logo", example_logo,
                       "title", `_("About ExampleCode")`,
                       NULL);

CSS nodes

GtkAboutDialog has a single CSS node with the name window and style class .aboutdialog.

The AboutDialogRef type acts as a lightweight Swift reference to an underlying GtkAboutDialog instance. It exposes methods that can operate on this data type through AboutDialogProtocol conformance. Use AboutDialogRef only as an unowned reference to an existing GtkAboutDialog instance.

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

actionbar
╰── revealer
    ╰── box
        ├── box.start
        │   ╰── [start children]
        ├── [center widget]
        ╰── box.end
            ╰── [end children]

A GtkActionBar‘s CSS node is called actionbar. It contains a revealer subnode, which contains a box subnode, which contains two box subnodes at the start and end of the action bar, with start and `end style classes respectively, as well as a center node that represents the center child.

Each of the boxes contains children packed for that side.

The ActionBarRef type acts as a lightweight Swift reference to an underlying GtkActionBar instance. It exposes methods that can operate on this data type through ActionBarProtocol conformance. Use ActionBarRef only as an unowned reference to an existing GtkActionBar instance.

A GtkShortcutAction that calls gtk_widget_activate().

The ActivateActionRef type acts as a lightweight Swift reference to an underlying GtkActivateAction instance. It exposes methods that can operate on this data type through ActivateActionProtocol conformance. Use ActivateActionRef only as an unowned reference to an existing GtkActivateAction instance.

GtkAdjustment is a model for a numeric value.

The `GtkAdjustment has an associated lower and upper bound. It also contains step and page increments, and a page size.

Adjustments are used within several GTK widgets, including [classGtk.SpinButton], [classGtk.Viewport], [classGtk.Scrollbar] and [classGtk.Scale].

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 AdjustmentRef type acts as a lightweight Swift reference to an underlying GtkAdjustment instance. It exposes methods that can operate on this data type through AdjustmentProtocol conformance. Use AdjustmentRef only as an unowned reference to an existing GtkAdjustment instance.

A GtkShortcutTrigger that combines two triggers.

The GtkAlternativeTrigger triggers when either of two trigger.

This can be cascaded to combine more than two triggers.

The AlternativeTriggerRef type acts as a lightweight Swift reference to an underlying GtkAlternativeTrigger instance. It exposes methods that can operate on this data type through AlternativeTriggerProtocol conformance. Use AlternativeTriggerRef only as an unowned reference to an existing GtkAlternativeTrigger instance.

GtkAnyFilter matches an item when at least one of its filters matches.

To add filters to a GtkAnyFilter, use [methodGtk.MultiFilter.append].

The AnyFilterRef type acts as a lightweight Swift reference to an underlying GtkAnyFilter instance. It exposes methods that can operate on this data type through AnyFilterProtocol conformance. Use AnyFilterRef only as an unowned reference to an existing GtkAnyFilter instance.

The GtkAppChooserButton lets the user select an application.

Initially, a GtkAppChooserButton selects the first application in its list, which will either be the most-recently used application or, if [propertyGtk.AppChooserButton: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 [propertyGtk.AppChooserButton:show-default-item] is set, the default application is also included. To let the user chooser other applications, you can set the [propertyGtk.AppChooserButton:show-dialog-item] property, which allows to open a full [classGtk.AppChooserDialog].

It is possible to add custom items to the list, using [methodGtk.AppChooserButton.append_custom_item]. These items cause the [signalGtk.AppChooserButton::custom-item-activated] signal to be emitted when they are selected.

To track changes in the selected application, use the [signalGtk.AppChooserButton::changed] signal.

CSS nodes

GtkAppChooserButton has a single CSS node with the name “appchooserbutton”.

The AppChooserButtonRef type acts as a lightweight Swift reference to an underlying GtkAppChooserButton instance. It exposes methods that can operate on this data type through AppChooserButtonProtocol conformance. Use AppChooserButtonRef only as an unowned reference to an existing GtkAppChooserButton instance.

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 [methodGtk.AppChooserDialog.get_widget] and call its methods if the generic [ifaceGtk.AppChooser] interface is not sufficient for your needs.

To set the heading that is shown above the GtkAppChooserWidget, use [methodGtk.AppChooserDialog.set_heading].

The AppChooserDialogRef type acts as a lightweight Swift reference to an underlying GtkAppChooserDialog instance. It exposes methods that can operate on this data type through AppChooserDialogProtocol conformance. Use AppChooserDialogRef only as an unowned reference to an existing GtkAppChooserDialog instance.

GtkAppChooserWidget is a widget for selecting applications.

It is the main building block for [classGtk.AppChooserDialog]. 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 [propertyGtk.AppChooserWidget:show-default], [propertyGtk.AppChooserWidget:show-recommended], [propertyGtk.AppChooserWidget:show-fallback], [propertyGtk.AppChooserWidget:show-other] and [propertyGtk.AppChooserWidget:show-all] properties. See the [ifaceGtk.AppChooser] documentation for more information about these groups of applications.

To keep track of the selected application, use the [signalGtk.AppChooserWidget::application-selected] and [signalGtk.AppChooserWidget::application-activated] signals.

CSS nodes

GtkAppChooserWidget has a single CSS node with name appchooser.

The AppChooserWidgetRef type acts as a lightweight Swift reference to an underlying GtkAppChooserWidget instance. It exposes methods that can operate on this data type through AppChooserWidgetProtocol conformance. Use AppChooserWidgetRef only as an unowned reference to an existing GtkAppChooserWidget instance.

GtkApplication is a high-level API for writing applications.

It supports many aspects of writing a GTK application in a convenient fashion, without enforcing a one-size-fits-all 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 [classGtk.Window]s, it is recommended to use it together with [classGtk.ApplicationWindow].

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 “menubar” is taken as the application’s menubar. Additional menus (most interesting submenus) can be named and accessed via [methodGtk.Application.get_menu_by_id] which allows for dynamic population of a part of the menu structure.

It is also possible to provide the menubar manually using [methodGtk.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 [methodGtk.IconTheme.add_resource_path] for more information.

If there is a resource located at “gtk/help-overlay.ui” which defines a [classGtk.ShortcutsWindow] with ID “help_overlay” then GtkApplication associates an instance of this shortcuts window with each [classGtk.ApplicationWindow] and sets up the keyboard accelerator <kbd>Control</kbd>+<kbd>?</kbd> 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 is available in the GTK source code repository

GtkApplication optionally registers with a session manager of the users session (if you set the [propertyGtk.Application: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 [methodGtk.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 ApplicationRef type acts as a lightweight Swift reference to an underlying GtkApplication instance. It exposes methods that can operate on this data type through ApplicationProtocol conformance. Use ApplicationRef only as an unowned reference to an existing GtkApplication instance.

GtkApplicationWindow is a GtkWindow subclass that integrates with GtkApplication.

Notably, GtkApplicationWindow can handle an application menubar.

This class implements the GActionGroup and GActionMap interfaces, to let you add window-specific actions that will be exported by the associated [classGtk.Application], 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 [ifaceGtk.Actionable] interface.

The settings [propertyGtk.Settings:gtk-shell-shows-app-menu] and [propertyGtk.Settings: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.

If the desktop environment does not display the menubar, then GtkApplicationWindow will automatically show a menubar for it. This behaviour can be overridden with the [propertyGtk.ApplicationWindow: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.

See [classGtk.PopoverMenu] for information about the XML language used by GtkBuilder for menu models.

See also: [methodGtk.Application.set_menubar].

A GtkApplicationWindow with a menubar

The code sample below shows how to set up a GtkApplicationWindow with a menu bar defined on the [classGtk.Application]:

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

GtkBuilder *builder = gtk_builder_new_from_string (
    "<interface>"
    "  <menu id='menubar'>"
    "    <submenu>"
    "      <attribute name='label' translatable='yes'>_Edit</attribute>"
    "      <item>"
    "        <attribute name='label' translatable='yes'>_Copy</attribute>"
    "        <attribute name='action'>win.copy</attribute>"
    "      </item>"
    "      <item>"
    "        <attribute name='label' translatable='yes'>_Paste</attribute>"
    "        <attribute name='action'>win.paste</attribute>"
    "      </item>"
    "    </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);

The ApplicationWindowRef type acts as a lightweight Swift reference to an underlying GtkApplicationWindow instance. It exposes methods that can operate on this data type through ApplicationWindowProtocol conformance. Use ApplicationWindowRef only as an unowned reference to an existing GtkApplicationWindow instance.

GtkAspectFrame preserves the aspect ratio of its child.

The frame can respect the aspect ratio of the child widget, or use its own aspect ratio.

CSS nodes

GtkAspectFrame uses a CSS node with name frame.

The AspectFrameRef type acts as a lightweight Swift reference to an underlying GtkAspectFrame instance. It exposes methods that can operate on this data type through AspectFrameProtocol conformance. Use AspectFrameRef only as an unowned reference to an existing GtkAspectFrame instance.

GtkAssistant is used to represent a complex as a series of steps.

Each step consists of one or more pages. GtkAssistant guides the user through the pages, and controls the page flow to collect the data needed for the operation.

GtkAssistant handles which buttons to show and to make sensitive based on page sequence knowledge and the [enumGtk.AssistantPageType] of each page in addition to state information like the completed and committed page statuses.

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 maintains a GtkAssistantPage object for each added child, which holds additional per-child properties. You obtain the GtkAssistantPage for a child with [methodGtk.Assistant.get_page].

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. If you need to set per-object properties, create a GtkAssistantPage object explicitly, and set the child widget as a property on it.

CSS nodes

GtkAssistant has a single CSS node with the name window and style class .assistant.

The AssistantRef type acts as a lightweight Swift reference to an underlying GtkAssistant instance. It exposes methods that can operate on this data type through AssistantProtocol conformance. Use AssistantRef only as an unowned reference to an existing GtkAssistant instance.

GtkAssistantPage is an auxiliary object used by `GtkAssistant.

The AssistantPageRef type acts as a lightweight Swift reference to an underlying GtkAssistantPage instance. It exposes methods that can operate on this data type through AssistantPageProtocol conformance. Use AssistantPageRef only as an unowned reference to an existing GtkAssistantPage instance.

GtkBinLayout is a GtkLayoutManager subclass useful for create “bins” of widgets.

GtkBinLayout will stack each child of a widget on top of each other, using the [propertyGtk.Widget:hexpand], [propertyGtk.Widget:vexpand], [propertyGtk.Widget:halign], and [propertyGtk.Widget:valign] properties of each child to determine where they should be positioned.

The BinLayoutRef type acts as a lightweight Swift reference to an underlying GtkBinLayout instance. It exposes methods that can operate on this data type through BinLayoutProtocol conformance. Use BinLayoutRef only as an unowned reference to an existing GtkBinLayout instance.

The ATContextClassRef type acts as a lightweight Swift reference to an underlying GtkATContextClass instance. It exposes methods that can operate on this data type through ATContextClassProtocol conformance. Use ATContextClassRef only as an unowned reference to an existing GtkATContextClass instance.

The AccessibleInterfaceRef type acts as a lightweight Swift reference to an underlying GtkAccessibleInterface instance. It exposes methods that can operate on this data type through AccessibleInterfaceProtocol conformance. Use AccessibleInterfaceRef only as an unowned reference to an existing GtkAccessibleInterface instance.

The interface vtable for GtkActionable.

The ActionableInterfaceRef type acts as a lightweight Swift reference to an underlying GtkActionableInterface instance. It exposes methods that can operate on this data type through ActionableInterfaceProtocol conformance. Use ActionableInterfaceRef only as an unowned reference to an existing GtkActionableInterface instance.

The ActivateActionClassRef type acts as a lightweight Swift reference to an underlying GtkActivateActionClass instance. It exposes methods that can operate on this data type through ActivateActionClassProtocol conformance. Use ActivateActionClassRef only as an unowned reference to an existing GtkActivateActionClass instance.

The AdjustmentClassRef type acts as a lightweight Swift reference to an underlying GtkAdjustmentClass instance. It exposes methods that can operate on this data type through AdjustmentClassProtocol conformance. Use AdjustmentClassRef only as an unowned reference to an existing GtkAdjustmentClass instance.

The AlternativeTriggerClassRef type acts as a lightweight Swift reference to an underlying GtkAlternativeTriggerClass instance. It exposes methods that can operate on this data type through AlternativeTriggerClassProtocol conformance. Use AlternativeTriggerClassRef only as an unowned reference to an existing GtkAlternativeTriggerClass instance.

The AnyFilterClassRef type acts as a lightweight Swift reference to an underlying GtkAnyFilterClass instance. It exposes methods that can operate on this data type through AnyFilterClassProtocol conformance. Use AnyFilterClassRef only as an unowned reference to an existing GtkAnyFilterClass instance.

The ApplicationClassRef type acts as a lightweight Swift reference to an underlying GtkApplicationClass instance. It exposes methods that can operate on this data type through ApplicationClassProtocol conformance. Use ApplicationClassRef only as an unowned reference to an existing GtkApplicationClass instance.

The ApplicationWindowClassRef type acts as a lightweight Swift reference to an underlying GtkApplicationWindowClass instance. It exposes methods that can operate on this data type through ApplicationWindowClassProtocol conformance. Use ApplicationWindowClassRef only as an unowned reference to an existing GtkApplicationWindowClass instance.

The BinLayoutClassRef type acts as a lightweight Swift reference to an underlying GtkBinLayoutClass instance. It exposes methods that can operate on this data type through BinLayoutClassProtocol conformance. Use BinLayoutClassRef only as an unowned reference to an existing GtkBinLayoutClass instance.

GtkAccessible is an interface for describing UI elements for Assistive Technologies.

Every accessible implementation has:

• a “role”, represented by a value of the [enumGtk.AccessibleRole] enumeration
• an “attribute”, represented by a set of [enumGtk.AccessibleState], [enumGtk.AccessibleProperty] and [enumGtk.AccessibleRelation] values

The role cannot be changed after instantiating a GtkAccessible implementation.

The attributes are updated every time a UI element’s state changes in a way that should be reflected by assistive technologies. For instance, if a GtkWidget visibility changes, the GTK_ACCESSIBLE_STATE_HIDDEN state will also change to reflect the [propertyGtk.Widget:visible] property.

The AccessibleRef type acts as a lightweight Swift reference to an underlying GtkAccessible instance. It exposes methods that can operate on this data type through AccessibleProtocol conformance. Use AccessibleRef only as an unowned reference to an existing GtkAccessible instance.

The GtkActionable interface provides a convenient way of asscociating widgets with actions.

It primarily consists of two properties: [propertyGtk.Actionable:action-name] and [propertyGtk.Actionable: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 [methodGtk.Widget.insert_action_group] will be consulted as well.

The ActionableRef type acts as a lightweight Swift reference to an underlying GtkActionable instance. It exposes methods that can operate on this data type through ActionableProtocol conformance. Use ActionableRef only as an unowned reference to an existing GtkActionable instance.

GtkAppChooser is an interface for widgets which allow the user to choose an application.

The main objects that implement this interface are [classGtk.AppChooserWidget], [classGtk.AppChooserDialog] and [classGtk.AppChooserButton].

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 [methodGtk.AppChooser.get_app_info].

The AppChooserRef type acts as a lightweight Swift reference to an underlying GtkAppChooser instance. It exposes methods that can operate on this data type through AppChooserProtocol conformance. Use AppChooserRef only as an unowned reference to an existing GtkAppChooser instance.

GtkBuildable allows objects to extend and customize their deserialization from ui files.

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 [classGtk.Builder]. 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 XML format or run any extra routines at deserialization time.

The BuildableRef type acts as a lightweight Swift reference to an underlying GtkBuildable instance. It exposes methods that can operate on this data type through BuildableProtocol conformance. Use BuildableRef only as an unowned reference to an existing GtkBuildable instance.

A GtkBitset represents a set of unsigned integers.

Another name for this data structure is “bitmap”.

The current implementation is based on roaring bitmaps.

A bitset allows adding a set of integers and provides support for set operations like unions, intersections and checks for equality or if a value is contained in the set. GtkBitset also contains various functions to query metadata about the bitset, such as the minimum or maximum values or its size.

The fastest way to iterate values in a bitset is [structGtk.BitsetIter].

The main use case for GtkBitset is implementing complex selections for [ifaceGtk.SelectionModel].

The BitsetRef type acts as a lightweight Swift reference to an underlying GtkBitset instance. It exposes methods that can operate on this data type through BitsetProtocol conformance. Use BitsetRef only as an unowned reference to an existing GtkBitset instance.

An opaque, stack-allocated struct for iterating over the elements of a GtkBitset.

Before a GtkBitsetIter can be used, it needs to be initialized with [funcGtk.BitsetIter.init_first], [funcGtk.BitsetIter.init_last] or [funcGtk.BitsetIter.init_at].

The BitsetIterRef type acts as a lightweight Swift reference to an underlying GtkBitsetIter instance. It exposes methods that can operate on this data type through BitsetIterProtocol conformance. Use BitsetIterRef only as an unowned reference to an existing GtkBitsetIter instance.

The BookmarkListClassRef type acts as a lightweight Swift reference to an underlying GtkBookmarkListClass instance. It exposes methods that can operate on this data type through BookmarkListClassProtocol conformance. Use BookmarkListClassRef only as an unowned reference to an existing GtkBookmarkListClass instance.

The BoolFilterClassRef type acts as a lightweight Swift reference to an underlying GtkBoolFilterClass instance. It exposes methods that can operate on this data type through BoolFilterClassProtocol conformance. Use BoolFilterClassRef only as an unowned reference to an existing GtkBoolFilterClass instance.

A struct that specifies a border around a rectangular area.

Each side can have different width.

The BorderRef type acts as a lightweight Swift reference to an underlying GtkBorder instance. It exposes methods that can operate on this data type through BorderProtocol conformance. Use BorderRef only as an unowned reference to an existing GtkBorder instance.

The BoxClassRef type acts as a lightweight Swift reference to an underlying GtkBoxClass instance. It exposes methods that can operate on this data type through BoxClassProtocol conformance. Use BoxClassRef only as an unowned reference to an existing GtkBoxClass instance.

The BoxLayoutClassRef type acts as a lightweight Swift reference to an underlying GtkBoxLayoutClass instance. It exposes methods that can operate on this data type through BoxLayoutClassProtocol conformance. Use BoxLayoutClassRef only as an unowned reference to an existing GtkBoxLayoutClass instance.

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

The BuildableIfaceRef type acts as a lightweight Swift reference to an underlying GtkBuildableIface instance. It exposes methods that can operate on this data type through BuildableIfaceProtocol conformance. Use BuildableIfaceRef only as an unowned reference to an existing GtkBuildableIface instance.

An opaque context struct for GtkBuildableParser.

The BuildableParseContextRef type acts as a lightweight Swift reference to an underlying GtkBuildableParseContext instance. It exposes methods that can operate on this data type through BuildableParseContextProtocol conformance. Use BuildableParseContextRef only as an unowned reference to an existing GtkBuildableParseContext instance.

A sub-parser for GtkBuildable implementations.

The BuildableParserRef type acts as a lightweight Swift reference to an underlying GtkBuildableParser instance. It exposes methods that can operate on this data type through BuildableParserProtocol conformance. Use BuildableParserRef only as an unowned reference to an existing GtkBuildableParser instance.

The BuilderCScopeClassRef type acts as a lightweight Swift reference to an underlying GtkBuilderCScopeClass instance. It exposes methods that can operate on this data type through BuilderCScopeClassProtocol conformance. Use BuilderCScopeClassRef only as an unowned reference to an existing GtkBuilderCScopeClass instance.

The BuilderClassRef type acts as a lightweight Swift reference to an underlying GtkBuilderClass instance. It exposes methods that can operate on this data type through BuilderClassProtocol conformance. Use BuilderClassRef only as an unowned reference to an existing GtkBuilderClass instance.

The BuilderListItemFactoryClassRef type acts as a lightweight Swift reference to an underlying GtkBuilderListItemFactoryClass instance. It exposes methods that can operate on this data type through BuilderListItemFactoryClassProtocol conformance. Use BuilderListItemFactoryClassRef only as an unowned reference to an existing GtkBuilderListItemFactoryClass instance.

The virtual function table to implement for GtkBuilderScope implementations. Default implementations for each function do exist, but they usually just fail, so it is suggested that implementations implement all of them.

The BuilderScopeInterfaceRef type acts as a lightweight Swift reference to an underlying GtkBuilderScopeInterface instance. It exposes methods that can operate on this data type through BuilderScopeInterfaceProtocol conformance. Use BuilderScopeInterfaceRef only as an unowned reference to an existing GtkBuilderScopeInterface instance.

The ButtonClassRef type acts as a lightweight Swift reference to an underlying GtkButtonClass instance. It exposes methods that can operate on this data type through ButtonClassProtocol conformance. Use ButtonClassRef only as an unowned reference to an existing GtkButtonClass instance.

The CallbackActionClassRef type acts as a lightweight Swift reference to an underlying GtkCallbackActionClass instance. It exposes methods that can operate on this data type through CallbackActionClassProtocol conformance. Use CallbackActionClassRef only as an unowned reference to an existing GtkCallbackActionClass instance.

GtkBookmarkList is a list model that wraps GBookmarkFile.

It presents a GListModel and fills it asynchronously with the GFileInfos returned from that function.

The GFileInfos in the list have some attributes in the recent namespace added: recentprivate`(boolean) andrecent:applications` (stringv).

The BookmarkListRef type acts as a lightweight Swift reference to an underlying GtkBookmarkList instance. It exposes methods that can operate on this data type through BookmarkListProtocol conformance. Use BookmarkListRef only as an unowned reference to an existing GtkBookmarkList instance.

GtkBoolFilter evaluates a boolean GtkExpression to determine whether to include items.

The BoolFilterRef type acts as a lightweight Swift reference to an underlying GtkBoolFilter instance. It exposes methods that can operate on this data type through BoolFilterProtocol conformance. Use BoolFilterRef only as an unowned reference to an existing GtkBoolFilter instance.

The GtkBox widget arranges child widgets into a single row or column.

Whether it is a row or column depends on the value of its [propertyGtk.Orientable:orientation] property. Within the other dimension, all children are allocated the same size. Of course, the [propertyGtk.Widget:halign] and [propertyGtk.Widget:valign] properties can be used on the children to influence their allocation.

Use repeated calls to [methodGtk.Box.append] to pack widgets into a GtkBox from start to end. Use [methodGtk.Box.remove] to remove widgets from the GtkBox. [methodGtk.Box.insert_child_after] can be used to add a child at a particular position.

Use [methodGtk.Box.set_homogeneous] to specify whether or not all children of the GtkBox are forced to get the same amount of space.

Use [methodGtk.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.

Use [methodGtk.Box.reorder_child_after] to move a child to a different place in the box.

CSS nodes

GtkBox uses a single CSS node with name box.

Accessibility

GtkBox uses the GTK_ACCESSIBLE_ROLE_GROUP role.

The BoxRef type acts as a lightweight Swift reference to an underlying GtkBox instance. It exposes methods that can operate on this data type through BoxProtocol conformance. Use BoxRef only as an unowned reference to an existing GtkBox instance.

GtkBoxLayout is a layout manager that arranges children in a single row or column.

Whether it is a row or column depends on the value of its [propertyGtk.Orientable:orientation] property. Within the other dimension all children all allocated the same size. The GtkBoxLayout will respect the [propertyGtk.Widget:halign] and [propertyGtk.Widget:valign] properties of each child widget.

If you want all children to be assigned the same size, you can use the [propertyGtk.BoxLayout:homogeneous] property.

If you want to specify the amount of space placed between each child, you can use the [propertyGtk.BoxLayout:spacing] property.

The BoxLayoutRef type acts as a lightweight Swift reference to an underlying GtkBoxLayout instance. It exposes methods that can operate on this data type through BoxLayoutProtocol conformance. Use BoxLayoutRef only as an unowned reference to an existing GtkBoxLayout instance.

A GtkBuilder reads XML descriptions of a user interface and instantiates the described objects.

To create a GtkBuilder from a user interface description, call [ctorGtk.Builder.new_from_file], [ctorGtk.Builder.new_from_resource] or [ctorGtk.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 [ctorGtk.Builder.new] to get an empty builder and populate it by (multiple) calls to [methodGtk.Builder.add_from_file], [methodGtk.Builder.add_from_resource] or [methodGtk.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 [methodGtk.Window.destroy] to get rid of them and all the widgets they contain.

The functions [methodGtk.Builder.get_object] and [methodGtk.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 [methodGtk.Window.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.

GtkBuilder UI Definitions

GtkBuilder parses textual descriptions of user interfaces which are specified in XML format. We refer to these descriptions as “GtkBuilder UI definitions” or just “UI definitions” if the context is clear.

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 [methodGtk.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>”. GtkBuilder 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 explicitly with the “type-func” attribute.

Objects may be given a name with the “id” attribute, which allows the application to retrieve them from the builder with [methodGtk.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 ___ (three consecutive 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_INPUT_HINT_EMOJI|GTK_INPUT_HINT_LOWERCASE”) and colors (in a format understood by [methodGdk.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 [methodGtk.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, and optionally, “bind-property” and “bind-flags” to specify the source property and source binding flags respectively. Internally, GtkBuilder implements this using GBinding objects. For more information see g_object_bind_property().

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 content area 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.

Signal handlers and function pointers

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

If you rely on GModule support to lookup callbacks in the symbol table, the following details should be noted:

When compiling applications for Windows, you must declare signal callbacks with G_MODULE_EXPORT, or they will not be put in the symbol table. On Linux and Unix, this is not necessary; applications should instead be compiled with the -Wl,–export-dynamic CFLAGS, and linked against gmodule-export-2.0.

A GtkBuilder UI Definition

<interface>
  <object class="GtkDialog" id="dialog1">
    <child internal-child="content_area">
      <object class="GtkBox" id="vbox1">
        <child internal-child="action_area">
          <object class="GtkBox" id="hbuttonbox1">
            <child>
              <object class="GtkButton" id="ok_button">
                <property name="label" translatable="yes">_Ok</property>
                <property name="use-underline">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.

A <template> tag can be used to define a widget class’s components. See the GtkWidget documentation for details.

The BuilderRef type acts as a lightweight Swift reference to an underlying GtkBuilder instance. It exposes methods that can operate on this data type through BuilderProtocol conformance. Use BuilderRef only as an unowned reference to an existing GtkBuilder instance.

A GtkBuilderScope implementation for the C language.

GtkBuilderCScope instances use symbols explicitly added to builder with prior calls to [methodGtk.BuilderCScope.add_callback_symbol]. If developers want to do that, they are encouraged to create their own scopes for that purpose.

In the case that symbols are not explicitly added; GTK will uses GModule’s introspective features (by opening the module nil) to look at the application’s symbol table. From here it tries to match the signal function names given in the interface description with symbols in the application.

Note that unless [methodGtk.BuilderCScope.add_callback_symbol] is called for all signal callbacks which are referenced by the loaded XML, this functionality will require that GModule be supported on the platform.

The BuilderCScopeRef type acts as a lightweight Swift reference to an underlying GtkBuilderCScope instance. It exposes methods that can operate on this data type through BuilderCScopeProtocol conformance. Use BuilderCScopeRef only as an unowned reference to an existing GtkBuilderCScope instance.

GtkBuilderListItemFactory is a GtkListItemFactory that creates widgets by instantiating GtkBuilder UI templates.

The templates must be extending GtkListItem, and typically use GtkExpressions to obtain data from the items in the model.

Example:

  <interface>
    <template class="GtkListItem">
      <property name="child">
        <object class="GtkLabel">
          <property name="xalign">0</property>
          <binding name="label">
            <lookup name="name" type="SettingsKey">
              <lookup name="item">GtkListItem</lookup>
            </lookup>
          </binding>
        </object>
      </property>
    </template>
  </interface>

The BuilderListItemFactoryRef type acts as a lightweight Swift reference to an underlying GtkBuilderListItemFactory instance. It exposes methods that can operate on this data type through BuilderListItemFactoryProtocol conformance. Use BuilderListItemFactoryRef only as an unowned reference to an existing GtkBuilderListItemFactory instance.

The GtkButton widget is generally used to trigger a callback function that is called when the button is pressed.

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. When activating a button via the keyboard, the button will temporarily gain the .keyboard-activating 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 [classGtk.ToggleButton], [classGtk.MenuButton], [classGtk.VolumeButton], [classGtk.LockButton], [classGtk.ColorButton] or [classGtk.FontButton] use style classes such as .toggle, .popup, .scale, .lock, .color on the button node to differentiate themselves from a plain GtkButton.

Accessibility

GtkButton uses the GTK_ACCESSIBLE_ROLE_BUTTON role.

The ButtonRef type acts as a lightweight Swift reference to an underlying GtkButton instance. It exposes methods that can operate on this data type through ButtonProtocol conformance. Use ButtonRef only as an unowned reference to an existing GtkButton instance.

A variant of GtkClosureExpression using a C closure.

The CClosureExpressionRef type acts as a lightweight Swift reference to an underlying GtkCClosureExpression instance. It exposes methods that can operate on this data type through CClosureExpressionProtocol conformance. Use CClosureExpressionRef only as an unowned reference to an existing GtkCClosureExpression instance.

GtkBuilderScope is an interface to provide language binding support to GtkBuilder.

The goal of GtkBuilderScope is to look up programming-language-specific values for strings that are given in a GtkBuilder UI file.

The primary intended audience is bindings that want to provide deeper integration of GtkBuilder into the language.

A GtkBuilderScope instance may be used with multiple GtkBuilder objects, even at once.

By default, GTK will use its own implementation of GtkBuilderScope for the C language which can be created via [ctorGtk.BuilderCScope.new].

The BuilderScopeRef type acts as a lightweight Swift reference to an underlying GtkBuilderScope instance. It exposes methods that can operate on this data type through BuilderScopeProtocol conformance. Use BuilderScopeRef only as an unowned reference to an existing GtkBuilderScope instance.

Interface for widgets that can be used for editing cells

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 CellEditableRef type acts as a lightweight Swift reference to an underlying GtkCellEditable instance. It exposes methods that can operate on this data type through CellEditableProtocol conformance. Use CellEditableRef only as an unowned reference to an existing GtkCellEditable instance.

GtkCalendar is a widget that displays a Gregorian calendar, one month at a time.

A GtkCalendar can be created with [ctorGtk.Calendar.new].

The date that is currently displayed can be altered with [methodGtk.Calendar.select_day].

To place a visual marker on a particular day, use [methodGtk.Calendar.mark_day] and to remove the marker, [methodGtk.Calendar.unmark_day]. Alternative, all marks can be cleared with [methodGtk.Calendar.clear_marks].

The selected date can be retrieved from a GtkCalendar using [methodGtk.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.

CSS nodes

calendar.view
├── header
│   ├── button
│   ├── stack.month
│   ├── button
│   ├── button
│   ├── label.year
│   ╰── button
╰── grid
    ╰── label[.day-name][.week-number][.day-number][.other-month][.today]

GtkCalendar has a main node with name calendar. It contains a subnode called header containing the widgets for switching between years and months.

The grid subnode contains all day labels, including week numbers on the left (marked with the .week-number css class) and day names on top (marked with the .day-name css class).

Day labels that belong to the previous or next month get the .other-month style class. The label of the current day get the .today style class.

Marked day labels get the :selected state assigned.

The CalendarRef type acts as a lightweight Swift reference to an underlying GtkCalendar instance. It exposes methods that can operate on this data type through CalendarProtocol conformance. Use CalendarRef only as an unowned reference to an existing GtkCalendar instance.

A GtkShortcutAction that invokes a callback.

The CallbackActionRef type acts as a lightweight Swift reference to an underlying GtkCallbackAction instance. It exposes methods that can operate on this data type through CallbackActionProtocol conformance. Use CallbackActionRef only as an unowned reference to an existing GtkCallbackAction instance.

An abstract class for laying out GtkCellRenderers

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;
int         minimum_width;
int         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 [vfuncGtk.Widget.measure] 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,
                         int             *minimum_size,
                         int             *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;
int         minimum_height;
int         natural_height;
int         full_minimum_height = 0;
int         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 [vfuncGtk.Widget.measure]. 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 acquired at least for the rows in the visible area of the layouting widget they can be rendered at [vfuncGtk.Widget.snapshot] 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;
int           minimum_width;
int           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 the time the widget is allocated 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 GtkCellAreafocus-changed signal to fire; as well as GtkCellAreaadd-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 [vfuncGtk.Widget.focus] virtual method. The layouting widget is always responsible for knowing where GtkTreeModel rows are rendered inside the widget, so at [vfuncGtk.Widget.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 [vfuncGtk.Widget.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;
  int         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. 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 CellAreaRef type acts as a lightweight Swift reference to an underlying GtkCellArea instance. It exposes methods that can operate on this data type through CellAreaProtocol conformance. Use CellAreaRef only as an unowned reference to an existing GtkCellArea instance.

A cell area that renders GtkCellRenderers into a row or a column

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 CellAreaBoxRef type acts as a lightweight Swift reference to an underlying GtkCellAreaBox instance. It exposes methods that can operate on this data type through CellAreaBoxProtocol conformance. Use CellAreaBoxRef only as an unowned reference to an existing GtkCellAreaBox instance.

Stores geometrical information for a series of rows in a GtkCellArea

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 CellAreaContextRef type acts as a lightweight Swift reference to an underlying GtkCellAreaContext instance. It exposes methods that can operate on this data type through CellAreaContextProtocol conformance. Use CellAreaContextRef only as an unowned reference to an existing GtkCellAreaContext instance.

An object for rendering a single cell

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_preferred_size(). Finally, the cell is rendered in the correct location using gtk_cell_renderer_snapshot().

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 style 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 CellRendererRef type acts as a lightweight Swift reference to an underlying GtkCellRenderer instance. It exposes methods that can operate on this data type through CellRendererProtocol conformance. Use CellRendererRef only as an unowned reference to an existing GtkCellRenderer instance.

Renders a keyboard accelerator in a cell

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 CellRendererAccelRef type acts as a lightweight Swift reference to an underlying GtkCellRendererAccel instance. It exposes methods that can operate on this data type through CellRendererAccelProtocol conformance. Use CellRendererAccelRef only as an unowned reference to an existing GtkCellRendererAccel instance.

Renders a combobox in a cell

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 GtkCellRendererediting-started`` signal.

The CellRendererComboRef type acts as a lightweight Swift reference to an underlying GtkCellRendererCombo instance. It exposes methods that can operate on this data type through CellRendererComboProtocol conformance. Use CellRendererComboRef only as an unowned reference to an existing GtkCellRendererCombo instance.

Renders a pixbuf in a cell

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 CellRendererPixbufRef type acts as a lightweight Swift reference to an underlying GtkCellRendererPixbuf instance. It exposes methods that can operate on this data type through CellRendererPixbufProtocol conformance. Use CellRendererPixbufRef only as an unowned reference to an existing GtkCellRendererPixbuf instance.

Renders numbers as progress bars

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 CellRendererProgressRef type acts as a lightweight Swift reference to an underlying GtkCellRendererProgress instance. It exposes methods that can operate on this data type through CellRendererProgressProtocol conformance. Use CellRendererProgressRef only as an unowned reference to an existing GtkCellRendererProgress instance.

Renders a spin button in a cell

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 GtkCellRendererediting-started`` signal.

The GtkCellRendererSpin cell renderer was added in GTK 2.10.

The CellRendererSpinRef type acts as a lightweight Swift reference to an underlying GtkCellRendererSpin instance. It exposes methods that can operate on this data type through CellRendererSpinProtocol conformance. Use CellRendererSpinRef only as an unowned reference to an existing GtkCellRendererSpin instance.

Renders a spinning animation in a cell

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 CellRendererSpinnerRef type acts as a lightweight Swift reference to an underlying GtkCellRendererSpinner instance. It exposes methods that can operate on this data type through CellRendererSpinnerProtocol conformance. Use CellRendererSpinnerRef only as an unowned reference to an existing GtkCellRendererSpinner instance.

Renders text in a cell

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 CellRendererTextRef type acts as a lightweight Swift reference to an underlying GtkCellRendererText instance. It exposes methods that can operate on this data type through CellRendererTextProtocol conformance. Use CellRendererTextRef only as an unowned reference to an existing GtkCellRendererText instance.

Renders a toggle button in a cell

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 GtkCellRendererToggletoggled`` signal.

The CellRendererToggleRef type acts as a lightweight Swift reference to an underlying GtkCellRendererToggle instance. It exposes methods that can operate on this data type through CellRendererToggleProtocol conformance. Use CellRendererToggleRef only as an unowned reference to an existing GtkCellRendererToggle instance.

A widget displaying a single row of a GtkTreeModel

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 each other (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 CellViewRef type acts as a lightweight Swift reference to an underlying GtkCellView instance. It exposes methods that can operate on this data type through CellViewProtocol conformance. Use CellViewRef only as an unowned reference to an existing GtkCellView instance.

GtkCenterBox arranges three children in a row, keeping the middle child centered as well as possible.

To add children to GtkCenterBox, use [methodGtk.CenterBox.set_start_widget], [methodGtk.CenterBox.set_center_widget] and [methodGtk.CenterBox.set_end_widget].

The sizing and positioning of children can be influenced with the align and expand properties of the children.

GtkCenterBox as GtkBuildable

The GtkCenterBox implementation of the GtkBuildable interface supports placing children in the 3 positions by specifying “start”, “center” or “end” as the “type” attribute of a <child> element.

CSS nodes

GtkCenterBox uses a single CSS node with the name “box”,

The first child of the GtkCenterBox will be allocated depending on the text direction, i.e. in left-to-right layouts it will be allocated on the left and in right-to-left layouts on the right.

In vertical orientation, the nodes of the children are arranged from top to bottom.

Accessibility

GtkCenterBox uses the GTK_ACCESSIBLE_ROLE_GROUP role.

The CenterBoxRef type acts as a lightweight Swift reference to an underlying GtkCenterBox instance. It exposes methods that can operate on this data type through CenterBoxProtocol conformance. Use CenterBoxRef only as an unowned reference to an existing GtkCenterBox instance.

GtkCenterLayout is a layout manager that manages up to three children.

The start widget is allocated at the start of the layout (left in left-to-right locales and right in right-to-left ones), and the end widget at the end.

The center widget is centered regarding the full width of the layout’s.

The CenterLayoutRef type acts as a lightweight Swift reference to an underlying GtkCenterLayout instance. It exposes methods that can operate on this data type through CenterLayoutProtocol conformance. Use CenterLayoutRef only as an unowned reference to an existing GtkCenterLayout instance.

A GtkCheckButton places a label next to an indicator.

A GtkCheckButton is created by calling either [ctorGtk.CheckButton.new] or [ctorGtk.CheckButton.new_with_label].

The state of a GtkCheckButton can be set specifically using [methodGtk.CheckButton.set_active], and retrieved using [methodGtk.CheckButton.get_active].

Inconsistent state

In addition to “on” and “off”, check buttons can be an “in between” state that is neither on nor off. This can be used e.g. when the user has selected a range of elements (such as some text or spreadsheet cells) that are affected by a check button, and the current values in that range are inconsistent.

To set a GtkCheckButton to inconsistent state, use [methodGtk.CheckButton.set_inconsistent].

Grouping

Check buttons can be grouped together, to form mutually exclusive groups - only one of the buttons can be toggled at a time, and toggling another one will switch the currently toggled one off.

Grouped check buttons use a different indicator, and are commonly referred to as radio buttons.

To add a GtkCheckButton to a group, use [methodGtk.CheckButton.set_group].

CSS nodes

checkbutton[.text-button]
├── check
╰── [label]

A GtkCheckButton has a main node with name checkbutton. If the [propertyGtk.CheckButton:label] property is set, it contains a label child. The indicator node is named check when no group is set, and radio if the checkbutton is grouped together with other checkbuttons.

Accessibility

GtkCheckButton uses the GTK_ACCESSIBLE_ROLE_CHECKBOX role.

The CheckButtonRef type acts as a lightweight Swift reference to an underlying GtkCheckButton instance. It exposes methods that can operate on this data type through CheckButtonProtocol conformance. Use CheckButtonRef only as an unowned reference to an existing GtkCheckButton instance.

An expression using a custom GClosure to compute the value from its parameters.

The ClosureExpressionRef type acts as a lightweight Swift reference to an underlying GtkClosureExpression instance. It exposes methods that can operate on this data type through ClosureExpressionProtocol conformance. Use ClosureExpressionRef only as an unowned reference to an existing GtkClosureExpression instance.

The GtkColorButton allows to open a color chooser dialog to change the color.

It is suitable widget for selecting a color in a preference dialog.

CSS nodes

colorbutton
╰── button.color
    ╰── [content]

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

The ColorButtonRef type acts as a lightweight Swift reference to an underlying GtkColorButton instance. It exposes methods that can operate on this data type through ColorButtonProtocol conformance. Use ColorButtonRef only as an unowned reference to an existing GtkColorButton instance.

A dialog for choosing a color.

GtkColorChooserDialog implements the [ifaceGtk.ColorChooser] interface and does not provide much API of its own.

To create a GtkColorChooserDialog, use [ctorGtk.ColorChooserDialog.new].

To change the initially selected color, use [methodGtk.ColorChooser.set_rgba]. To get the selected color use [methodGtk.ColorChooser.get_rgba].

The ColorChooserDialogRef type acts as a lightweight Swift reference to an underlying GtkColorChooserDialog instance. It exposes methods that can operate on this data type through ColorChooserDialogProtocol conformance. Use ColorChooserDialogRef only as an unowned reference to an existing GtkColorChooserDialog instance.

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 create a GtkColorChooserWidget, use [ctorGtk.ColorChooserWidget.new].

To change the initially selected color, use [methodGtk.ColorChooser.set_rgba]. To get the selected color use [methodGtk.ColorChooser.get_rgba].

The GtkColorChooserWidget is used in the [classGtk.ColorChooserDialog] to provide a dialog for selecting colors.

CSS names

GtkColorChooserWidget has a single CSS node with name colorchooser.

The ColorChooserWidgetRef type acts as a lightweight Swift reference to an underlying GtkColorChooserWidget instance. It exposes methods that can operate on this data type through ColorChooserWidgetProtocol conformance. Use ColorChooserWidgetRef only as an unowned reference to an existing GtkColorChooserWidget instance.

GtkColumnView presents a large dynamic list of items using multiple columns with headers.

GtkColumnView uses the factories of its columns to generate a cell widget for each column, for each visible item and displays them together as the row for this item.

The [propertyGtk.ColumnView:show-row-separators] and [propertyGtk.ColumnView:show-column-separators] properties offer a simple way to display separators between the rows or columns.

GtkColumnView allows the user to select items according to the selection characteristics of the model. For models that allow multiple selected items, it is possible to turn on rubberband selection, using [propertyGtk.ColumnView:enable-rubberband].

The column view supports sorting that can be customized by the user by clicking on column headers. To set this up, the GtkSorter returned by [methodGtk.ColumnView.get_sorter] must be attached to a sort model for the data that the view is showing, and the columns must have sorters attached to them by calling [methodGtk.ColumnViewColumn.set_sorter]. The initial sort order can be set with [methodGtk.ColumnView.sort_by_column].

The column view also supports interactive resizing and reordering of columns, via Drag-and-Drop of the column headers. This can be enabled or disabled with the [propertyGtk.ColumnView:reorderable] and [propertyGtk.ColumnViewColumn:resizable] properties.

To learn more about the list widget framework, see the overview.

CSS nodes

columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
├── header
│   ├── <column header>
┊   ┊
│   ╰── <column header>
│
├── listview
│
┊
╰── [rubberband]

GtkColumnView uses a single CSS node named columnview. It may carry the .column-separators style class, when [propertyGtk.ColumnView:show-column-separators] property is set. Header widgets appear below a node with name header. The rows are contained in a GtkListView widget, so there is a listview node with the same structure as for a standalone GtkListView widget. If [propertyGtk.ColumnView:show-row-separators] is set, it will be passed on to the list view, causing its CSS node to carry the .separators style class. For rubberband selection, a node with name rubberband is used.

The main columnview node may also carry style classes to select the style of list presentation: .rich-list, .navigation-sidebar or .data-table.

Accessibility

GtkColumnView uses the GTK_ACCESSIBLE_ROLE_TREE_GRID role, header title widgets are using the GTK_ACCESSIBLE_ROLE_COLUMN_HEADER role. The row widgets are using the GTK_ACCESSIBLE_ROLE_ROW role, and individual cells are using the GTK_ACCESSIBLE_ROLE_GRID_CELL role

The ColumnViewRef type acts as a lightweight Swift reference to an underlying GtkColumnView instance. It exposes methods that can operate on this data type through ColumnViewProtocol conformance. Use ColumnViewRef only as an unowned reference to an existing GtkColumnView instance.

GtkColumnViewColumn represents the columns being added to GtkColumnView.

The main ingredient for a GtkColumnViewColumn is the GtkListItemFactory that tells the columnview how to create cells for this column from items in the model.

Columns have a title, and can optionally have a header menu set with [methodGtk.ColumnViewColumn.set_header_menu].

A sorter can be associated with a column using [methodGtk.ColumnViewColumn.set_sorter], to let users influence sorting by clicking on the column header.

The ColumnViewColumnRef type acts as a lightweight Swift reference to an underlying GtkColumnViewColumn instance. It exposes methods that can operate on this data type through ColumnViewColumnProtocol conformance. Use ColumnViewColumnRef only as an unowned reference to an existing GtkColumnViewColumn instance.

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 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 [ifaceGtk.CellLayout] 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 [propertyGtk.ComboBox:has-entry] property allows the GtkComboBox to contain a [classGtk.Entry]. This entry can be accessed by calling [methodGtk.ComboBox.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, [classGtk.ComboBoxText] offers a simple alternative. Both GtkComboBox and GtkComboBoxText can contain an entry.

CSS nodes

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.

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.

Accessibility

GtkComboBox uses the GTK_ACCESSIBLE_ROLE_COMBO_BOX role.

The ComboBoxRef type acts as a lightweight Swift reference to an underlying GtkComboBox instance. It exposes methods that can operate on this data type through ComboBoxProtocol conformance. Use ComboBoxRef only as an unowned reference to an existing GtkComboBox instance.

A GtkComboBoxText is a simple variant of GtkComboBox for text-only use cases.

GtkComboBoxText hides the model-view complexity of GtkComboBox.

To create a GtkComboBoxText, use [ctorGtk.ComboBoxText.new] or [ctorGtk.ComboBoxText.new_with_entry].

You can add items to a GtkComboBoxText with [methodGtk.ComboBoxText.append_text], [methodGtk.ComboBoxText.insert_text] or [methodGtk.ComboBoxText.prepend_text] and remove options with [methodGtk.ComboBoxText.remove].

If the GtkComboBoxText contains an entry (via the [propertyGtk.ComboBox:has-entry] property), its contents can be retrieved using [methodGtk.ComboBoxText.get_active_text].

You should not call [methodGtk.ComboBox.set_model] or attempt to pack more cells into this combo box via its [ifaceGtk.CellLayout] 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

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 ComboBoxTextRef type acts as a lightweight Swift reference to an underlying GtkComboBoxText instance. It exposes methods that can operate on this data type through ComboBoxTextProtocol conformance. Use ComboBoxTextRef only as an unowned reference to an existing GtkComboBoxText instance.

A constant value in a GtkExpression.

The ConstantExpressionRef type acts as a lightweight Swift reference to an underlying GtkConstantExpression instance. It exposes methods that can operate on this data type through ConstantExpressionProtocol conformance. Use ConstantExpressionRef only as an unowned reference to an existing GtkConstantExpression instance.

GtkConstraint describes a constraint between attributes of two widgets, expressed as a linear equation.

The typical equation for a constraint is:

  target.target_attr = source.source_attr × multiplier + constant

Each GtkConstraint is part of a system that will be solved by a [classGtk.ConstraintLayout] in order to allocate and position each child widget or guide.

The source and target, as well as their attributes, of a GtkConstraint instance are immutable after creation.

The ConstraintRef type acts as a lightweight Swift reference to an underlying GtkConstraint instance. It exposes methods that can operate on this data type through ConstraintProtocol conformance. Use ConstraintRef only as an unowned reference to an existing GtkConstraint instance.

A GtkConstraintGuide is an invisible layout element in a GtkConstraintLayout.

The GtkConstraintLayout treats guides like widgets. They can be used as the source or target of a GtkConstraint.

Guides have a minimum, maximum and natural size. Depending on the constraints that are applied, they can act like a guideline that widgets can be aligned to, or like flexible space.

Unlike a GtkWidget, a GtkConstraintGuide will not be drawn.

The ConstraintGuideRef type acts as a lightweight Swift reference to an underlying GtkConstraintGuide instance. It exposes methods that can operate on this data type through ConstraintGuideProtocol conformance. Use ConstraintGuideRef only as an unowned reference to an existing GtkConstraintGuide instance.

A layout manager using constraints to describe relations between widgets.

GtkConstraintLayout is a layout manager that uses relations between widget attributes, expressed via [classGtk.Constraint] instances, to measure and allocate widgets.

How do constraints work

Constraints are objects defining the relationship between attributes of a widget; you can read the description of the [classGtk.Constraint] class to have a more in depth definition.

By taking multiple constraints and applying them to the children of a widget using GtkConstraintLayout, it’s possible to describe complex layout policies; each constraint applied to a child or to the parent widgets contributes to the full description of the layout, in terms of parameters for resolving the value of each attribute.

It is important to note that a layout is defined by the totality of constraints; removing a child, or a constraint, from an existing layout without changing the remaining constraints may result in an unstable or unsolvable layout.

Constraints have an implicit “reading order”; you should start describing each edge of each child, as well as their relationship with the parent container, from the top left (or top right, in RTL languages), horizontally first, and then vertically.

A constraint-based layout with too few constraints can become “unstable”, that is: have more than one solution. The behavior of an unstable layout is undefined.

A constraint-based layout with conflicting constraints may be unsolvable, and lead to an unstable layout. You can use the [propertyGtk.Constraint:strength] property of [classGtk.Constraint] to “nudge” the layout towards a solution.

GtkConstraintLayout as GtkBuildable

GtkConstraintLayout implements the [ifaceGtk.Buildable] interface and has a custom “constraints” element which allows describing constraints in a [classGtk.Builder] UI file.

An example of a UI definition fragment specifying a constraint:

  <object class="GtkConstraintLayout">
    <constraints>
      <constraint target="button" target-attribute="start"
                  relation="eq"
                  source="super" source-attribute="start"
                  constant="12"
                  strength="required" />
      <constraint target="button" target-attribute="width"
                  relation="ge"
                  constant="250"
                  strength="strong" />
    </constraints>
  </object>

The definition above will add two constraints to the GtkConstraintLayout:

• a required constraint between the leading edge of “button” and the leading edge of the widget using the constraint layout, plus 12 pixels
• a strong, constant constraint making the width of “button” greater than, or equal to 250 pixels

The “target” and “target-attribute” attributes are required.

The “source” and “source-attribute” attributes of the “constraint” element are optional; if they are not specified, the constraint is assumed to be a constant.

The “relation” attribute is optional; if not specified, the constraint is assumed to be an equality.

The “strength” attribute is optional; if not specified, the constraint is assumed to be required.

The “source” and “target” attributes can be set to “super” to indicate that the constraint target is the widget using the GtkConstraintLayout.

There can be “constant” and “multiplier” attributes.

Additionally, the “constraints” element can also contain a description of the GtkConstraintGuides used by the layout:

  <constraints>
    <guide min-width="100" max-width="500" name="hspace"/>
    <guide min-height="64" nat-height="128" name="vspace" strength="strong"/>
  </constraints>

The “guide” element has the following optional attributes:

• “min-width”, “nat-width”, and “max-width”, describe the minimum, natural, and maximum width of the guide, respectively
• “min-height”, “nat-height”, and “max-height”, describe the minimum, natural, and maximum height of the guide, respectively
• “strength” describes the strength of the constraint on the natural size of the guide; if not specified, the constraint is assumed to have a medium strength
• “name” describes a name for the guide, useful when debugging

Using the Visual Format Language

Complex constraints can be described using a compact syntax called VFL, or Visual Format Language.

The Visual Format Language describes all the constraints on a row or column, typically starting from the leading edge towards the trailing one. Each element of the layout is composed by “views”, which identify a [ifaceGtk.ConstraintTarget].

For instance:

  [button]-[textField]

Describes a constraint that binds the trailing edge of “button” to the leading edge of “textField”, leaving a default space between the two.

Using VFL is also possible to specify predicates that describe constraints on attributes like width and height:

  // Width must be greater than, or equal to 50
  [`button(>=50)`]

  // Width of button1 must be equal to width of button2
  [`button1(==button2)`]

The default orientation for a VFL description is horizontal, unless otherwise specified:

  // horizontal orientation, default attribute: width
  H:[`button(>=150)`]

  // vertical orientation, default attribute: height
  V:[`button1(==button2)`]

It’s also possible to specify multiple predicates, as well as their strength:

  // minimum width of button must be 150
  // natural width of button can be 250
  [`button(>=150@required, ==250@medium)`]

Finally, it’s also possible to use simple arithmetic operators:

  // width of button1 must be equal to width of button2
  // divided by 2 plus 12
  [`button1(button2 / 2 + 12)`]

The ConstraintLayoutRef type acts as a lightweight Swift reference to an underlying GtkConstraintLayout instance. It exposes methods that can operate on this data type through ConstraintLayoutProtocol conformance. Use ConstraintLayoutRef only as an unowned reference to an existing GtkConstraintLayout instance.

GtkLayoutChild subclass for children in a GtkConstraintLayout.

The ConstraintLayoutChildRef type acts as a lightweight Swift reference to an underlying GtkConstraintLayoutChild instance. It exposes methods that can operate on this data type through ConstraintLayoutChildProtocol conformance. Use ConstraintLayoutChildRef only as an unowned reference to an existing GtkConstraintLayoutChild instance.

GtkCssProvider is an object implementing the GtkStyleProvider interface for CSS.

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 [methodGtk.CssProvider.load_from_file] or [methodGtk.CssProvider.load_from_resource] and adding the provider with [methodGtk.StyleContext.add_provider] or [funcGtk.StyleContext.add_provider_for_display].

In addition, certain files will be read when GTK is initialized. First, the file $XDG_CONFIG_HOME/gtk-4.0/gtk.css is loaded if it exists. Then, GTK loads the first existing file among XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk-VARIANT.css, $HOME/.themes/THEME/gtk-VERSION/gtk-VARIANT.css, $XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk-VARIANT.css and DATADIR/share/themes/THEME/gtk-VERSION/gtk-VARIANT.css, where THEME is the name of the current theme (see the [propertyGtk.Settings:gtk-theme-name] setting), VARIANT is the variant to load (see the [propertyGtk.Settings:gtk-application-prefer-dark-theme] 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 4.0.

To track errors while loading CSS, connect to the [signalGtk.CssProvider::parsing-error] signal.

The CssProviderRef type acts as a lightweight Swift reference to an underlying GtkCssProvider instance. It exposes methods that can operate on this data type through CssProviderProtocol conformance. Use CssProviderRef only as an unowned reference to an existing GtkCssProvider instance.

GtkCustomFilter determines whether to include items with a callback.

The CustomFilterRef type acts as a lightweight Swift reference to an underlying GtkCustomFilter instance. It exposes methods that can operate on this data type through CustomFilterProtocol conformance. Use CustomFilterRef only as an unowned reference to an existing GtkCustomFilter instance.

GtkCustomLayout uses closures for size negotiation.

A GtkCustomLayoutuses closures matching to the old GtkWidget virtual functions for size negotiation, as a convenience API to ease the porting towards the corresponding `GtkLayoutManager virtual functions.

The CustomLayoutRef type acts as a lightweight Swift reference to an underlying GtkCustomLayout instance. It exposes methods that can operate on this data type through CustomLayoutProtocol conformance. Use CustomLayoutRef only as an unowned reference to an existing GtkCustomLayout instance.

GtkCustomSorter is a GtkSorter implementation that sorts via a callback function.

The CustomSorterRef type acts as a lightweight Swift reference to an underlying GtkCustomSorter instance. It exposes methods that can operate on this data type through CustomSorterProtocol conformance. Use CustomSorterRef only as an unowned reference to an existing GtkCustomSorter instance.

Dialogs are a convenient way to prompt the user for a small amount of input.

Typical uses are to display a message, ask a question, or anything else that does not require extensive effort on the user’s part.

The main area of a GtkDialog is called the “content area”, and is yours to populate with widgets such a GtkLabel or GtkEntry, to present your information, questions, or tasks to the user.

In addition, dialogs allow you to add “action widgets”. Most commonly, action widgets are buttons. Depending on the platform, action widgets may be presented in the header bar at the top of the window, or at the bottom of the window. To add action widgets, create your GtkDialog using [ctorGtk.Dialog.new_with_buttons], or use [methodGtk.Dialog.add_button], [methodGtk.Dialog.add_buttons], or [methodGtk.Dialog.add_action_widget].

GtkDialogs uses some heuristics to decide whether to add a close button to the window decorations. If any of the action buttons use the response ID GTK_RESPONSE_CLOSE or GTK_RESPONSE_CANCEL, the close button is omitted.

Clicking a button that was added as an action widget will emit the [signalGtk.Dialog::response] signal 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 [enumGtk.ResponseType] enumeration (these all have values less than zero). If a dialog receives a delete event, the [signalGtk.Dialog::response] signal will be emitted with the GTK_RESPONSE_DELETE_EVENT response ID.

Dialogs are created with a call to [ctorGtk.Dialog.new] or [ctorGtk.Dialog.new_with_buttons]. The latter is recommended; it allows you to set the dialog title, some convenient flags, and add buttons.

A “modal” dialog (that is, one which freezes the rest of the application from user input), can be created by calling [methodGtk.Window.set_modal] on the dialog. When using [ctorGtk.Dialog.new_with_buttons], you can also pass the GTK_DIALOG_MODAL flag to make a dialog modal.

For the simple dialog in the following example, a [classGtk.MessageDialog] would save 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:

// Function to open a dialog box with a message
void
quick_message (GtkWindow *parent, char *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_window_destroy),
                           dialog);

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

 gtk_box_append (GTK_BOX (content_area), label);
 gtk_widget_show (dialog);
}

GtkDialog as GtkBuildable

The GtkDialog implementation of the GtkBuildable interface exposes the content_area as an internal child with the name “content_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">
    </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>

Accessibility

GtkDialog uses the GTK_ACCESSIBLE_ROLE_DIALOG role.

The DialogRef type acts as a lightweight Swift reference to an underlying GtkDialog instance. It exposes methods that can operate on this data type through DialogProtocol conformance. Use DialogRef only as an unowned reference to an existing GtkDialog instance.

The CellAreaClassRef type acts as a lightweight Swift reference to an underlying GtkCellAreaClass instance. It exposes methods that can operate on this data type through CellAreaClassProtocol conformance. Use CellAreaClassRef only as an unowned reference to an existing GtkCellAreaClass instance.

The CellAreaContextClassRef type acts as a lightweight Swift reference to an underlying GtkCellAreaContextClass instance. It exposes methods that can operate on this data type through CellAreaContextClassProtocol conformance. Use CellAreaContextClassRef only as an unowned reference to an existing GtkCellAreaContextClass instance.

The CellEditableIfaceRef type acts as a lightweight Swift reference to an underlying GtkCellEditableIface instance. It exposes methods that can operate on this data type through CellEditableIfaceProtocol conformance. Use CellEditableIfaceRef only as an unowned reference to an existing GtkCellEditableIface instance.

The CellLayoutIfaceRef type acts as a lightweight Swift reference to an underlying GtkCellLayoutIface instance. It exposes methods that can operate on this data type through CellLayoutIfaceProtocol conformance. Use CellLayoutIfaceRef only as an unowned reference to an existing GtkCellLayoutIface instance.

The CellRendererClassRef type acts as a lightweight Swift reference to an underlying GtkCellRendererClass instance. It exposes methods that can operate on this data type through CellRendererClassProtocol conformance. Use CellRendererClassRef only as an unowned reference to an existing GtkCellRendererClass instance.

The CellRendererClassPrivateRef type acts as a lightweight Swift reference to an underlying GtkCellRendererClassPrivate instance. It exposes methods that can operate on this data type through CellRendererClassPrivateProtocol conformance. Use CellRendererClassPrivateRef only as an unowned reference to an existing GtkCellRendererClassPrivate instance.

The CellRendererTextClassRef type acts as a lightweight Swift reference to an underlying GtkCellRendererTextClass instance. It exposes methods that can operate on this data type through CellRendererTextClassProtocol conformance. Use CellRendererTextClassRef only as an unowned reference to an existing GtkCellRendererTextClass instance.

The CenterBoxClassRef type acts as a lightweight Swift reference to an underlying GtkCenterBoxClass instance. It exposes methods that can operate on this data type through CenterBoxClassProtocol conformance. Use CenterBoxClassRef only as an unowned reference to an existing GtkCenterBoxClass instance.

The CenterLayoutClassRef type acts as a lightweight Swift reference to an underlying GtkCenterLayoutClass instance. It exposes methods that can operate on this data type through CenterLayoutClassProtocol conformance. Use CenterLayoutClassRef only as an unowned reference to an existing GtkCenterLayoutClass instance.

The CheckButtonClassRef type acts as a lightweight Swift reference to an underlying GtkCheckButtonClass instance. It exposes methods that can operate on this data type through CheckButtonClassProtocol conformance. Use CheckButtonClassRef only as an unowned reference to an existing GtkCheckButtonClass instance.

The ColorChooserInterfaceRef type acts as a lightweight Swift reference to an underlying GtkColorChooserInterface instance. It exposes methods that can operate on this data type through ColorChooserInterfaceProtocol conformance. Use ColorChooserInterfaceRef only as an unowned reference to an existing GtkColorChooserInterface instance.

The ColumnViewClassRef type acts as a lightweight Swift reference to an underlying GtkColumnViewClass instance. It exposes methods that can operate on this data type through ColumnViewClassProtocol conformance. Use ColumnViewClassRef only as an unowned reference to an existing GtkColumnViewClass instance.

The ColumnViewColumnClassRef type acts as a lightweight Swift reference to an underlying GtkColumnViewColumnClass instance. It exposes methods that can operate on this data type through ColumnViewColumnClassProtocol conformance. Use ColumnViewColumnClassRef only as an unowned reference to an existing GtkColumnViewColumnClass instance.

The ComboBoxClassRef type acts as a lightweight Swift reference to an underlying GtkComboBoxClass instance. It exposes methods that can operate on this data type through ComboBoxClassProtocol conformance. Use ComboBoxClassRef only as an unowned reference to an existing GtkComboBoxClass instance.

The ConstraintClassRef type acts as a lightweight Swift reference to an underlying GtkConstraintClass instance. It exposes methods that can operate on this data type through ConstraintClassProtocol conformance. Use ConstraintClassRef only as an unowned reference to an existing GtkConstraintClass instance.

The ConstraintGuideClassRef type acts as a lightweight Swift reference to an underlying GtkConstraintGuideClass instance. It exposes methods that can operate on this data type through ConstraintGuideClassProtocol conformance. Use ConstraintGuideClassRef only as an unowned reference to an existing GtkConstraintGuideClass instance.

The ConstraintLayoutChildClassRef type acts as a lightweight Swift reference to an underlying GtkConstraintLayoutChildClass instance. It exposes methods that can operate on this data type through ConstraintLayoutChildClassProtocol conformance. Use ConstraintLayoutChildClassRef only as an unowned reference to an existing GtkConstraintLayoutChildClass instance.

The ConstraintLayoutClassRef type acts as a lightweight Swift reference to an underlying GtkConstraintLayoutClass instance. It exposes methods that can operate on this data type through ConstraintLayoutClassProtocol conformance. Use ConstraintLayoutClassRef only as an unowned reference to an existing GtkConstraintLayoutClass instance.

The ConstraintTargetInterfaceRef type acts as a lightweight Swift reference to an underlying GtkConstraintTargetInterface instance. It exposes methods that can operate on this data type through ConstraintTargetInterfaceProtocol conformance. Use ConstraintTargetInterfaceRef only as an unowned reference to an existing GtkConstraintTargetInterface instance.

Represents a location in a file or other source of data parsed by the CSS engine.

The bytes and line_bytes offsets are meant to be used to programmatically match data. The lines and line_chars offsets can be used for printing the location in a file.

Note that the lines parameter starts from 0 and is increased whenever a CSS line break is encountered. (CSS defines the C character sequences “\r\n”, “\r”, “\n” and “\f” as newlines.) If your document uses different rules for line breaking, you might want run into problems here.

The CssLocationRef type acts as a lightweight Swift reference to an underlying GtkCssLocation instance. It exposes methods that can operate on this data type through CssLocationProtocol conformance. Use CssLocationRef only as an unowned reference to an existing GtkCssLocation instance.

The CssProviderClassRef type acts as a lightweight Swift reference to an underlying GtkCssProviderClass instance. It exposes methods that can operate on this data type through CssProviderClassProtocol conformance. Use CssProviderClassRef only as an unowned reference to an existing GtkCssProviderClass instance.

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 CssSectionRef type acts as a lightweight Swift reference to an underlying GtkCssSection instance. It exposes methods that can operate on this data type through CssSectionProtocol conformance. Use CssSectionRef only as an unowned reference to an existing GtkCssSection instance.

The CssStyleChangeRef type acts as a lightweight Swift reference to an underlying GtkCssStyleChange instance. It exposes methods that can operate on this data type through CssStyleChangeProtocol conformance. Use CssStyleChangeRef only as an unowned reference to an existing GtkCssStyleChange instance.

The CustomFilterClassRef type acts as a lightweight Swift reference to an underlying GtkCustomFilterClass instance. It exposes methods that can operate on this data type through CustomFilterClassProtocol conformance. Use CustomFilterClassRef only as an unowned reference to an existing GtkCustomFilterClass instance.

The CustomLayoutClassRef type acts as a lightweight Swift reference to an underlying GtkCustomLayoutClass instance. It exposes methods that can operate on this data type through CustomLayoutClassProtocol conformance. Use CustomLayoutClassRef only as an unowned reference to an existing GtkCustomLayoutClass instance.

The CustomSorterClassRef type acts as a lightweight Swift reference to an underlying GtkCustomSorterClass instance. It exposes methods that can operate on this data type through CustomSorterClassProtocol conformance. Use CustomSorterClassRef only as an unowned reference to an existing GtkCustomSorterClass instance.

The DialogClassRef type acts as a lightweight Swift reference to an underlying GtkDialogClass instance. It exposes methods that can operate on this data type through DialogClassProtocol conformance. Use DialogClassRef only as an unowned reference to an existing GtkDialogClass instance.

An interface for packing cells

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 CellLayoutRef type acts as a lightweight Swift reference to an underlying GtkCellLayout instance. It exposes methods that can operate on this data type through CellLayoutProtocol conformance. Use CellLayoutRef only as an unowned reference to an existing GtkCellLayout instance.

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 [classGtk.ColorChooserWidget], [classGtk.ColorChooserDialog] and [classGtk.ColorButton].

The ColorChooserRef type acts as a lightweight Swift reference to an underlying GtkColorChooser instance. It exposes methods that can operate on this data type through ColorChooserProtocol conformance. Use ColorChooserRef only as an unowned reference to an existing GtkColorChooser instance.

The GtkConstraintTarget interface is implemented by objects that can be used as source or target in GtkConstraints.

Besides GtkWidget, it is also implemented by GtkConstraintGuide.

The ConstraintTargetRef type acts as a lightweight Swift reference to an underlying GtkConstraintTarget instance. It exposes methods that can operate on this data type through ConstraintTargetProtocol conformance. Use ConstraintTargetRef only as an unowned reference to an existing GtkConstraintTarget instance.

GtkEditable is an interface for text editing widgets.

Typical examples of editable widgets are [classGtk.Entry] and [classGtk.SpinButton]. 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 modify the behavior of a widget.

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

Forcing entry to uppercase.

`include` <ctype.h>

void
insert_text_handler (GtkEditable *editable,
                     const char  *text,
                     int          length,
                     int         *position,
                     gpointer     data)
{
  char *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);
}

Implementing GtkEditable

The most likely scenario for implementing GtkEditable on your own widget is that you will embed a GtkText inside a complex widget, and want to delegate the editable functionality to that text widget. GtkEditable provides some utility functions to make this easy.

In your class_init function, call [funcGtk.Editable.install_properties], passing the first available property ID:

static void
my_class_init (MyClass *class)
{
  ...
  g_object_class_install_properties (object_class, NUM_PROPERTIES, props);
  gtk_editable_install_properties (object_clas, NUM_PROPERTIES);
  ...
}

In your interface_init function for the GtkEditable interface, provide an implementation for the get_delegate vfunc that returns your text widget:

GtkEditable *
get_editable_delegate (GtkEditable *editable)
{
  return GTK_EDITABLE (MY_WIDGET (editable)->text_widget);
}

static void
my_editable_init (GtkEditableInterface *iface)
{
  iface->get_delegate = get_editable_delegate;
}

You don’t need to provide any other vfuncs. The default implementations work by forwarding to the delegate that the GtkEditableInterface.get_delegate() vfunc returns.

In your instance_init function, create your text widget, and then call [methodGtk.Editable.init_delegate]:

static void
my_widget_init (MyWidget *self)
{
  ...
  self->text_widget = gtk_text_new ();
  gtk_editable_init_delegate (GTK_EDITABLE (self));
  ...
}

In your dispose function, call [methodGtk.Editable.finish_delegate] before destroying your text widget:

static void
my_widget_dispose (GObject *object)
{
  ...
  gtk_editable_finish_delegate (GTK_EDITABLE (self));
  g_clear_pointer (&self->text_widget, gtk_widget_unparent);
  ...
}

Finally, use [funcGtk.Editable.delegate_set_property] in your set_property function (and similar for get_property), to set the editable properties:

  ...
  if (gtk_editable_delegate_set_property (object, prop_id, value, pspec))
    return;

  switch (prop_id)
  ...

It is important to note that if you create a GtkEditable that uses a delegate, the low level [signalGtk.Editable::insert-text] and [signalGtk.Editable::delete-text] signals will be propagated from the “wrapper” editable to the delegate, but they will not be propagated from the delegate to the “wrapper” editable, as they would cause an infinite recursion. If you wish to connect to the [signalGtk.Editable::insert-text] and [signalGtk.Editable::delete-text] signals, you will need to connect to them on the delegate obtained via [methodGtk.Editable.get_delegate].

The EditableRef type acts as a lightweight Swift reference to an underlying GtkEditable instance. It exposes methods that can operate on this data type through EditableProtocol conformance. Use EditableRef only as an unowned reference to an existing GtkEditable instance.

GtkDirectoryList is a list model that wraps g_file_enumerate_children_async().

It presents a GListModel and fills it asynchronously with the GFileInfos returned from that function.

Enumeration will start automatically when a the [propertyGtk.DirectoryList:file] property is set.

While the GtkDirectoryList is being filled, the [propertyGtk.DirectoryList:loading] property will be set to true. You can listen to that property if you want to show information like a GtkSpinner or a “Loading…” text.

If loading fails at any point, the [propertyGtk.DirectoryList:error] property will be set to give more indication about the failure.

The GFileInfos returned from a GtkDirectoryList have the “standardfile” attribute set to the GFile they refer to. This way you can get at the file that is referred to in the same way you would via g_file_enumerator_get_child(). This means you do not need access to the GtkDirectoryList, but can access the GFile directly from the GFileInfo when operating with a GtkListView or similar.

The DirectoryListRef type acts as a lightweight Swift reference to an underlying GtkDirectoryList instance. It exposes methods that can operate on this data type through DirectoryListProtocol conformance. Use DirectoryListRef only as an unowned reference to an existing GtkDirectoryList instance.

GtkDragIcon is a GtkRoot implementation for drag icons.

A drag icon moves with the pointer during a Drag-and-Drop operation and is destroyed when the drag ends.

To set up a drag icon and associate it with an ongoing drag operation, use [funcGtk.DragIcon.get_for_drag] to get the icon for a drag. You can then use it like any other widget and use [methodGtk.DragIcon.set_child] to set whatever widget should be used for the drag icon.

Keep in mind that drag icons do not allow user input.

The DragIconRef type acts as a lightweight Swift reference to an underlying GtkDragIcon instance. It exposes methods that can operate on this data type through DragIconProtocol conformance. Use DragIconRef only as an unowned reference to an existing GtkDragIcon instance.

GtkDragSource is an event controller to initiate Drag-And-Drop operations.

GtkDragSource can be set up with the necessary ingredients for a DND operation ahead of time. This includes the source for the data that is being transferred, in the form of a [classGdk.ContentProvider], the desired action, and the icon to use during the drag operation. After setting it up, the drag source must be added to a widget as an event controller, using [methodGtk.Widget.add_controller].

static void
my_widget_init (MyWidget *self)
{
  GtkDragSource *drag_source = gtk_drag_source_new ();

  g_signal_connect (drag_source, "prepare", G_CALLBACK (on_drag_prepare), self);
  g_signal_connect (drag_source, "drag-begin", G_CALLBACK (on_drag_begin), self);

  gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag_source));
}

Setting up the content provider and icon ahead of time only makes sense when the data does not change. More commonly, you will want to set them up just in time. To do so, GtkDragSource has [signalGtk.DragSource::prepare] and [signalGtk.DragSource::drag-begin] signals.

The prepare signal is emitted before a drag is started, and can be used to set the content provider and actions that the drag should be started with.

static GdkContentProvider *
on_drag_prepare (GtkDragSource *source,
                 double         x,
                 double         y,
                 MyWidget      *self)
{
  // This widget supports two types of content: GFile objects
  // and GdkPixbuf objects; GTK will handle the serialization
  // of these types automatically
  GFile *file = my_widget_get_file (self);
  GdkPixbuf *pixbuf = my_widget_get_pixbuf (self);

  return gdk_content_provider_new_union ((GdkContentProvider *[2]) {
      gdk_content_provider_new_typed (G_TYPE_FILE, file),
      gdk_content_provider_new_typed (GDK_TYPE_PIXBUF, pixbuf),
    }, 2);
}