Gtk

API reference for the Gtk namespace (version 4.0), generated from GObject-Introspection.

Classes

• ATContext — Communicates with platform-specific assistive technologies API. Each platform supported by GTK implements a GtkATContext subclass, and is…
• ATContextClass
• AboutDialog — Displays information about a program. The shown information includes the programs' logo, name, copyright, website and license. It is also…
• Accessible — An interface for describing UI elements for Assistive Technologies. Every accessible implementation has: - a “role”, represented by a value…
• AccessibleHyperlink — Represents a link (i.e. a uri). A widget that contains one or more links should implement the AccessibleHypertext interface and return…
• AccessibleHyperlinkClass
• AccessibleHypertext — An interface for accessible objects containing links. The GtkAccessibleHypertext interfaces is meant to be implemented by accessible…
• AccessibleHypertextInterface — The interface vtable for accessible objects containing links.
• AccessibleInterface — The common interface for accessible objects.
• AccessibleList — Wraps a list of references to Accessible objects.
• AccessibleRange — An interface for accessible objects containing a numeric value. GtkAccessibleRange describes ranged controls for Assistive Technologies.…
• AccessibleRangeInterface
• AccessibleText — An interface for accessible objects containing formatted text. The GtkAccessibleText interfaces is meant to be implemented by accessible…
• AccessibleTextInterface — The interface vtable for accessible objects containing text.
• AccessibleTextRange — A range inside the text of an accessible object.
• ActionBar — Presents contextual actions. <picture> <source srcset="action-bar-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• Actionable — Provides a way to associate widgets with actions. It primarily consists of two properties: Actionable.action-name and…
• ActionableInterface — The interface vtable for GtkActionable.
• ActivateAction — Activates a widget. Widgets are activated by calling Widget.activate.
• ActivateActionClass
• Adjustment — A model for a numeric value. The GtkAdjustment has an associated lower and upper bound. It also contains step and page increments, and a…
• AdjustmentClass
• AlertDialog — Collects the arguments that are needed to present a message to the user. The message is shown with the AlertDialog.choose function. If you…
• AlertDialogClass
• AlternativeTrigger — Combines two shortcut triggers. The GtkAlternativeTrigger triggers when either of the two trigger. This can be cascaded to combine more…
• AlternativeTriggerClass
• AnyFilter — Matches an item when at least one of its filters matches. To add filters to a GtkAnyFilter, use MultiFilter.append.
• AnyFilterClass
• AppChooser — GtkAppChooser is an interface for widgets which allow the user to choose an application. The main objects that implement this interface…
• AppChooserButton — The GtkAppChooserButton lets the user select an application. <picture> <source srcset="appchooserbutton-dark.png"…
• AppChooserDialog — GtkAppChooserDialog shows a GtkAppChooserWidget inside a GtkDialog. <picture> <source srcset="appchooserdialog-dark.png"…
• AppChooserWidget — GtkAppChooserWidget is a widget for selecting applications. It is the main building block for AppChooserDialog. Most applications only…
• Application — A high-level API for writing applications. GtkApplication supports many aspects of writing a GTK application in a convenient fashion,…
• ApplicationClass
• ApplicationWindow — A GtkWindow subclass that integrates with GtkApplication. Notably, GtkApplicationWindow can handle an application menubar. This class…
• ApplicationWindowClass
• AspectFrame — 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…
• Assistant — GtkAssistant is used to represent a complex as a series of steps. <picture> <source srcset="assistant-dark.png"…
• AssistantPage — GtkAssistantPage is an auxiliary object used by GtkAssistant.
• BinLayout — A layout manager for widgets with a single child. GtkBinLayout will stack each child of a widget on top of each other, using the…
• BinLayoutClass
• Bitset — A set of unsigned integers. Another name for this data structure is “bitmap”. The current implementation is based on roaring bitmaps. A…
• BitsetIter — Iterates over the elements of a Bitset. GtkBitSetIter is an opaque, stack-allocated struct. Before aGtkBitsetIter` can be used, it needs…
• BookmarkList — A list model that wraps GBookmarkFile. It presents a GListModel and fills it asynchronously with the GFileInfos returned from that…
• BookmarkListClass
• BoolFilter — Evaluates a boolean expression to determine whether to include items.
• BoolFilterClass
• Border — Specifies a border around a rectangular area. Each side can have a different width.
• Box — Arranges child widgets into a single row or column. <picture> <source srcset="box-dark.png" media="(prefers-color-scheme: dark)">…
• BoxClass
• BoxLayout — Arranges children in a single row or column. Whether it is a row or column depends on the value of its Orientable.orientation property.…
• BoxLayoutClass
• Buildable — Allows objects to extend and customize deserialization from ui files. The GtkBuildable interface includes methods for setting names and…
• BuildableIface — Contains methods to let GtkBuilder construct an object from a GtkBuilder UI definition.
• BuildableParseContext — Provides context for parsing GtkBuilder UI files. GtkBuildableParseContext is an opaque struct.
• BuildableParser — A sub-parser for GtkBuildable implementations.
• Builder — Reads XML descriptions of a user interface and instantiates the described objects. To create a GtkBuilder from a user interface…
• BuilderCScope — A GtkBuilderScope implementation for the C language. GtkBuilderCScope instances use symbols explicitly added to builder with prior…
• BuilderCScopeClass
• BuilderClass
• BuilderListItemFactory — Creates widgets by instantiating GtkBuilder UI templates. The templates must extend the class that the parent widget expects. For…
• BuilderListItemFactoryClass
• BuilderScope — Provides language binding support to GtkBuilder. The goal of GtkBuilderScope is to look up programming-language-specific values for…
• BuilderScopeInterface — The virtual function table to implement for GtkBuilderScope implementations. Default implementations for each function do exist, but they…
• Button — Calls a callback function when the button is clicked. <picture> <source srcset="button-dark.png" media="(prefers-color-scheme:…
• ButtonClass
• ButtonPrivate
• CClosureExpression — A variant of GtkClosureExpression using a C closure.
• Calendar — Displays a Gregorian calendar, one month at a time. <picture> <source srcset="calendar-dark.png" media="(prefers-color-scheme:…
• CallbackAction — Invokes a callback.
• CallbackActionClass
• CellArea — An abstract class for laying out GtkCellRenderers The GtkCellArea is an abstract class for CellLayout widgets (also referred to as…
• CellAreaBox — A cell area that renders GtkCellRenderers into a row or a column The GtkCellAreaBox renders cell renderers into a row or a column…
• CellAreaClass
• CellAreaContext — Stores geometrical information for a series of rows in a GtkCellArea The GtkCellAreaContext object is created by a given GtkCellArea…
• CellAreaContextClass
• CellAreaContextPrivate
• CellEditable — Interface for widgets that can be used for editing cells The GtkCellEditable interface must be implemented for widgets to be usable to…
• CellEditableIface
• CellLayout — An interface for packing cells GtkCellLayout is an interface to be implemented by all objects which want to provide a GtkTreeViewColumn…
• CellLayoutIface
• CellRenderer — 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.…
• CellRendererAccel — Renders a keyboard accelerator in a cell GtkCellRendererAccel displays a keyboard accelerator (i.e. a key combination like `Control +…
• CellRendererClass
• CellRendererClassPrivate
• CellRendererCombo — Renders a combobox in a cell GtkCellRendererCombo renders text in a cell like GtkCellRendererText from which it is derived. But while…
• CellRendererPixbuf — 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…
• CellRendererPrivate
• CellRendererProgress — Renders numbers as progress bars GtkCellRendererProgress renders a numeric value as a progress par in a cell. Additionally, it can…
• CellRendererSpin — Renders a spin button in a cell GtkCellRendererSpin renders text in a cell like GtkCellRendererText from which it is derived. But while…
• CellRendererSpinner — Renders a spinning animation in a cell GtkCellRendererSpinner renders a spinning animation in a cell, very similar to GtkSpinner. It…
• CellRendererText — Renders text in a cell A GtkCellRendererText renders a given text in its cell, using the font, color and style information provided by…
• CellRendererTextClass
• CellRendererToggle — Renders a toggle button in a cell GtkCellRendererToggle renders a toggle button in a cell. The button is drawn as a radio or a…
• CellView — A widget displaying a single row of a GtkTreeModel A GtkCellView displays a single row of a GtkTreeModel using a GtkCellArea and…
• CenterBox — Arranges three children in a row, keeping the middle child centered as well as possible. <picture> <source…
• CenterBoxClass
• CenterLayout — 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…
• CenterLayoutClass
• CheckButton — Places a label next to an indicator. <picture> <source srcset="check-button-dark.png" media="(prefers-color-scheme: dark)"> <img…
• CheckButtonClass
• ClosureExpression — An expression using a custom GClosure to compute the value from its parameters.
• ColorButton — The GtkColorButton allows to open a color chooser dialog to change the color. <picture> <source srcset="color-button-dark.png"…
• ColorChooser — GtkColorChooser is an interface that is implemented by widgets for choosing colors. Depending on the situation, colors may be allowed to…
• ColorChooserDialog — A dialog for choosing a color. <picture> <source srcset="colorchooser-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• ColorChooserInterface
• ColorChooserWidget — The GtkColorChooserWidget widget lets the user select a color. By default, the chooser presents a predefined palette of colors, plus a…
• ColorDialog — Asynchronous API to present a color chooser dialog. GtkColorDialog collects the arguments that are needed to present the dialog to the…
• ColorDialogButton — Opens a color chooser dialog to select a color. <picture> <source srcset="color-button-dark.png" media="(prefers-color-scheme:…
• ColorDialogButtonClass
• ColorDialogClass
• ColumnView — Presents a large dynamic list of items using multiple columns with headers. GtkColumnView uses the factories of its columns to generate a…
• ColumnViewCell — Represents items in a cell in ColumnView. The GtkColumnViewCells are managed by the ColumnView widget (with its factory) and cannot be…
• ColumnViewCellClass
• ColumnViewClass
• ColumnViewColumn — Represents the columns in a GtkColumnView. The main ingredient for a GtkColumnViewColumn is the GtkListItemFactory that tells the…
• ColumnViewColumnClass
• ColumnViewRow — Configures how rows are displayed in a ColumnView. It is not used to set the widgets displayed in the individual cells. For that see…
• ColumnViewRowClass
• ColumnViewSorter — Sorts ColumnView columns. The sorter returned by ColumnView.get_sorter is a GtkColumnViewSorter. In column views, sorting can be…
• ColumnViewSorterClass
• ComboBox — A GtkComboBox is a widget that allows the user to choose from a list of valid choices. <picture> <source…
• ComboBoxClass
• ComboBoxText — A GtkComboBoxText is a simple variant of GtkComboBox for text-only use cases. <picture> <source srcset="combo-box-text-dark.png"…
• ConstantExpression — A constant value in a GtkExpression.
• Constraint — Describes a constraint between attributes of two widgets, expressed as a linear equation. The typical equation for a constraint is: ```…
• ConstraintClass
• ConstraintGuide — An invisible layout element in a GtkConstraintLayout. The GtkConstraintLayout treats guides like widgets. They can be used as the…
• ConstraintGuideClass
• ConstraintLayout — Uses constraints to describe relations between widgets. GtkConstraintLayout is a layout manager that uses relations between widget…
• ConstraintLayoutChild — GtkLayoutChild subclass for children in a GtkConstraintLayout.
• ConstraintLayoutChildClass
• ConstraintLayoutClass
• ConstraintTarget — Makes it possible to use an object as source or target in a Constraint. Besides GtkWidget, it is also implemented by GtkConstraintGuide.
• ConstraintTargetInterface
• CssLocation — Points at a location inside a CSS stream.
• CssProvider — A style provider for CSS. It is able to parse CSS-like input in order to style widgets. An application can make GTK parse a specific CSS…
• CssProviderClass
• CssProviderPrivate
• CssSection — Defines a part of a CSS document. Because sections are nested into one another, you can use CssSection.get_parent to get the containing…
• CssStyleChange — A CSS style change.
• CustomFilter — Determines whether to include items with a callback.
• CustomFilterClass
• CustomLayout — Uses closures for size negotiation. A GtkCustomLayout uses closures matching to the old GtkWidget virtual functions for size…
• CustomLayoutClass
• CustomSorter — Sorts items via a callback function.
• CustomSorterClass
• Dialog — Dialogs are a convenient way to prompt the user for a small amount of input. <picture> <source srcset="dialog-dark.png"…
• DialogClass
• DirectoryList — A list model that wraps Gio.File.enumerate_children_async. It presents a GListModel and fills it asynchronously with the GFileInfos…
• DirectoryListClass
• DragIcon — A GtkRoot implementation for drag icons. A drag icon moves with the pointer during a Drag-and-Drop operation and is destroyed when the…
• DragIconClass
• DragSource — An event controller to initiate Drag-And-Drop operations. GtkDragSource can be set up with the necessary ingredients for a DND operation…
• DragSourceClass
• DrawingArea — Allows drawing with cairo. <picture> <source srcset="drawingarea-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• DrawingAreaClass
• DropControllerMotion — An event controller tracking the pointer during Drag-and-Drop operations. It is modeled after EventControllerMotion so if you have used…
• DropControllerMotionClass
• DropDown — Allows the user to choose an item from a list of options. <picture> <source srcset="drop-down-dark.png" media="(prefers-color-scheme:…
• DropDownClass
• DropTarget — An event controller to receive Drag-and-Drop operations. The most basic way to use a GtkDropTarget to receive drops on a widget is to…
• DropTargetAsync — An event controller to receive Drag-and-Drop operations, asynchronously. It is the more complete but also more complex method of handling…
• DropTargetAsyncClass
• DropTargetClass
• Editable — Interface for single-line text editing widgets. Typical examples of editable widgets are Entry and SpinButton. It contains functions for…
• EditableInterface
• EditableLabel — Allows users to edit the displayed text by switching to an “edit mode”. <picture> <source srcset="editable-label-dark.png"…
• EditableLabelClass
• EmojiChooser — Used by text widgets to let users insert Emoji characters. <picture> <source srcset="emojichooser-dark.png"…
• EmojiChooserClass
• Entry — A single-line text entry widget. <picture> <source srcset="entry-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• EntryBuffer — Holds the text that is displayed in a single-line text entry widget. A single GtkEntryBuffer object can be shared by multiple widgets…
• EntryBufferClass
• EntryClass — Class structure for GtkEntry. All virtual functions have a default implementation. Derived classes may set the virtual function pointers…
• EntryCompletion — GtkEntryCompletion is an auxiliary object to provide completion functionality for GtkEntry. It implements the CellLayout interface, to…
• EventController — The base class for event controllers. These are ancillary objects associated to widgets, which react to GdkEvents, and possibly trigger…
• EventControllerClass
• EventControllerFocus — Tracks keyboard focus. The event controller offers EventControllerFocus.enter and EventControllerFocus.leave signals, as well as…
• EventControllerFocusClass
• EventControllerKey — Provides access to key events.
• EventControllerKeyClass
• EventControllerLegacy — Provides raw access to the event stream. It should only be used as a last resort if none of the other event controllers or gestures do the…
• EventControllerLegacyClass
• EventControllerMotion — Tracks the pointer position. The event controller offers EventControllerMotion.enter and EventControllerMotion.leave signals, as well as…
• EventControllerMotionClass
• EventControllerScroll — Handles scroll events. It is capable of handling both discrete and continuous scroll events from mice or touchpads, abstracting them both…
• EventControllerScrollClass
• EveryFilter — Matches an item when each of its filters matches. To add filters to a GtkEveryFilter, use MultiFilter.append.
• EveryFilterClass
• Expander — Allows the user to reveal or conceal a child widget. <picture> <source srcset="expander-dark.png" media="(prefers-color-scheme:…
• Expression — Provides a way to describe references to values. An important aspect of expressions is that the value can be obtained from a source that is…
• ExpressionWatch — An opaque structure representing a watched GtkExpression. The contents of GtkExpressionWatch should only be accessed through the…
• FileChooser — GtkFileChooser is an interface that can be implemented by file selection widgets. In GTK, the main objects that implement this interface…
• FileChooserDialog — GtkFileChooserDialog is a dialog suitable for use with “File Open” or “File Save” commands. An example GtkFileChooserDialog This widget…
• FileChooserNative — GtkFileChooserNative is an abstraction of a dialog suitable for use with “File Open” or “File Save as” commands. By default, this just…
• FileChooserNativeClass
• FileChooserWidget — GtkFileChooserWidget is a widget for choosing files. It exposes the FileChooser interface, and you should use the methods of this…
• FileDialog — Asynchronous API to present a file chooser dialog. GtkFileDialog collects the arguments that are needed to present the dialog to the…
• FileDialogClass
• FileFilter — Filters files by name or mime type. GtkFileFilter can be used to restrict the files being shown in a file chooser. Files can be filtered…
• FileLauncher — Asynchronous API to open a file with an application. GtkFileLauncher collects the arguments that are needed to open the file. Depending…
• FileLauncherClass
• Filter — Describes the filtering to be performed by a FilterListModel. The model will use the filter to determine if it should include items or not…
• FilterClass
• FilterListModel — A list model that filters the elements of another model. It hides some elements from the underlying model according to criteria given by a…
• FilterListModelClass
• Fixed — Places its child widgets at fixed positions and with fixed sizes. GtkFixed performs no automatic layout management. For most…
• FixedClass
• FixedLayout — Places child widgets at fixed positions. Most applications should never use this layout manager; fixed positioning and sizing requires…
• FixedLayoutChild — GtkLayoutChild subclass for children in a GtkFixedLayout.
• FixedLayoutChildClass
• FixedLayoutClass
• FlattenListModel — A list model that concatenates other list models. GtkFlattenListModel takes a list model containing list models, and flattens it into a…
• FlattenListModelClass
• FlowBox — Puts child widgets in a reflowing grid. <picture> <source srcset="flow-box-dark.png" media="(prefers-color-scheme: dark)"> <img…
• FlowBoxChild — The kind of widget that can be added to a GtkFlowBox. FlowBox will automatically wrap its children in a GtkFlowBoxChild when necessary.
• FlowBoxChildClass
• FontButton — The GtkFontButton allows to open a font chooser dialog to change the font. <picture> <source srcset="font-button-dark.png"…
• FontChooser — GtkFontChooser is an interface that can be implemented by widgets for choosing fonts. In GTK, the main objects that implement this…
• FontChooserDialog — The GtkFontChooserDialog widget is a dialog for selecting a font. <picture> <source srcset="fontchooser-dark.png"…
• FontChooserIface
• FontChooserWidget — The GtkFontChooserWidget widget lets the user select a font. It is used in the GtkFontChooserDialog widget to provide a dialog for…
• FontDialog — Asynchronous API to present a font chooser dialog. GtkFontDialog collects the arguments that are needed to present the dialog to the…
• FontDialogButton — Opens a font chooser dialog to select a font. <picture> <source srcset="font-button-dark.png" media="(prefers-color-scheme: dark)">…
• FontDialogButtonClass
• FontDialogClass
• Frame — Surrounds its child with a decorative frame and an optional label. <picture> <source srcset="frame-dark.png"…
• FrameClass
• GLArea — Allows drawing with OpenGL. <picture> <source srcset="glarea-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An example…
• GLAreaClass — The GtkGLAreaClass structure contains only private data.
• Gesture — The base class for gesture recognition. Although GtkGesture is quite generalized to serve as a base for multi-touch gestures, it is…
• GestureClass
• GestureClick — Recognizes click gestures. It is able to recognize multiple clicks on a nearby zone, which can be listened for through the…
• GestureClickClass
• GestureDrag — Recognizes drag gestures. The drag operation itself can be tracked throughout the GestureDrag.drag-begin, GestureDrag.drag-update and…
• GestureDragClass
• GestureLongPress — Recognizes long press gestures. This gesture is also known as “Press and Hold”. When the timeout is exceeded, the gesture is triggering the…
• GestureLongPressClass
• GesturePan — Recognizes pan gestures. These are drags that are locked to happen along one axis. The axis that a GtkGesturePan handles is defined at…
• GesturePanClass
• GestureRotate — Recognizes 2-finger rotation gestures. Whenever the angle between both handled sequences changes, the GestureRotate.angle-changed signal is…
• GestureRotateClass
• GestureSingle — A GtkGesture subclass optimized for singe-touch and mouse gestures. Under interaction, these gestures stick to the first interacting…
• GestureSingleClass
• GestureStylus — Recognizes tablet stylus input. The provided signals just relay the basic information of the stylus events.
• GestureStylusClass
• GestureSwipe — Recognizes swipe gestures. After a press/move/.../move/release sequence happens, the GestureSwipe.swipe signal will be emitted, providing…
• GestureSwipeClass
• GestureZoom — Recognizes 2-finger pinch/zoom gestures. Whenever the distance between both tracked sequences changes, the GestureZoom.scale-changed signal…
• GestureZoomClass
• GraphicsOffload — Bypasses gsk rendering by passing the content of its child directly to the compositor. Graphics offload is an optimization to reduce…
• GraphicsOffloadClass
• Grid — Arranges its child widgets in rows and columns. <picture> <source srcset="grid-dark.png" media="(prefers-color-scheme: dark)">…
• GridClass
• GridLayout — Arranges child widgets in rows and columns. Children have an "attach point" defined by the horizontal and vertical index of the cell they…
• GridLayoutChild — GtkLayoutChild subclass for children in a GtkGridLayout.
• GridLayoutChildClass
• GridLayoutClass
• GridView — Presents a large dynamic grid of items. GtkGridView uses its factory to generate one child widget for each visible item and shows them in…
• GridViewClass
• HeaderBar — Creates a custom titlebar for a window. <picture> <source srcset="headerbar-dark.png" media="(prefers-color-scheme: dark)"> <img…
• IMContext — The interface for GTK input methods. GtkIMContext is used by GTK text input widgets like GtkText to map from key events to Unicode…
• IMContextClass
• IMContextSimple — Supports compose sequences, dead keys and numeric Unicode input. #### Compose sequences GtkIMContextSimple reads compose sequences from…
• IMContextSimpleClass
• IMContextSimplePrivate
• IMMulticontext — Supports switching between multiple input methods. Text widgets such as GtkText or GtkTextView use a GtkIMMultiContext to implement…
• IMMulticontextClass
• IMMulticontextPrivate
• IconPaintable — Contains information found when looking up an icon in GtkIconTheme or loading it from a file. GtkIconPaintable implements…
• IconPaintableClass
• IconTheme — Loads themed icons. The main reason for using a name rather than simply providing a filename is to allow different icons to be used…
• IconView — GtkIconView is a widget which displays data in a grid of icons. <picture> <source srcset="icon-view-dark.png"…
• Image — Displays an image. <picture> <source srcset="image-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An example GtkImage"…
• InfoBar — GtkInfoBar can be used to show messages to the user without a dialog. <picture> <source srcset="info-bar-dark.png"…
• Inscription — Shows text in a predefined area. You likely want to use GtkLabel instead as this widget is intended only for a small subset of use cases.…
• InscriptionClass
• KeyvalTrigger — Triggers when a specific keyval and modifiers are pressed.
• KeyvalTriggerClass
• Label — Displays a small amount of text. Most labels are used to label another widget (such as an Entry). <picture> <source…
• LayoutChild — The base class for objects that are meant to hold layout properties. If a GtkLayoutManager has per-child properties, like their packing…
• LayoutChildClass
• LayoutManager — Handles the preferred size and allocation for children of a widget. You typically subclass GtkLayoutManager if you want to implement a…
• LayoutManagerClass — The GtkLayoutManagerClass structure contains only private data, and should only be accessed through the provided API, or when subclassing…
• LevelBar — Shows a level indicator. Typical use cases are displaying the strength of a password, or showing the charge level of a battery.…
• LinkButton — A button with a hyperlink. <picture> <source srcset="link-button-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• ListBase — The abstract base class for GTK's list widgets. ### Shortcuts and Gestures GtkListBase supports the following keyboard shortcuts: -…
• ListBaseClass
• ListBox — Shows a vertical list. <picture> <source srcset="list-box-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An example…
• ListBoxRow — The kind of widget that can be added to a GtkListBox. ListBox will automatically wrap its children in a GtkListboxRow when necessary.
• ListBoxRowClass
• ListHeader — Used by list widgets to represent the headers they display. GtkListHeader objects are managed just like ListItem objects via their…
• ListHeaderClass
• ListItem — Used by list widgets to represent items in a Gio.ListModel. GtkListItem objects are managed by the list widget (with its factory) and…
• ListItemClass
• ListItemFactory — Creates widgets for the items taken from a GListModel. This is one of the core concepts of handling list widgets such as ListView or…
• ListItemFactoryClass
• ListStore — A list-like data structure that can be used with the TreeView. The GtkListStore object is a list model for use with a GtkTreeView…
• ListStoreClass
• ListStorePrivate
• ListView — Presents a large dynamic list of items. GtkListView uses its factory to generate one row widget for each visible item and shows them in a…
• ListViewClass
• LockButton — GtkLockButton is a widget to obtain and revoke authorizations needed to operate the controls. <picture> <source…
• MapListModel — A list model that maps the items in another model to different items. GtkMapListModel uses a MapListModelMapFunc. Example: Create a list…
• MapListModelClass
• MediaControls — Shows controls for video playback. <picture> <source srcset="media-controls-dark.png" media="(prefers-color-scheme: dark)"> <img…
• MediaControlsClass
• MediaFile — Implements the GtkMediaStream interface for files. This provides a simple way to play back video files with GTK. GTK provides a GIO…
• MediaFileClass
• MediaStream — The integration point for media playback inside GTK. GTK provides an implementation of the GtkMediaStream interface that is called…
• MediaStreamClass
• MenuButton — Displays a popup when clicked. <picture> <source srcset="menu-button-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• MessageDialog — GtkMessageDialog presents a dialog with some message text. <picture> <source srcset="messagedialog-dark.png"…
• MessageDialogClass
• MnemonicAction — Activates a widget with a mnemonic. This means that Widget.mnemonic_activate is called.
• MnemonicActionClass
• MnemonicTrigger — Triggers when a specific mnemonic is pressed. Mnemonics require a mnemonic modifier (typically <kbd>Alt</kbd>) to be pressed…
• MnemonicTriggerClass
• MountOperation — Asks the user for passwords and other information required to mount a volume. GtkMountOperation is needed when mounting volumes: It is an…
• MountOperationClass
• MountOperationPrivate
• MultiFilter — Base class for filters that combine multiple filters.
• MultiFilterClass
• MultiSelection — A selection model that allows selecting multiple elements.
• MultiSelectionClass
• MultiSorter — Combines multiple sorters by trying them in turn. If the first sorter compares two items as equal, the second is tried next, and so on.
• MultiSorterClass
• NamedAction — Activates a named action. See WidgetClass.install_action and Widget.insert_action_group for ways to associate named actions with widgets.
• NamedActionClass
• Native — An interface for widgets that have their own Gdk.Surface. The obvious example of a GtkNative is GtkWindow. Every widget that is not…
• NativeDialog — Base class for platform dialogs that don't use GtkDialog. Native dialogs are used in order to integrate better with a platform, by…
• NativeDialogClass — Class structure for GtkNativeDialog.
• NativeInterface
• NeverTrigger — A GtkShortcutTrigger that never triggers.
• NeverTriggerClass
• NoSelection — A selection model that does not allow selecting anything. This model is meant to be used as a simple wrapper around a GListModel when a…
• NoSelectionClass
• Notebook — Switches between children using tabs. <picture> <source srcset="notebook-dark.png" media="(prefers-color-scheme: dark)"> <img…
• NotebookPage — An auxiliary object used by GtkNotebook.
• NothingAction — Does nothing.
• NothingActionClass
• NumericSorter — Sorts items numerically. To obtain the numbers to compare, this sorter evaluates a Expression.
• NumericSorterClass
• ObjectExpression — A GObject value in a GtkExpression.
• Orientable — An interface for widgets that can be oriented horizontally or vertically. GtkOrientable is more flexible in that it allows the…
• OrientableIface
• Overlay — Places “overlay” widgets on top of a single main child. <picture> <source srcset="overlay-dark.png" media="(prefers-color-scheme:…
• OverlayLayout — The layout manager used by Overlay. It places widgets as overlays on top of the main child. This is not a reusable layout manager, since it…
• OverlayLayoutChild — GtkLayoutChild subclass for children in a GtkOverlayLayout.
• OverlayLayoutChildClass
• OverlayLayoutClass
• PadActionEntry — Struct defining a pad action entry.
• PadController — Handles input from the pads found in drawing tablets. Pads are the collection of buttons and tactile sensors often found around the…
• PadControllerClass
• PageRange — A range of pages to print. See also PrintSettings.set_page_ranges.
• PageSetup — Stores page size, orientation and margins for printing. The idea is that you can get one of these from the page setup dialog and then pass…
• PageSetupUnixDialog — Presents a page setup dialog for platforms which don’t provide a native page setup dialog, like Unix. <picture> <source…
• Paned — Arranges its children in two panes, horizontally or vertically. <picture> <source srcset="panes-dark.png"…
• PaperSize — GtkPaperSize handles paper sizes. It uses the standard called PWG 5101.1-2002 PWG: Standard for Media Standardized Names to name the…
• ParamSpecExpression — A GParamSpec for properties holding a GtkExpression.
• PasswordEntry — A single-line text entry widget for entering passwords and other secrets. <picture> <source srcset="password-entry-dark.png"…
• PasswordEntryBuffer — A GtkEntryBuffer that locks the underlying memory to prevent it from being swapped to disk. GtkPasswordEntry uses a…
• PasswordEntryBufferClass
• PasswordEntryClass
• Picture — Displays a GdkPaintable. <picture> <source srcset="picture-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An example…
• PictureClass
• Popover — Presents a bubble-like popup. <picture> <source srcset="popover-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• PopoverBin — A single child container with a popover. You should use GtkPopoverBin whenever you need to present a Popover to the user. #### Actions…
• PopoverBinClass
• PopoverClass
• PopoverMenu — A subclass of GtkPopover that implements menu behavior. <picture> <source srcset="menu-dark.png" media="(prefers-color-scheme:…
• PopoverMenuBar — Presents a horizontal bar of items that pop up menus when clicked. <picture> <source srcset="menubar-dark.png"…
• PrintBackend — A print backend.
• PrintContext — Encapsulates context information that is required when drawing pages for printing. This includes the cairo context and important parameters…
• PrintDialog — Asynchronous API to present a print dialog to the user. GtkPrintDialog collects the arguments that are needed to present the dialog, such…
• PrintDialogClass
• PrintJob — Represents a job that is sent to a printer. You only need to deal directly with print jobs if you use the non-portable PrintUnixDialog API.…
• PrintOperation — High-level, portable printing API. It looks a bit different than other GTK dialogs such as the GtkFileChooser, since some platforms don’t…
• PrintOperationClass
• PrintOperationPreview — The interface that is used to implement print preview. A GtkPrintOperationPreview object is passed to the PrintOperation.preview signal…
• PrintOperationPreviewIface
• PrintOperationPrivate
• PrintSettings — Collects the settings of a print dialog in a system-independent way. The main use for this object is that once you’ve printed you can get a…
• PrintSetup — An auxiliary object for printing that allows decoupling the setup from the printing. A print setup is obtained by calling…
• PrintUnixDialog — A print dialog for platforms which don’t provide a native print dialog, like Unix. <picture> <source srcset="printdialog-dark.png"…
• Printer — Represents a printer. You only need to deal directly with printers if you use the non-portable PrintUnixDialog API. A GtkPrinter allows…
• ProgressBar — Displays the progress of a long-running operation. GtkProgressBar provides a visual clue that processing is underway. It can be used in…
• PropertyExpression — A GObject property value in a GtkExpression.
• Range — Base class for widgets which visualize an adjustment. Widgets that are derived from GtkRange include Scale and Scrollbar. Apart from…
• RangeClass
• RecentData — Meta-data to be passed to RecentManager.add_full when registering a recently used resource.
• RecentInfo — Contains the metadata associated with an item in the recently used files list.
• RecentManager — Manages and looks up recently used files. Each recently used file is identified by its URI, and has meta-data associated to it, like the…
• RecentManagerClass — GtkRecentManagerClass contains only private data.
• RecentManagerPrivate
• RequestedSize — Represents a request of a screen object in a given orientation. These are primarily used in container implementations when allocating a…
• Requisition — Represents the desired size of a widget. See GtkWidget’s geometry management section for more information.
• Revealer — Animates the transition of its child from invisible to visible. The style of transition can be controlled with…
• Root — An interface for widgets that can act as the root of a widget hierarchy. The root widget takes care of providing the connection to the…
• RootInterface
• Scale — Allows to select a numeric value with a slider control. <picture> <source srcset="scales-dark.png" media="(prefers-color-scheme:…
• ScaleButton — Provides a button which pops up a scale widget. This kind of widget is commonly used for volume controls in multimedia applications, and…
• ScaleButtonClass
• ScaleClass
• ScrollInfo — Provides detailed information on how a scroll operation should be performed. Scrolling functions usually allow passing a NULL scroll info…
• Scrollable — An interface for widgets with native scrolling ability. To implement this interface you should override the Scrollable.hadjustment and…
• ScrollableInterface
• Scrollbar — Shows a horizontal or vertical scrollbar. <picture> <source srcset="scrollbar-dark.png" media="(prefers-color-scheme: dark)"> <img…
• ScrolledWindow — Makes its child scrollable. <picture> <source srcset="scrolledwindow-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• SearchBar — Reveals a search entry when search is started. <picture> <source srcset="search-bar-dark.png" media="(prefers-color-scheme: dark)">…
• SearchEntry — A single-line text entry widget for use as a search entry. The main API for interacting with a GtkSearchEntry as entry is the…
• SectionModel — An interface that adds support for sections to list models. A GtkSectionModel groups successive items into so-called sections. List…
• SectionModelInterface — The list of virtual functions for the GtkSectionModel interface. No function must be implemented, but unless…
• SelectionFilterModel — A list model that presents the selection from a GtkSelectionModel.
• SelectionFilterModelClass
• SelectionModel — An interface that adds support for selection to list models. This support is then used by widgets using list models to add the ability to…
• SelectionModelInterface — The list of virtual functions for the GtkSelectionModel interface. No function must be implemented, but unless…
• Separator — Draws a horizontal or vertical line to separate other widgets. <picture> <source srcset="separator-dark.png"…
• Settings — Provides a mechanism to share global settings between applications. GTK relies on the platform-specific API for getting desktop-wide…
• Shortcut — Describes a keyboard shortcut. It contains a description of how to trigger the shortcut via a ShortcutTrigger and a way to activate the…
• ShortcutAction — Encodes an action that can be triggered by a keyboard shortcut. GtkShortcutActions contain functions that allow easy presentation to end…
• ShortcutActionClass
• ShortcutClass
• ShortcutController — Manages keyboard shortcuts and their activation. Most common shortcuts are using this controller implicitly, e.g. by adding a mnemonic…
• ShortcutControllerClass
• ShortcutLabel — GtkShortcutLabel displays a single keyboard shortcut or gesture. The main use case for GtkShortcutLabel is inside a ShortcutsWindow.
• ShortcutLabelClass
• ShortcutManager — An interface that is used to implement shortcut scopes. This is important for Native widgets that have their own surface, since the event…
• ShortcutManagerInterface — The list of functions that can be implemented for the GtkShortcutManager interface. Note that no function is mandatory to implement, the…
• ShortcutTrigger — Tracks how a GtkShortcut can be activated. To find out if a GtkShortcutTrigger triggers, you can call ShortcutTrigger.trigger on a…
• ShortcutTriggerClass
• ShortcutsGroup — A GtkShortcutsGroup represents a group of related keyboard shortcuts or gestures. The group has a title. It may optionally be associated…
• ShortcutsGroupClass
• ShortcutsSection — A GtkShortcutsSection collects all the keyboard shortcuts and gestures for a major application mode. If your application needs multiple…
• ShortcutsSectionClass
• ShortcutsShortcut — A GtkShortcutsShortcut represents a single keyboard shortcut or gesture with a short text. This widget is only meant to be used with…
• ShortcutsShortcutClass
• ShortcutsWindow — A GtkShortcutsWindow shows information about the keyboard shortcuts and gestures of an application. The shortcuts can be grouped, and you…
• SignalAction — Emits a signal on a widget. Signals that are used in this way are referred to as keybinding signals, and they are expected to be defined…
• SignalActionClass
• SignalListItemFactory — Emits signals to manage listitems. Signals are emitted for every listitem in the same order: 1. SignalListItemFactory.setup is emitted to…
• SignalListItemFactoryClass
• SingleSelection — A selection model that allows selecting a single item. Note that the selection is persistent -- if the selected item is removed and…
• SingleSelectionClass
• SizeGroup — Groups widgets together so they all request the same size. This is typically useful when you want a column of widgets to have the same…
• SliceListModel — A list model that presents a slice of another model. This is useful when implementing paging by setting the size to the number of elements…
• SliceListModelClass
• Snapshot — Assists in creating Gsk.RenderNodes for widgets. It functions in a similar way to a cairo context, and maintains a stack of render nodes…
• SnapshotClass
• SortListModel — A list model that sorts the elements of another model. The elements are sorted according to a GtkSorter. The model is a stable sort. If…
• SortListModelClass
• Sorter — Describes sorting criteria for a SortListModel. Its primary user is SortListModel The model will use a sorter to determine the order in…
• SorterClass — The virtual table for GtkSorter.
• SpinButton — Allows to enter or change numeric values. <picture> <source srcset="spinbutton-dark.png" media="(prefers-color-scheme: dark)">…
• Spinner — Displays an icon-size spinning animation. It is often used as an alternative to a ProgressBar for displaying indefinite activity, instead…
• Stack — Shows one of its children at a time. <picture> <source srcset="stack-dark.png" media="(prefers-color-scheme: dark)"> <img alt="An…
• StackPage — An auxiliary class used by GtkStack.
• StackSidebar — Uses a sidebar to switch between GtkStack pages. <picture> <source srcset="sidebar-dark.png" media="(prefers-color-scheme: dark)">…
• StackSwitcher — Shows a row of buttons to switch between GtkStack pages. <picture> <source srcset="stackswitcher-dark.png"…
• Statusbar — A GtkStatusbar widget is usually placed along the bottom of an application's main Window. <picture> <source…
• StringFilter — Determines whether to include items by comparing strings to a fixed search term. The strings are obtained from the items by evaluating an…
• StringFilterClass
• StringList — A list model that wraps an array of strings. The objects in the model are of type StringObject and have a "string" property that can be…
• StringListClass
• StringObject — The type of items in a GtkStringList. A GtkStringObject is a wrapper around a const char*; it has a StringObject.string property that…
• StringObjectClass
• StringSorter — Sorts items by comparing strings. To obtain the strings to compare, this sorter evaluates a Expression. It does the comparison in a…
• StringSorterClass
• StyleContext — GtkStyleContext stores styling information affecting a widget. In order to construct the final style information, GtkStyleContext…
• StyleContextClass
• StyleProvider — An interface for style information used by StyleContext. See StyleContext.add_provider and StyleContext.add_provider_for_display for adding…
• Svg — A paintable implementation that renders SVG, with animations. GtkSvg objects are created by parsing a subset of SVG, including SVG…
• SvgClass
• SvgLocation — Provides information about a location in an SVG document. The information should be considered approximate; it is meant to provide feedback…
• Switch — Shows a "light switch" that has two states: on or off. <picture> <source srcset="switch-dark.png" media="(prefers-color-scheme:…
• SymbolicPaintable — An interface that supports symbolic colors in paintables. GdkPaintables implementing the interface will have the…
• SymbolicPaintableInterface — The list of virtual functions for the GtkSymbolicPaintable interface. No function must be implemented, default implementations exist for…
• Text — A single-line text entry. GtkText is the common implementation of single-line text editing that is shared between Entry, PasswordEntry,…
• TextBuffer — Stores text and attributes for display in a GtkTextView. You may wish to begin by reading the text widget conceptual overview, which…
• TextBufferClass — The class structure for GtkTextBuffer.
• TextBufferPrivate
• TextChildAnchor — Marks a spot in a GtkTextBuffer where child widgets can be “anchored”. The anchor can have multiple widgets anchored, to allow for…
• TextChildAnchorClass
• TextIter — Iterates over the contents of a GtkTextBuffer. You may wish to begin by reading the text widget conceptual overview, which gives an…
• TextMark — Marks a position in a GtkTextbuffer that is preserved across modifications. You may wish to begin by reading the text widget conceptual…
• TextMarkClass
• TextTag — Can be applied to text contained in a GtkTextBuffer. You may wish to begin by reading the text widget conceptual overview, which gives an…
• TextTagClass
• TextTagPrivate
• TextTagTable — Collects the tags in a GtkTextBuffer. You may wish to begin by reading the text widget conceptual overview, which gives an overview of…
• TextView — Displays the contents of a TextBuffer. <picture> <source srcset="multiline-text-dark.png" media="(prefers-color-scheme: dark)">…
• TextViewClass
• TextViewPrivate
• ToggleButton — Shows a button which remains “pressed-in” when clicked. <picture> <source srcset="toggle-button-dark.png"…
• ToggleButtonClass
• Tooltip — Represents a widget tooltip. Basic tooltips can be realized simply by using Widget.set_tooltip_text or Widget.set_tooltip_markup without…
• TreeDragDest — Interface for Drag-and-Drop destinations in GtkTreeView.
• TreeDragDestIface
• TreeDragSource — Interface for Drag-and-Drop destinations in GtkTreeView.
• TreeDragSourceIface
• TreeExpander — Provides an expander for a tree-like list. It is typically placed as a bottommost child into a GtkListView to allow users to expand and…
• TreeExpanderClass
• TreeIter — The GtkTreeIter is the primary structure for accessing a GtkTreeModel. Models are expected to put a unique integer in the stamp…
• TreeListModel — A list model that can create child models on demand.
• TreeListModelClass
• TreeListRow — The type of item used by GtkTreeListModel. It allows navigating the model as a tree and modify the state of rows. GtkTreeListRow…
• TreeListRowClass
• TreeListRowSorter — Applies a gives sorter to the levels in a tree. Here is an example for setting up a column view with a tree model and a…
• TreeListRowSorterClass
• TreeModel — The tree interface used by GtkTreeView The GtkTreeModel interface defines a generic tree interface for use by the GtkTreeView widget.…
• TreeModelFilter — A GtkTreeModel which hides parts of an underlying tree model A GtkTreeModelFilter is a tree model which wraps another tree model, and…
• TreeModelFilterClass
• TreeModelFilterPrivate
• TreeModelIface
• TreeModelSort — A GtkTreeModel which makes an underlying tree model sortable The GtkTreeModelSort is a model which implements the GtkTreeSortable…
• TreeModelSortClass
• TreeModelSortPrivate
• TreePath — An opaque structure representing a path to a row in a model.
• TreeRowReference — A GtkTreeRowReference tracks model changes so that it always refers to the same row (a GtkTreePath refers to a position, not a fixed…
• TreeSelection — The selection object for GtkTreeView The GtkTreeSelection object is a helper object to manage the selection for a GtkTreeView widget.…
• TreeSortable — The interface for sortable models used by GtkTreeView GtkTreeSortable is an interface to be implemented by tree models which support…
• TreeSortableIface
• TreeStore — A tree-like data structure that can be used with the TreeView. The GtkTreeStore object is a list model for use with a GtkTreeView…
• TreeStoreClass
• TreeStorePrivate
• TreeView — A widget for displaying both trees and lists <picture> <source srcset="list-and-tree-dark.png" media="(prefers-color-scheme: dark)">…
• TreeViewClass
• TreeViewColumn — A visible column in a TreeView widget The GtkTreeViewColumn object represents a visible column in a GtkTreeView widget. It allows to…
• TryExpression — A GtkExpression that tries to evaluate each of its expressions until it succeeds. If all expressions fail to evaluate, the…
• UriLauncher — Asynchronous API to open a uri with an application. GtkUriLauncher collects the arguments that are needed to open the uri. Depending on…
• UriLauncherClass
• Video — Shows a GtkMediaStream with media controls. <picture> <source srcset="video-dark.png" media="(prefers-color-scheme: dark)"> <img…
• VideoClass
• Viewport — Implements scrollability for widgets that don't support scrolling on their own. Use GtkViewport to scroll child widgets such as…
• VolumeButton — GtkVolumeButton is a GtkScaleButton subclass tailored for volume control. <picture> <source srcset="volumebutton-dark.png"…
• Widget — The base class for all widgets. It manages the widget lifecycle, layout, states and style. ##### Height-for-width Geometry Management GTK…
• WidgetClass
• WidgetClassPrivate
• WidgetPaintable — A GdkPaintable that displays the contents of a widget. GtkWidgetPaintable will also take care of the widget not being in a state where…
• WidgetPaintableClass
• WidgetPrivate
• Window — A toplevel window which can contain other widgets. <picture> <source srcset="window-dark.png" media="(prefers-color-scheme: dark)">…
• WindowClass
• WindowControls — Shows window frame controls. Typical window frame controls are minimize, maximize and close buttons, and the window icon. <picture>…
• WindowControlsClass
• WindowGroup — Creates groups of windows that behave like separate applications. It achieves this by limiting the effect of GTK grabs and modality to…
• WindowGroupClass
• WindowGroupPrivate
• WindowHandle — Implements titlebar functionality for a window. When added into a window, it can be dragged to move the window, and it implements the right…
• WindowHandleClass

Functions

accelerator_get_accessible_label

def accelerator_get_accessible_label(accelerator_key: int, accelerator_mods: Gdk.ModifierType | int) -> str

Generates an accessible description of an accelerator.

This function is similar to accelerator_get_label but it is meant for accessibility layers labels rather than user-facing labels. The output of this function is fit for AccessibleProperty.KEY_SHORTCUTS.

For more information, see the WAI-ARIA reference.

Parameters:

• accelerator_key — accelerator keyval
• accelerator_mods — accelerator modifier mask

accelerator_get_default_mod_mask

def accelerator_get_default_mod_mask() -> Gdk.ModifierType

Gets the modifier mask.

The modifier mask determines which modifiers are considered significant for keyboard accelerators. This includes all keyboard modifiers except for GDK_LOCK_MASK.

accelerator_get_label

def accelerator_get_label(accelerator_key: int, accelerator_mods: Gdk.ModifierType | int) -> str

Converts an accelerator keyval and modifier mask into a string which can be used to represent the accelerator to the user.

Parameters:

• accelerator_key — accelerator keyval
• accelerator_mods — accelerator modifier mask

accelerator_get_label_with_keycode

def accelerator_get_label_with_keycode(display: Gdk.Display | None, accelerator_key: int, keycode: int, accelerator_mods: Gdk.ModifierType | int) -> str

Converts an accelerator keyval and modifier mask into a string that can be displayed to the user.

The string may be translated.

This function is similar to accelerator_get_label, but handling keycodes. This is only useful for system-level components, applications should use accelerator_get_label instead.

Parameters:

• display — a GdkDisplay
• accelerator_key — accelerator keyval
• keycode — accelerator keycode
• accelerator_mods — accelerator modifier mask

accelerator_name

def accelerator_name(accelerator_key: int, accelerator_mods: Gdk.ModifierType | int) -> str

Converts an accelerator keyval and modifier mask into a string that can be parsed by accelerator_parse.

For example, if you pass in GDK_KEY_q and GDK_CONTROL_MASK, this function returns <Control>q.

If you need to display accelerators in the user interface, see accelerator_get_label.

Parameters:

• accelerator_key — accelerator keyval
• accelerator_mods — accelerator modifier mask

accelerator_name_with_keycode

def accelerator_name_with_keycode(display: Gdk.Display | None, accelerator_key: int, keycode: int, accelerator_mods: Gdk.ModifierType | int) -> str

Converts an accelerator keyval and modifier mask into a string that can be parsed by accelerator_parse_with_keycode.

This is similar to accelerator_name but handling keycodes. This is only useful for system-level components, applications should use accelerator_name instead.

Parameters:

• display — a GdkDisplay
• accelerator_key — accelerator keyval
• keycode — accelerator keycode
• accelerator_mods — accelerator modifier mask

accelerator_parse

def accelerator_parse(accelerator: str) -> tuple[bool, int, Gdk.ModifierType | int]

Parses a string representing an accelerator.

The format looks like “<Control>a” or “<Shift><Alt>F1”.

The parser is fairly liberal and allows lower or upper case, and also abbreviations such as “<Ctl>” and “<Ctrl>”.

Key names are parsed using Gdk.keyval_from_name. For character keys the name is not the symbol, but the lowercase name, e.g. one would use “<Ctrl>minus” instead of “<Ctrl>-”.

Modifiers are enclosed in angular brackets <>, and match the Gdk.ModifierType mask:

• <Shift> for GDK_SHIFT_MASK
• <Ctrl> for GDK_CONTROL_MASK
• <Alt> for GDK_ALT_MASK
• <Meta> for GDK_META_MASK
• <Super> for GDK_SUPER_MASK
• <Hyper> for GDK_HYPER_MASK

If the parse operation fails, accelerator_key and accelerator_mods will be set to 0 (zero).

Parameters:

• accelerator — string representing an accelerator

accelerator_parse_with_keycode

def accelerator_parse_with_keycode(accelerator: str, display: Gdk.Display | None = ...) -> tuple[bool, int, list[int], Gdk.ModifierType | int]

Parses a string representing an accelerator.

This is similar to accelerator_parse but handles keycodes as well. This is only useful for system-level components, applications should use accelerator_parse instead.

If accelerator_codes is given and the result stored in it is non-None, the result must be freed with GLib.free.

If a keycode is present in the accelerator and no accelerator_codes is given, the parse will fail.

If the parse fails, accelerator_key, accelerator_mods and accelerator_codes will be set to 0 (zero).

Parameters:

• accelerator — string representing an accelerator
• display — the GdkDisplay to look up accelerator_codes in

accelerator_valid

def accelerator_valid(keyval: int, modifiers: Gdk.ModifierType | int) -> bool

Determines whether a given keyval and modifier mask constitute a valid keyboard accelerator.

For example, the GDK_KEY_a keyval plus GDK_CONTROL_MASK mask is valid, and matches the “Ctrl+a” accelerator. But, you can't, for instance, use the GDK_KEY_Control_L keyval as an accelerator.

Parameters:

• keyval — a GDK keyval
• modifiers — modifier mask

check_version

def check_version(required_major: int, required_minor: int, required_micro: int) -> str | None

Checks that the GTK library in use is compatible with the given version.

Generally you would pass in the constants MAJOR_VERSION, MINOR_VERSION, MICRO_VERSION as the three arguments to this function; that produces a check that the library in use is compatible with the version of GTK the application or module was compiled against.

Compatibility is defined by two things: first the version of the running library is newer than the version required_major.required_minor.required_micro. Second the running library must be binary compatible with the version required_major.required_minor.required_micro (same major version.)

This function is primarily for GTK modules; the module can call this function to check that it wasn’t loaded into an incompatible version of GTK. However, such a check isn’t completely reliable, since the module may be linked against an old version of GTK and calling the old version of check_version, but still get loaded into an application using a newer version of GTK.

Parameters:

• required_major — the required major version
• required_minor — the required minor version
• required_micro — the required micro version

css_parser_error_quark

def css_parser_error_quark() -> GLib.Quark

Registers an error quark for CSS parsing errors.

css_parser_warning_quark

def css_parser_warning_quark() -> GLib.Quark

Registers an error quark for CSS parsing warnings.

disable_portal_interfaces

def disable_portal_interfaces(portal_interfaces: list[str]) -> None

Prevents GTK from using the specified portals.

This should only be used in portal implementations, apps must not call it.

Parameters:

• portal_interfaces — a None-terminated array of portal interface names to disable

disable_portals

def disable_portals() -> None

Prevents GTK from using portals.

This is equivalent to setting GDK_DEBUG=no-portals in the environment.

This should only be used in portal implementations, apps must not call it.

disable_setlocale

def disable_setlocale() -> None

Prevents init and init_check from calling setlocale().

You would want to use this function if you wanted to set the locale for your program to something other than the user’s locale, or if you wanted to set different values for different locale categories.

Most programs should not need to call this function.

distribute_natural_allocation

def distribute_natural_allocation(extra_space: int, sizes: list[RequestedSize]) -> int

Distributes extra_space to child sizes by bringing smaller children up to natural size first.

The remaining space will be added to the minimum_size member of the GtkRequestedSize struct. If all sizes reach their natural size then the remaining space is returned.

Parameters:

• extra_space — Extra space to redistribute among children after subtracting minimum sizes and any child padding from the overall allocation
• sizes — An array of structs with a client pointer and a minimum/natural size in the orientation of the allocation.

enumerate_printers

def enumerate_printers(func: PrinterFunc, wait: bool) -> None

Calls a function for all printers that are known to GTK.

If func returns true, the enumeration is stopped.

Parameters:

• func — a function to call for each printer
• wait — if true, wait in a recursive mainloop until all printers are enumerated; otherwise return early

get_binary_age

def get_binary_age() -> int

Returns the binary age as passed to libtool.

If libtool means nothing to you, don't worry about it.

get_debug_flags

def get_debug_flags() -> DebugFlags

Returns the GTK debug flags that are currently active.

This function is intended for GTK modules that want to adjust their debug output based on GTK debug flags.

get_default_language

def get_default_language() -> Pango.Language

Returns the PangoLanguage for the default language currently in effect.

Note that this can change over the life of an application.

The default language is derived from the current locale. It determines, for example, whether GTK uses the right-to-left or left-to-right text direction.

This function is equivalent to Pango.Language.get_default. See that function for details.

get_interface_age

def get_interface_age() -> int

Returns the interface age as passed to libtool.

If libtool means nothing to you, don't worry about it.

get_locale_direction

def get_locale_direction() -> TextDirection

Gets the direction of the current locale.

This is the expected reading direction for text and UI.

This function depends on the current locale being set with setlocale() and will default to setting the GTK_TEXT_DIR_LTR direction otherwise. GTK_TEXT_DIR_NONE will never be returned.

GTK sets the default text direction according to the locale during init, and you should normally use Widget.get_direction or Widget.get_default_direction to obtain the current direction.

This function is only needed rare cases when the locale is changed after GTK has already been initialized. In this case, you can use it to update the default text direction as follows:

#include <locale.h>

static void
update_locale (const char *new_locale)
{
  setlocale (LC_ALL, new_locale);
  gtk_widget_set_default_direction (gtk_get_locale_direction ());
}

get_major_version

def get_major_version() -> int

Returns the major version number of the GTK library.

For example, in GTK version 3.1.5 this is 3.

This function is in the library, so it represents the GTK library your code is running against. Contrast with the MAJOR_VERSION macro, which represents the major version of the GTK headers you have included when compiling your code.

get_micro_version

def get_micro_version() -> int

Returns the micro version number of the GTK library.

For example, in GTK version 3.1.5 this is 5.

This function is in the library, so it represents the GTK library your code is are running against. Contrast with the MICRO_VERSION macro, which represents the micro version of the GTK headers you have included when compiling your code.

get_minor_version

def get_minor_version() -> int

Returns the minor version number of the GTK library.

For example, in GTK version 3.1.5 this is 1.

This function is in the library, so it represents the GTK library your code is are running against. Contrast with the MINOR_VERSION macro, which represents the minor version of the GTK headers you have included when compiling your code.

hsv_to_rgb

def hsv_to_rgb(h: float, s: float, v: float) -> tuple[float, float, float]

Converts a color from HSV space to RGB.

Input values must be in the [0.0, 1.0] range; output values will be in the same range.

Parameters:

• h — Hue
• s — Saturation
• v — Value

init

def init() -> None

Initializes GTK.

This function must be called before using any other GTK functions in your GUI applications.

It will initialize everything needed to operate the toolkit. In particular, it will open the default display (see Gdk.Display.get_default).

If you are using Application, you usually don't have to call this function; the Gio.Application.startup handler does it for you. Though, if you are using GApplication methods that will be invoked before startup, such as local_command_line, you may need to initialize GTK explicitly.

This function will terminate your program if it was unable to initialize the windowing system for some reason. If you want your program to fall back to a textual interface, call init_check instead.

GTK calls signal (SIGPIPE, SIG_IGN) during initialization, to ignore SIGPIPE signals, since these are almost never wanted in graphical applications. If you do need to handle SIGPIPE for some reason, reset the handler after init, but notice that other libraries (e.g. libdbus or gvfs) might do similar things.

init_check

def init_check() -> bool

Initializes GTK.

This function does the same work as init with only a single change: It does not terminate the program if the windowing system can’t be initialized. Instead it returns false on failure.

This way the application can fall back to some other means of communication with the user - for example a curses or command line interface.

is_initialized

def is_initialized() -> bool

Returns whether GTK has been initialized.

See init.

param_spec_expression

def param_spec_expression(name: str, nick: str, blurb: str, flags: GObject.ParamFlags | int) -> GObject.ParamSpec

Creates a new GParamSpec instance for a property holding a GtkExpression.

See g_param_spec_internal() for details on the property strings.

Parameters:

• name — canonical name of the property
• nick — a user-readable name for the property
• blurb — a user-readable description of the property
• flags — flags for the property

print_run_page_setup_dialog

def print_run_page_setup_dialog(parent: Window | None, page_setup: PageSetup | None, settings: PrintSettings) -> PageSetup

Runs a page setup dialog, letting the user modify the values from page_setup.

If the user cancels the dialog, the returned GtkPageSetup is identical to the passed in page_setup, otherwise it contains the modifications done in the dialog.

Note that this function may use a recursive mainloop to show the page setup dialog. See print_run_page_setup_dialog_async if this is a problem.

Parameters:

• parent — transient parent
• page_setup — an existing GtkPageSetup
• settings — a GtkPrintSettings

print_run_page_setup_dialog_async

def print_run_page_setup_dialog_async(parent: Window | None, page_setup: PageSetup | None, settings: PrintSettings, done_cb: PageSetupDoneFunc) -> None

Runs a page setup dialog, letting the user modify the values from page_setup.

In contrast to print_run_page_setup_dialog, this function returns after showing the page setup dialog on platforms that support this, and calls done_cb from a signal handler for the ::response signal of the dialog.

Parameters:

• parent — transient parent
• page_setup — an existing GtkPageSetup
• settings — a GtkPrintSettings
• done_cb — a function to call when the user saves the modified page setup

render_activity

def render_activity(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders an activity indicator (such as in GtkSpinner). The state StateFlags.CHECKED determines whether there is activity going on.

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

render_arrow

def render_arrow(context: StyleContext, cr: cairo.Context[cairo.Surface], angle: float, x: float, y: float, size: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders an arrow pointing to angle.

Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• angle — arrow angle from 0 to 2 * GLib.PI, being 0 the arrow pointing to the north
• x — X origin of the render area
• y — Y origin of the render area
• size — square side for render area

render_background

def render_background(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders the background of an element.

Typical background rendering, showing the effect of background-image, border-width and border-radius:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

render_check

def render_check(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders a checkmark (as in a GtkCheckButton).

The StateFlags.CHECKED state determines whether the check is on or off, and StateFlags.INCONSISTENT determines whether it should be marked as undefined.

Typical checkmark rendering:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

render_expander

def render_expander(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders an expander (as used in GtkTreeView and GtkExpander) in the area defined by x, y, width, height. The state StateFlags.CHECKED determines whether the expander is collapsed or expanded.

Typical expander rendering:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

render_focus

def render_focus(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders a focus indicator on the rectangle determined by x, y, width, height.

Typical focus rendering:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

render_frame

def render_frame(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders a frame around the rectangle defined by x, y, width, height.

Examples of frame rendering, showing the effect of border-image, border-color, border-width, border-radius and junctions:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

render_handle

def render_handle(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders a handle (as in GtkPaned and GtkWindow’s resize grip), in the rectangle determined by x, y, width, height.

Handles rendered for the paned and grip classes:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

render_icon

def render_icon(context: StyleContext, cr: cairo.Context[cairo.Surface], texture: Gdk.Texture, x: float, y: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders the icon in texture at the specified x and y coordinates.

This function will render the icon in texture at exactly its size, regardless of scaling factors, which may not be appropriate when drawing on displays with high pixel densities.

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• texture — a GdkTexture containing the icon to draw
• x — X position for the texture
• y — Y position for the texture

render_layout

def render_layout(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, layout: Pango.Layout) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders layout on the coordinates x, y

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin
• y — Y origin
• layout — the PangoLayout to render

render_line

def render_line(context: StyleContext, cr: cairo.Context[cairo.Surface], x0: float, y0: float, x1: float, y1: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders a line from (x0, y0) to (x1, y1).

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x0 — X coordinate for the origin of the line
• y0 — Y coordinate for the origin of the line
• x1 — X coordinate for the end of the line
• y1 — Y coordinate for the end of the line

render_option

def render_option(context: StyleContext, cr: cairo.Context[cairo.Surface], x: float, y: float, width: float, height: float) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

Renders an option mark (as in a radio button), the StateFlags.CHECKED state will determine whether the option is on or off, and StateFlags.INCONSISTENT whether it should be marked as undefined.

Typical option mark rendering:

Parameters:

• context — a GtkStyleContext
• cr — a cairo_t
• x — X origin of the rectangle
• y — Y origin of the rectangle
• width — rectangle width
• height — rectangle height

rgb_to_hsv

def rgb_to_hsv(r: float, g: float, b: float) -> tuple[float, float, float]

Converts a color from RGB space to HSV.

Input values must be in the [0.0, 1.0] range; output values will be in the same range.

Parameters:

• r — Red
• g — Green
• b — Blue

set_debug_flags

def set_debug_flags(flags: DebugFlags | int) -> None

Sets the GTK debug flags.

Parameters:

• flags — the debug flags to set

show_uri

def show_uri(parent: Window | None, uri: str, timestamp: int) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

This function launches the default application for showing a given uri, or shows an error dialog if that fails.

Parameters:

• parent — parent window
• uri — the uri to show
• timestamp — timestamp from the event that triggered this call, or Gdk.CURRENT_TIME

show_uri_full

def show_uri_full(parent: Window | None, uri: str, timestamp: int, cancellable: Gio.Cancellable | None = ..., callback: Gio.AsyncReadyCallback | None = ...) -> None

:::warning Deprecated since 4.10 This API is deprecated. :::

This function launches the default application for showing a given uri.

The callback will be called when the launch is completed.

This is the recommended call to be used as it passes information necessary for sandbox helpers to parent their dialogs properly.

Parameters:

• parent — parent window
• uri — the uri to show
• timestamp — timestamp from the event that triggered this call, or Gdk.CURRENT_TIME
• cancellable — a GCancellable to cancel the launch
• callback — a callback to call when the action is complete

show_uri_full_finish

def show_uri_full_finish(parent: Window, result: Gio.AsyncResult) -> bool

:::warning Deprecated since 4.10 This API is deprecated. :::

Finishes the show_uri call and returns the result of the operation.

Parameters:

• parent — the GtkWindow passed to show_uri
• result — GAsyncResult that was passed to callback

test_accessible_assertion_message_role

def test_accessible_assertion_message_role(domain: str, file: str, line: int, func: str, expr: str, accessible: Accessible, expected_role: AccessibleRole | int, actual_role: AccessibleRole | int) -> None

Prints an assertion message for gtk_test_accessible_assert_role().

Parameters:

• domain — a domain
• file — a file name
• line — the line in file
• func — a function name in file
• expr — the expression being tested
• accessible — a GtkAccessible
• expected_role — the expected GtkAccessibleRole
• actual_role — the actual GtkAccessibleRole

test_accessible_has_property

def test_accessible_has_property(accessible: Accessible, property: AccessibleProperty | int) -> bool

Checks whether the GtkAccessible has property set.

Parameters:

• accessible — a GtkAccessible
• property — a GtkAccessibleProperty

test_accessible_has_relation

def test_accessible_has_relation(accessible: Accessible, relation: AccessibleRelation | int) -> bool

Checks whether the GtkAccessible has relation set.

Parameters:

• accessible — a GtkAccessible
• relation — a GtkAccessibleRelation

test_accessible_has_role

def test_accessible_has_role(accessible: Accessible, role: AccessibleRole | int) -> bool

Checks whether the GtkAccessible:accessible-role of the accessible is role.

Parameters:

• accessible — a GtkAccessible
• role — a GtkAccessibleRole

test_accessible_has_state

def test_accessible_has_state(accessible: Accessible, state: AccessibleState | int) -> bool

Checks whether the GtkAccessible has state set.

Parameters:

• accessible — a GtkAccessible
• state — a GtkAccessibleState

test_list_all_types

def test_list_all_types() -> list[type | GObject.Type]

Return the type ids that have been registered after calling test_register_all_types.

test_register_all_types

def test_register_all_types() -> None

Force registration of all core GTK object types.

This allows to refer to any of those object types via GObject.type_from_name after calling this function.

test_widget_wait_for_draw

def test_widget_wait_for_draw(widget: Widget) -> None

Enters the main loop and waits for widget to be “drawn”.

In this context that means it waits for the frame clock of widget to have run a full styling, layout and drawing cycle.

This function is intended to be used for syncing with actions that depend on widget relayouting or on interaction with the display server.

Parameters:

• widget — the widget to wait for

tree_create_row_drag_content

def tree_create_row_drag_content(tree_model: TreeModel, path: TreePath) -> Gdk.ContentProvider

:::warning Deprecated since 4.10 This API is deprecated. :::

Creates a content provider for dragging path from tree_model.

Parameters:

• tree_model — a GtkTreeModel
• path — a row in tree_model

tree_get_row_drag_data

def tree_get_row_drag_data(value: GObject.Value) -> tuple[bool, TreeModel, TreePath]

:::warning Deprecated since 4.10 This API is deprecated. :::

Obtains a tree_model and path from value of target type GTK_TYPE_TREE_ROW_DATA.

The returned path must be freed with TreePath.free.

Parameters:

• value — a GValue

value_dup_expression

def value_dup_expression(value: GObject.Value) -> Expression | None

Retrieves the GtkExpression stored inside the given value, and acquires a reference to it.

Parameters:

• value — a GValue initialized with type GTK_TYPE_EXPRESSION

value_get_expression

def value_get_expression(value: GObject.Value) -> Expression | None

Retrieves the GtkExpression stored inside the given value.

Parameters:

• value — a GValue initialized with type GTK_TYPE_EXPRESSION

value_set_expression

def value_set_expression(value: GObject.Value, expression: Expression) -> None

Stores the given GtkExpression inside value.

The GValue will acquire a reference to the expression.

Parameters:

• value — a GValue initialized with type GTK_TYPE_EXPRESSION
• expression — a GtkExpression

value_take_expression

def value_take_expression(value: GObject.Value, expression: Expression | None = ...) -> None

Stores the given GtkExpression inside value.

This function transfers the ownership of the expression to the GValue.

Parameters:

• value — a GValue initialized with type GTK_TYPE_EXPRESSION
• expression — a GtkExpression

Enumerations

AccessibleAnnouncementPriority

Enumeration.

• LOW = 0 — The announcement is low priority, and might be read only on the user's request.
• MEDIUM = 1 — The announcement is of medium priority, and is usually spoken at the next opportunity, such as at the end of speaking the current sentence or when the user pauses typing.
• HIGH = 2 — The announcement is of high priority, and is usually spoken immediately. Because an interruption might disorient users or cause them to not complete their current task, authors SHOULD NOT use high priority announcements unless the interruption is imperative. An example would be a notification about a critical battery power level.

AccessibleAutocomplete

Enumeration.

• NONE = 0 — Automatic suggestions are not displayed.
• INLINE = 1 — When a user is providing input, text suggesting one way to complete the provided input may be dynamically inserted after the caret.
• LIST = 2 — When a user is providing input, an element containing a collection of values that could complete the provided input may be displayed.
• BOTH = 3 — When a user is providing input, an element containing a collection of values that could complete the provided input may be displayed. If displayed, one value in the collection is automatically selected, and the text needed to complete the automatically selected value appears after the caret in the input.

AccessibleInvalidState

Enumeration.

• FALSE = 0 — There are no detected errors in the value
• TRUE = 1 — The value entered by the user has failed validation
• GRAMMAR = 2 — A grammatical error was detected
• SPELLING = 3 — A spelling error was detected

AccessiblePlatformState

Enumeration.

• FOCUSABLE = 0 — whether the accessible can be focused
• FOCUSED = 1 — whether the accessible has focus
• ACTIVE = 2 — whether the accessible is active

AccessibleProperty

Enumeration.

• AUTOCOMPLETE = 0 — Indicates whether inputting text could trigger display of one or more predictions of the user's intended value for a combobox, searchbox, or textbox and specifies how predictions would be presented if they were made. Value type: AccessibleAutocomplete
• DESCRIPTION = 1 — Defines a string value that describes or annotates the current element. Value type: string
• HAS_POPUP = 2 — Indicates the availability of interactive popup element, such as menu or popover, that can be triggered by an element. Contrary to “aria-haspopup”, it doesn't indicate the type of the element, as such it cannot be used to indicate the availability of more complex elements such as dialog. Value type: boolean
• KEY_SHORTCUTS = 3 — Indicates keyboard shortcuts that an author has implemented to activate or give focus to an element. Value type: string. The format of the value is a space-separated list of shortcuts, with each shortcut consisting of one or more modifiers (Control, Alt or Shift), followed by a non-modifier key, all separated by +. The WAI-ARIA reference specifies how to build keyboard shortcuts strings, with specific values for each key which are the same regardless of the language, so these strings can't be built from localized key names. You can convert an accelerator into the matching key shortcuts label with accelerator_get_accessible_label. Examples: F2, Alt+F, Control+Shift+N
• LABEL = 4 — Defines a string value that labels the current element. Value type: string
• LEVEL = 5 — Defines the hierarchical level of an element within a structure. Value type: integer
• MODAL = 6 — Indicates whether an element is modal when displayed. Value type: boolean
• MULTI_LINE = 7 — Indicates whether a text box accepts multiple lines of input or only a single line. Value type: boolean
• MULTI_SELECTABLE = 8 — Indicates that the user may select more than one item from the current selectable descendants. Value type: boolean
• ORIENTATION = 9 — Indicates whether the element's orientation is horizontal, vertical, or unknown/ambiguous. Value type: Orientation
• PLACEHOLDER = 10 — Defines a short hint (a word or short phrase) intended to aid the user with data entry when the control has no value. A hint could be a sample value or a brief description of the expected format. Value type: string
• READ_ONLY = 11 — Indicates that the element is not editable, but is otherwise operable. Value type: boolean
• REQUIRED = 12 — Indicates that user input is required on the element before a form may be submitted. Value type: boolean
• ROLE_DESCRIPTION = 13 — Defines a human-readable, author-localized description for the role of an element. Value type: string
• SORT = 14 — Indicates if items in a table or grid are sorted in ascending or descending order. Value type: AccessibleSort
• VALUE_MAX = 15 — Defines the maximum allowed value for a range widget. Value type: double
• VALUE_MIN = 16 — Defines the minimum allowed value for a range widget. Value type: double
• VALUE_NOW = 17 — Defines the current value for a range widget. Value type: double
• VALUE_TEXT = 18 — Defines the human readable text alternative of AccessibleProperty.VALUE_NOW for a range widget. Value type: string
• HELP_TEXT = 19 — Defines a string value that provides a description of non-standard keyboard interactions of the current element. Value type: string

AccessibleRelation

Enumeration.

• ACTIVE_DESCENDANT = 0 — Identifies the currently active element when focus is on a composite widget, combobox, textbox, group, or application. Value type: reference
• COL_COUNT = 1 — Defines the total number of columns in a table, grid, or treegrid. Value type: integer
• COL_INDEX = 2 — Defines an element's column index or position with respect to the total number of columns within a table, grid, or treegrid. Value type: integer
• COL_INDEX_TEXT = 3 — Defines a human readable text alternative of AccessibleRelation.COL_INDEX. Value type: string
• COL_SPAN = 4 — Defines the number of columns spanned by a cell or gridcell within a table, grid, or treegrid. Value type: integer
• CONTROLS = 5 — Identifies the element (or elements) whose contents or presence are controlled by the current element. Value type: reference
• DESCRIBED_BY = 6 — Identifies the element (or elements) that describes the object. Value type: reference
• DETAILS = 7 — Identifies the element (or elements) that provide additional information related to the object. Value type: reference
• ERROR_MESSAGE = 8 — Identifies the element (or elements) that provide an error message for an object. Value type: reference
• FLOW_TO = 9 — Identifies the next element (or elements) in an alternate reading order of content which, at the user's discretion, allows assistive technology to override the general default of reading in document source order. Value type: reference
• LABELLED_BY = 10 — Identifies the element (or elements) that labels the current element. Value type: reference
• OWNS = 11 — Identifies an element (or elements) in order to define a visual, functional, or contextual parent/child relationship between elements where the widget hierarchy cannot be used to represent the relationship. Value type: reference
• POS_IN_SET = 12 — Defines an element's number or position in the current set of listitems or treeitems. Value type: integer
• ROW_COUNT = 13 — Defines the total number of rows in a table, grid, or treegrid. Value type: integer
• ROW_INDEX = 14 — Defines an element's row index or position with respect to the total number of rows within a table, grid, or treegrid. Value type: integer
• ROW_INDEX_TEXT = 15 — Defines a human readable text alternative of AccessibleRelation.ROW_INDEX. Value type: string
• ROW_SPAN = 16 — Defines the number of rows spanned by a cell or gridcell within a table, grid, or treegrid. Value type: integer
• SET_SIZE = 17 — Defines the number of items in the current set of listitems or treeitems. Value type: integer
• LABEL_FOR = 18 — Identifies the element (or elements) that are labeled by the current element. Value type: reference This relation is managed by GTK and should not be set from application code.
• DESCRIPTION_FOR = 19 — Identifies the element (or elements) that are described by the current element. Value type: reference This relation is managed by GTK and should not be set from application code.
• CONTROLLED_BY = 20 — Identifies the element (or elements) that the current element is controlled by. Value type: reference This relation is managed by GTK and should not be set from application code.
• DETAILS_FOR = 21 — Identifies the element (or elements) for which the current element provides additional information. Value type: reference This relation is managed by GTK and should not be set from application code.
• ERROR_MESSAGE_FOR = 22 — Identifies the element (or elements) for which the current element provides an error message. Value type: reference This relation is managed by GTK and should not be set from application code.
• FLOW_FROM = 23 — Identifies the previous element (or elements) in an alternate reading order of content which, at the user's discretion, allows assistive technology to override the general default of reading in document source order. Value type: reference This relation is managed by GTK and should not be set from application code.

AccessibleRole

Enumeration.

• ALERT = 0 — An element with important, and usually time-sensitive, information
• ALERT_DIALOG = 1 — A type of dialog that contains an alert message
• BANNER = 2 — Unused
• BUTTON = 3 — An input element that allows for user-triggered actions when clicked or pressed
• CAPTION = 4 — Unused
• CELL = 5 — Unused
• CHECKBOX = 6 — A checkable input element that has three possible values: true, false, or mixed
• COLUMN_HEADER = 7 — A header in a columned list.
• COMBO_BOX = 8 — An input that controls another element, such as a list or a grid, that can dynamically pop up to help the user set the value of the input
• COMMAND = 9 — Abstract role.
• COMPOSITE = 10 — Abstract role.
• DIALOG = 11 — A dialog is a window that is designed to interrupt the current processing of an application in order to prompt the user to enter information or require a response.
• DOCUMENT = 12 — Content that assistive technology users may want to browse in a reading mode.
• FEED = 13 — Unused
• FORM = 14 — Unused
• GENERIC = 15 — A nameless container that has no semantic meaning of its own. This is the role that GTK uses by default for widgets.
• GRID = 16 — A grid of items.
• GRID_CELL = 17 — An item in a grid or tree grid.
• GROUP = 18 — An element that groups multiple related widgets. GTK uses this role for various containers, like HeaderBar or Notebook.
• HEADING = 19 — Unused
• IMG = 20 — An image.
• INPUT = 21 — Abstract role.
• LABEL = 22 — A visible name or caption for a user interface component.
• LANDMARK = 23 — Abstract role.
• LEGEND = 24 — Unused
• LINK = 25 — A clickable link.
• LIST = 26 — A list of items.
• LIST_BOX = 27 — Unused.
• LIST_ITEM = 28 — An item in a list.
• LOG = 29 — Unused
• MAIN = 30 — Unused
• MARQUEE = 31 — Unused
• MATH = 32 — Unused
• METER = 33 — An element that represents a value within a known range.
• MENU = 34 — A menu.
• MENU_BAR = 35 — A menubar.
• MENU_ITEM = 36 — An item in a menu.
• MENU_ITEM_CHECKBOX = 37 — A check item in a menu.
• MENU_ITEM_RADIO = 38 — A radio item in a menu.
• NAVIGATION = 39 — Unused
• NONE = 40 — An element that is not represented to accessibility technologies. This role is synonymous to GTK_ACCESSIBLE_ROLE_PRESENTATION.
• NOTE = 41 — Unused
• OPTION = 42 — Unused
• PRESENTATION = 43 — An element that is not represented to accessibility technologies. This role is synonymous to GTK_ACCESSIBLE_ROLE_NONE.
• PROGRESS_BAR = 44 — An element that displays the progress status for tasks that take a long time.
• RADIO = 45 — A checkable input in a group of radio roles, only one of which can be checked at a time.
• RADIO_GROUP = 46 — Unused
• RANGE = 47 — Abstract role.
• REGION = 48 — Unused
• ROW = 49 — A row in a columned list.
• ROW_GROUP = 50 — Unused
• ROW_HEADER = 51 — Unused
• SCROLLBAR = 52 — A graphical object that controls the scrolling of content within a viewing area, regardless of whether the content is fully displayed within the viewing area.
• SEARCH = 53 — Unused
• SEARCH_BOX = 54 — A type of textbox intended for specifying search criteria.
• SECTION = 55 — Abstract role.
• SECTION_HEAD = 56 — Abstract role.
• SELECT = 57 — Abstract role.
• SEPARATOR = 58 — A divider that separates and distinguishes sections of content or groups of menuitems.
• SLIDER = 59 — A user input where the user selects a value from within a given range.
• SPIN_BUTTON = 60 — A form of range that expects the user to select from among discrete choices.
• STATUS = 61 — Unused
• STRUCTURE = 62 — Abstract role.
• SWITCH = 63 — A type of checkbox that represents on/off values, as opposed to checked/unchecked values.
• TAB = 64 — An item in a list of tab used for switching pages.
• TABLE = 65 — Unused
• TAB_LIST = 66 — A list of tabs for switching pages.
• TAB_PANEL = 67 — A page in a notebook or stack.
• TEXT_BOX = 68 — A type of input that allows free-form text as its value.
• TIME = 69 — Unused
• TIMER = 70 — Unused
• TOOLBAR = 71 — Unused
• TOOLTIP = 72 — Unused
• TREE = 73 — Unused
• TREE_GRID = 74 — A treeview-like, columned list.
• TREE_ITEM = 75 — Unused
• WIDGET = 76 — Abstract role for interactive components of a graphical user interface
• WINDOW = 77 — Abstract role for windows.
• TOGGLE_BUTTON = 78 — A type of push button which stays pressed until depressed by a second activation.
• APPLICATION = 79 — A toplevel element of a graphical user interface. This is the role that GTK uses by default for windows.
• PARAGRAPH = 80 — A paragraph of content.
• BLOCK_QUOTE = 81 — A section of content that is quoted from another source.
• ARTICLE = 82 — A section of a page that consists of a composition that forms an independent part of a document, page, or site.
• COMMENT = 83 — A comment contains content expressing reaction to other content.
• TERMINAL = 84 — A virtual terminal.

AccessibleSort

Enumeration.

• NONE = 0 — There is no defined sort applied to the column.
• ASCENDING = 1 — Items are sorted in ascending order by this column.
• DESCENDING = 2 — Items are sorted in descending order by this column.
• OTHER = 3 — A sort algorithm other than ascending or descending has been applied.

AccessibleState

Enumeration.

• BUSY = 0 — A “busy” state. This state has boolean values
• CHECKED = 1 — A “checked” state; indicates the current state of a CheckButton. Value type: AccessibleTristate
• DISABLED = 2 — A “disabled” state; corresponds to the Widget.sensitive property. It indicates a UI element that is perceivable, but not editable or operable. Value type: boolean
• EXPANDED = 3 — An “expanded” state; corresponds to the Expander.expanded property. Value type: boolean or undefined
• HIDDEN = 4 — A “hidden” state; corresponds to the Widget.visible property. You can use this state explicitly on UI elements that should not be exposed to an assistive technology. Value type: boolean See also: AccessibleState.DISABLED
• INVALID = 5 — An “invalid” state; set when a widget is showing an error. Value type: AccessibleInvalidState
• PRESSED = 6 — A “pressed” state; indicates the current state of a ToggleButton. Value type: AccessibleTristate enumeration
• SELECTED = 7 — A “selected” state; set when a widget is selected. Value type: boolean or undefined
• VISITED = 8 — Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited. Value type: boolean.

AccessibleTextContentChange

Enumeration.

• INSERT = 0 — contents change as the result of an insert operation
• REMOVE = 1 — contents change as the result of a remove operation

AccessibleTextGranularity

Enumeration.

• CHARACTER = 0 — Use the boundary between characters (including non-printing characters)
• WORD = 1 — Use the boundary between words, starting from the beginning of the current word and ending at the beginning of the next word
• SENTENCE = 2 — Use the boundary between sentences, starting from the beginning of the current sentence and ending at the beginning of the next sentence
• LINE = 3 — Use the boundary between lines, starting from the beginning of the current line and ending at the beginning of the next line
• PARAGRAPH = 4 — Use the boundary between paragraphs, starting from the beginning of the current paragraph and ending at the beginning of the next paragraph

AccessibleTristate

Enumeration.

• FALSE = 0 — The state is false
• TRUE = 1 — The state is true
• MIXED = 2 — The state is mixed

Align

Enumeration.

• FILL = 0 — stretch to fill all space if possible, center if no meaningful way to stretch
• START = 1 — snap to left or top side, leaving space on right or bottom
• END = 2 — snap to right or bottom side, leaving space on left or top
• CENTER = 3 — center natural width of widget inside the allocation
• BASELINE_FILL = 4 — a different name for GTK_ALIGN_BASELINE.
• BASELINE = 4 — align the widget according to the baseline.
• BASELINE_CENTER = 5 — stretch to fill all space, but align the baseline.

ApplicationInhibitFlags

Bit flags.

• LOGOUT = 1 — Inhibit ending the user session by logging out or by shutting down the computer
• SWITCH = 2 — Inhibit user switching
• SUSPEND = 4 — Inhibit suspending the session or computer
• IDLE = 8 — Inhibit the session being marked as idle (and possibly locked)

ArrowType

Enumeration.

• UP = 0 — Represents an upward pointing arrow.
• DOWN = 1 — Represents a downward pointing arrow.
• LEFT = 2 — Represents a left pointing arrow.
• RIGHT = 3 — Represents a right pointing arrow.
• NONE = 4 — No arrow.

AssistantPageType

Enumeration.

• CONTENT = 0 — The page has regular contents. Both the Back and forward buttons will be shown.
• INTRO = 1 — The page contains an introduction to the assistant task. Only the Forward button will be shown if there is a next page.
• CONFIRM = 2 — The page lets the user confirm or deny the changes. The Back and Apply buttons will be shown.
• SUMMARY = 3 — The page informs the user of the changes done. Only the Close button will be shown.
• PROGRESS = 4 — Used for tasks that take a long time to complete, blocks the assistant until the page is marked as complete. Only the back button will be shown.
• CUSTOM = 5 — Used for when other page types are not appropriate. No buttons will be shown, and the application must add its own buttons through Assistant.add_action_widget.

BaselinePosition

Enumeration.

• TOP = 0 — Align the baseline at the top
• CENTER = 1 — Center the baseline
• BOTTOM = 2 — Align the baseline at the bottom

BorderStyle

Enumeration.

• NONE = 0 — No visible border
• HIDDEN = 1 — Same as BorderStyle.NONE
• SOLID = 2 — A single line segment
• INSET = 3 — Looks as if the content is sunken into the canvas
• OUTSET = 4 — Looks as if the content is coming out of the canvas
• DOTTED = 5 — A series of round dots
• DASHED = 6 — A series of square-ended dashes
• DOUBLE = 7 — Two parallel lines with some space between them
• GROOVE = 8 — Looks as if it were carved in the canvas
• RIDGE = 9 — Looks as if it were coming out of the canvas

BuilderClosureFlags

Bit flags.

• SWAPPED = 1 — The closure should be created swapped. See g_cclosure_new_swap() for details.

BuilderError

Enumeration.

• INVALID_TYPE_FUNCTION = 0 — A type-func attribute didn’t name a function that returns a GType.
• UNHANDLED_TAG = 1 — The input contained a tag that GtkBuilder can’t handle.
• MISSING_ATTRIBUTE = 2 — An attribute that is required by GtkBuilder was missing.
• INVALID_ATTRIBUTE = 3 — GtkBuilder found an attribute that it doesn’t understand.
• INVALID_TAG = 4 — GtkBuilder found a tag that it doesn’t understand.
• MISSING_PROPERTY_VALUE = 5 — A required property value was missing.
• INVALID_VALUE = 6 — GtkBuilder couldn’t parse some attribute value.
• VERSION_MISMATCH = 7 — The input file requires a newer version of GTK.
• DUPLICATE_ID = 8 — An object id occurred twice.
• OBJECT_TYPE_REFUSED = 9 — A specified object type is of the same type or derived from the type of the composite class being extended with builder XML.
• TEMPLATE_MISMATCH = 10 — The wrong type was specified in a composite class’s template XML
• INVALID_PROPERTY = 11 — The specified property is unknown for the object class.
• INVALID_SIGNAL = 12 — The specified signal is unknown for the object class.
• INVALID_ID = 13 — An object id is unknown.
• INVALID_FUNCTION = 14 — A function could not be found. This often happens when symbols are set to be kept private. Compiling code with -rdynamic or using the gmodule-export-2.0 pkgconfig module can fix this problem.

ButtonsType

Enumeration.

• NONE = 0 — no buttons at all
• OK = 1 — an OK button
• CLOSE = 2 — a Close button
• CANCEL = 3 — a Cancel button
• YES_NO = 4 — Yes and No buttons
• OK_CANCEL = 5 — OK and Cancel buttons

CellRendererAccelMode

Enumeration.

• GTK = 0 — GTK accelerators mode
• OTHER = 1 — Other accelerator mode

CellRendererMode

Enumeration.

• INERT = 0 — The cell is just for display and cannot be interacted with. Note that this doesn’t mean that eg. the row being drawn can’t be selected -- just that a particular element of it cannot be individually modified.
• ACTIVATABLE = 1 — The cell can be clicked.
• EDITABLE = 2 — The cell can be edited or otherwise modified.

CellRendererState

Bit flags.

• SELECTED = 1 — The cell is currently selected, and probably has a selection colored background to render to.
• PRELIT = 2 — The mouse is hovering over the cell.
• INSENSITIVE = 4 — The cell is drawn in an insensitive manner
• SORTED = 8 — The cell is in a sorted row
• FOCUSED = 16 — The cell is in the focus row.
• EXPANDABLE = 32 — The cell is in a row that can be expanded
• EXPANDED = 64 — The cell is in a row that is expanded

Collation

Enumeration.

• NONE = 0 — Don't do any collation
• UNICODE = 1 — Use GLib.utf8_collate_key
• FILENAME = 2 — Use GLib.utf8_collate_key_for_filename

ConstraintAttribute

Enumeration.

• NONE = 0 — No attribute, used for constant relations
• LEFT = 1 — The left edge of a widget, regardless of text direction
• RIGHT = 2 — The right edge of a widget, regardless of text direction
• TOP = 3 — The top edge of a widget
• BOTTOM = 4 — The bottom edge of a widget
• START = 5 — The leading edge of a widget, depending on text direction; equivalent to ConstraintAttribute.LEFT for LTR languages, and ConstraintAttribute.RIGHT for RTL ones
• END = 6 — The trailing edge of a widget, depending on text direction; equivalent to ConstraintAttribute.RIGHT for LTR languages, and ConstraintAttribute.LEFT for RTL ones
• WIDTH = 7 — The width of a widget
• HEIGHT = 8 — The height of a widget
• CENTER_X = 9 — The center of a widget, on the horizontal axis
• CENTER_Y = 10 — The center of a widget, on the vertical axis
• BASELINE = 11 — The baseline of a widget

ConstraintRelation

Enumeration.

• LE = -1 — Less than, or equal
• EQ = 0 — Equal
• GE = 1 — Greater than, or equal

ConstraintStrength

Enumeration.

• REQUIRED = 1001001000 — The constraint is required towards solving the layout
• STRONG = 1000000000 — A strong constraint
• MEDIUM = 1000 — A medium constraint
• WEAK = 1 — A weak constraint

ConstraintVflParserError

Enumeration.

• INVALID_SYMBOL = 0 — Invalid or unknown symbol
• INVALID_ATTRIBUTE = 1 — Invalid or unknown attribute
• INVALID_VIEW = 2 — Invalid or unknown view
• INVALID_METRIC = 3 — Invalid or unknown metric
• INVALID_PRIORITY = 4 — Invalid or unknown priority
• INVALID_RELATION = 5 — Invalid or unknown relation

ContentFit

Enumeration.

• FILL = 0 — Make the content fill the entire allocation, without taking its aspect ratio in consideration. The resulting content will appear as stretched if its aspect ratio is different from the allocation aspect ratio.
• CONTAIN = 1 — Scale the content to fit the allocation, while taking its aspect ratio in consideration. The resulting content will appear as letterboxed if its aspect ratio is different from the allocation aspect ratio.
• COVER = 2 — Cover the entire allocation, while taking the content aspect ratio in consideration. The resulting content will appear as clipped if its aspect ratio is different from the allocation aspect ratio.
• SCALE_DOWN = 3 — The content is scaled down to fit the allocation, if needed, otherwise its original size is used.

CornerType

Enumeration.

• TOP_LEFT = 0 — Place the scrollbars on the right and bottom of the widget (default behaviour).
• BOTTOM_LEFT = 1 — Place the scrollbars on the top and right of the widget.
• TOP_RIGHT = 2 — Place the scrollbars on the left and bottom of the widget.
• BOTTOM_RIGHT = 3 — Place the scrollbars on the top and left of the widget.

CssParserError

Enumeration.

• FAILED = 0 — Unknown failure.
• SYNTAX = 1 — The given text does not form valid syntax
• IMPORT = 2 — Failed to import a resource
• NAME = 3 — The given name has not been defined
• UNKNOWN_VALUE = 4 — The given value is not correct

CssParserWarning

Enumeration.

• DEPRECATED = 0 — The given construct is deprecated and will be removed in a future version
• SYNTAX = 1 — A syntax construct was used that should be avoided
• UNIMPLEMENTED = 2 — A feature is not implemented

DebugFlags

Bit flags.

• TEXT = 1 — Information about GtkTextView
• TREE = 2 — Information about GtkTreeView
• KEYBINDINGS = 4 — Information about keyboard shortcuts
• MODULES = 8 — Information about modules and extensions
• GEOMETRY = 16 — Information about size allocation
• ICONTHEME = 32 — Information about icon themes
• PRINTING = 64 — Information about printing
• BUILDER_TRACE = 128 — Trace GtkBuilder operation
• SIZE_REQUEST = 256 — Information about size requests
• NO_CSS_CACHE = 512 — Disable the style property cache
• INTERACTIVE = 1024 — Open the GTK inspector
• TOUCHSCREEN = 2048 — Show touch UI elements for pointer events.
• ACTIONS = 4096 — Information about actions and menu models
• LAYOUT = 8192 — Information from layout managers
• SNAPSHOT = 16384 — Include debug render nodes in the generated snapshots
• CONSTRAINTS = 32768 — Information from the constraints solver
• BUILDER_OBJECTS = 65536 — Log unused GtkBuilder objects
• A11Y = 131072 — Information about accessibility state changes
• ICONFALLBACK = 262144 — Information about icon fallback.
• INVERT_TEXT_DIR = 524288 — Inverts the default text-direction.
• CSS = 1048576 — Information about deprecated CSS features.
• BUILDER = 2097152 — Information about deprecated GtkBuilder features.
• SESSION = 4194304 — Information about session saving.

DeleteType

Enumeration.

• CHARS = 0 — Delete characters.
• WORD_ENDS = 1 — Delete only the portion of the word to the left/right of cursor if we’re in the middle of a word.
• WORDS = 2 — Delete words.
• DISPLAY_LINES = 3 — Delete display-lines. Display-lines refers to the visible lines, with respect to the current line breaks. As opposed to paragraphs, which are defined by line breaks in the input.
• DISPLAY_LINE_ENDS = 4 — Delete only the portion of the display-line to the left/right of cursor.
• PARAGRAPH_ENDS = 5 — Delete to the end of the paragraph. Like C-k in Emacs (or its reverse).
• PARAGRAPHS = 6 — Delete entire line. Like C-k in pico.
• WHITESPACE = 7 — Delete only whitespace. Like M-\ in Emacs.

DialogError

Enumeration.

• FAILED = 0 — Generic error condition for when an operation fails and no more specific code is applicable
• CANCELLED = 1 — The async function call was cancelled via its GCancellable
• DISMISSED = 2 — The operation was cancelled by the user (via a Cancel or Close button)

DialogFlags

Bit flags.

• MODAL = 1 — Make the constructed dialog modal
• DESTROY_WITH_PARENT = 2 — Destroy the dialog when its parent is destroyed
• USE_HEADER_BAR = 4 — Create dialog with actions in header bar instead of action area

DirectionType

Enumeration.

• TAB_FORWARD = 0 — Move forward.
• TAB_BACKWARD = 1 — Move backward.
• UP = 2 — Move up.
• DOWN = 3 — Move down.
• LEFT = 4 — Move left.
• RIGHT = 5 — Move right.

EditableProperties

Enumeration.

• PROP_TEXT = 0 — the property id for Editable.text
• PROP_CURSOR_POSITION = 1 — the property id for Editable.cursor-position
• PROP_SELECTION_BOUND = 2 — the property id for Editable.selection-bound
• PROP_EDITABLE = 3 — the property id for Editable.editable
• PROP_WIDTH_CHARS = 4 — the property id for Editable.width-chars
• PROP_MAX_WIDTH_CHARS = 5 — the property id for Editable.max-width-chars
• PROP_XALIGN = 6 — the property id for Editable.xalign
• PROP_ENABLE_UNDO = 7 — the property id for Editable.enable-undo
• NUM_PROPERTIES = 8 — the number of properties

EntryIconPosition

Enumeration.

• PRIMARY = 0 — At the beginning of the entry (depending on the text direction).
• SECONDARY = 1 — At the end of the entry (depending on the text direction).

EventControllerScrollFlags

Bit flags.

• NONE = 0 — Don't emit scroll.
• VERTICAL = 1 — Emit scroll with vertical deltas.
• HORIZONTAL = 2 — Emit scroll with horizontal deltas.
• DISCRETE = 4 — Only emit deltas that are multiples of 1.
• KINETIC = 8 — Emit ::decelerate after continuous scroll finishes.
• PHYSICAL_DIRECTION = 16 — A EventControllerScrollFlags value to prefer physical direction over logical direction (i.e. oblivious to natural scroll).
• BOTH_AXES = 3 — Emit scroll on both axes.

EventSequenceState

Enumeration.

• NONE = 0 — The sequence is handled, but not grabbed.
• CLAIMED = 1 — The sequence is handled and grabbed.
• DENIED = 2 — The sequence is denied.

FileChooserAction

Enumeration.

• OPEN = 0 — Indicates open mode. The file chooser will only let the user pick an existing file.
• SAVE = 1 — Indicates save mode. The file chooser will let the user pick an existing file, or type in a new filename.
• SELECT_FOLDER = 2 — Indicates an Open mode for selecting folders. The file chooser will let the user pick an existing folder.

FileChooserError

Enumeration.

• NONEXISTENT = 0 — Indicates that a file does not exist.
• BAD_FILENAME = 1 — Indicates a malformed filename.
• ALREADY_EXISTS = 2 — Indicates a duplicate path (e.g. when adding a bookmark).
• INCOMPLETE_HOSTNAME = 3 — Indicates an incomplete hostname (e.g. "http://foo" without a slash after that).

FilterChange

Enumeration.

• DIFFERENT = 0 — The filter change cannot be described with any of the other enumeration values
• LESS_STRICT = 1 — The filter is less strict than it was before: All items that it used to return true still return true, others now may, too.
• MORE_STRICT = 2 — The filter is more strict than it was before: All items that it used to return false still return false, others now may, too.
• DIFFERENT_REWATCH = 3 — Similar to FilterChange.DIFFERENT, but signs that item watches should be recreated. This is used by FilterListModel to keep the list up-to-date when items change.
• LESS_STRICT_REWATCH = 4 — Similar to FilterChange.LESS_STRICT, but signs that item watches should be recreated. This is used by FilterListModel to keep the list up-to-date when items change.
• MORE_STRICT_REWATCH = 5 — Similar to FilterChange.MORE_STRICT, but signs that item watches should be recreated. This is used by FilterListModel to keep the list up-to-date when items change.

FilterMatch

Enumeration.

• SOME = 0 — The filter matches some items, Filter.match may return true or false
• NONE = 1 — The filter does not match any item, Filter.match will always return false
• ALL = 2 — The filter matches all items, Filter.match will alays return true

FontChooserLevel

Bit flags.

• FAMILY = 0 — Allow selecting a font family
• STYLE = 1 — Allow selecting a specific font face
• SIZE = 2 — Allow selecting a specific font size
• VARIATIONS = 4 — Allow changing OpenType font variation axes
• FEATURES = 8 — Allow selecting specific OpenType font features

FontLevel

Enumeration.

• FAMILY = 0 — Select a font family
• FACE = 1 — Select a font face (i.e. a family and a style)
• FONT = 2 — Select a font (i.e. a face with a size, and possibly font variations)
• FEATURES = 3 — Select a font and font features

FontRendering

Enumeration.

• AUTOMATIC = 0 — Set up font rendering automatically, taking factors like screen resolution and scale into account
• MANUAL = 1 — Follow low-level font-related settings when configuring font rendering

GraphicsOffloadEnabled

Enumeration.

• ENABLED = 0 — Graphics offloading is enabled.
• DISABLED = 1 — Graphics offloading is disabled.

IconLookupFlags

Bit flags.

• NONE = 0 — Perform a regular lookup.
• FORCE_REGULAR = 1 — Try to always load regular icons, even when symbolic icon names are given
• FORCE_SYMBOLIC = 2 — Try to always load symbolic icons, even when regular icon names are given
• PRELOAD = 4 — Starts loading the texture in the background so it is ready when later needed.

IconSize

Enumeration.

• INHERIT = 0 — Keep the size of the parent element
• NORMAL = 1 — Size similar to text size
• LARGE = 2 — Large size, for example in an icon view

IconThemeError

Enumeration.

• NOT_FOUND = 0 — The icon specified does not exist in the theme
• FAILED = 1 — An unspecified error occurred.

IconViewDropPosition

Enumeration.

• NO_DROP = 0 — no drop possible
• DROP_INTO = 1 — dropped item replaces the item
• DROP_LEFT = 2 — dropped item is inserted to the left
• DROP_RIGHT = 3 — dropped item is inserted to the right
• DROP_ABOVE = 4 — dropped item is inserted above
• DROP_BELOW = 5 — dropped item is inserted below

ImageType

Enumeration.

• EMPTY = 0 — there is no image displayed by the widget
• ICON_NAME = 1 — the widget contains a named icon
• GICON = 2 — the widget contains a GIcon
• PAINTABLE = 3 — the widget contains a GdkPaintable

InputHints

Bit flags.

• NONE = 0 — No special behaviour suggested
• SPELLCHECK = 1 — Suggest checking for typos
• NO_SPELLCHECK = 2 — Suggest not checking for typos
• WORD_COMPLETION = 4 — Suggest word completion
• LOWERCASE = 8 — Suggest to convert all text to lowercase
• UPPERCASE_CHARS = 16 — Suggest to capitalize all text
• UPPERCASE_WORDS = 32 — Suggest to capitalize the first character of each word
• UPPERCASE_SENTENCES = 64 — Suggest to capitalize the first word of each sentence
• INHIBIT_OSK = 128 — Suggest to not show an onscreen keyboard (e.g for a calculator that already has all the keys).
• VERTICAL_WRITING = 256 — The text is vertical
• EMOJI = 512 — Suggest offering Emoji support
• NO_EMOJI = 1024 — Suggest not offering Emoji support
• PRIVATE = 2048 — Request that the input method should not update personalized data (like typing history)

InputPurpose

Enumeration.

• FREE_FORM = 0 — Allow any character
• ALPHA = 1 — Allow only alphabetic characters
• DIGITS = 2 — Allow only digits
• NUMBER = 3 — Edited field expects numbers
• PHONE = 4 — Edited field expects phone number
• URL = 5 — Edited field expects URL
• EMAIL = 6 — Edited field expects email address
• NAME = 7 — Edited field expects the name of a person
• PASSWORD = 8 — Like InputPurpose.FREE_FORM, but characters are hidden
• PIN = 9 — Like InputPurpose.DIGITS, but characters are hidden
• TERMINAL = 10 — Allow any character, in addition to control codes

InscriptionOverflow

Enumeration.

• CLIP = 0 — Clip the remaining text
• ELLIPSIZE_START = 1 — Omit characters at the start of the text
• ELLIPSIZE_MIDDLE = 2 — Omit characters at the middle of the text
• ELLIPSIZE_END = 3 — Omit characters at the end of the text

InterfaceColorScheme

Enumeration.

• UNSUPPORTED = 0 — The system doesn't support color schemes
• DEFAULT = 1 — The default color scheme is used
• DARK = 2 — A dark color scheme is used
• LIGHT = 3 — A light color scheme is used

InterfaceContrast

Enumeration.

• UNSUPPORTED = 0 — The system doesn't support contrast levels
• NO_PREFERENCE = 1 — No particular preference for contrast
• MORE = 2 — More contrast is preferred
• LESS = 3 — Less contrast is preferred

Justification

Enumeration.

• LEFT = 0 — The text is placed at the left edge of the label.
• RIGHT = 1 — The text is placed at the right edge of the label.
• CENTER = 2 — The text is placed in the center of the label.
• FILL = 3 — The text is placed is distributed across the label.

LevelBarMode

Enumeration.

• CONTINUOUS = 0 — the bar has a continuous mode
• DISCRETE = 1 — the bar has a discrete mode

License

Enumeration.

• UNKNOWN = 0 — No license specified
• CUSTOM = 1 — A license text is going to be specified by the developer
• GPL_2_0 = 2 — The GNU General Public License, version 2.0 or later
• GPL_3_0 = 3 — The GNU General Public License, version 3.0 or later
• LGPL_2_1 = 4 — The GNU Lesser General Public License, version 2.1 or later
• LGPL_3_0 = 5 — The GNU Lesser General Public License, version 3.0 or later
• BSD = 6 — The BSD standard license
• MIT_X11 = 7 — The MIT/X11 standard license
• ARTISTIC = 8 — The Artistic License, version 2.0
• GPL_2_0_ONLY = 9 — The GNU General Public License, version 2.0 only
• GPL_3_0_ONLY = 10 — The GNU General Public License, version 3.0 only
• LGPL_2_1_ONLY = 11 — The GNU Lesser General Public License, version 2.1 only
• LGPL_3_0_ONLY = 12 — The GNU Lesser General Public License, version 3.0 only
• AGPL_3_0 = 13 — The GNU Affero General Public License, version 3.0 or later
• AGPL_3_0_ONLY = 14 — The GNU Affero General Public License, version 3.0 only
• BSD_3 = 15 — The 3-clause BSD licence
• APACHE_2_0 = 16 — The Apache License, version 2.0
• MPL_2_0 = 17 — The Mozilla Public License, version 2.0
• _0BSD = 18 — Zero-Clause BSD license

ListScrollFlags

Bit flags.

• NONE = 0 — Don't do anything extra
• FOCUS = 1 — Focus the target item
• SELECT = 2 — Select the target item and unselect all other items.

ListTabBehavior

Enumeration.

• ALL = 0 — Cycle through all focusable items of the list
• ITEM = 1 — Cycle through a single list element, then move focus out of the list. Moving focus between items needs to be done with the arrow keys.
• CELL = 2 — Cycle only through a single cell, then move focus out of the list. Moving focus between cells needs to be done with the arrow keys. This is only relevant for cell-based widgets like ColumnView, otherwise it behaves like GTK_LIST_TAB_ITEM.

MessageType

Enumeration.

• INFO = 0 — Informational message
• WARNING = 1 — Non-fatal warning message
• QUESTION = 2 — Question requiring a choice
• ERROR = 3 — Fatal error message
• OTHER = 4 — None of the above

MovementStep

Enumeration.

• LOGICAL_POSITIONS = 0 — Move forward or back by graphemes
• VISUAL_POSITIONS = 1 — Move left or right by graphemes
• WORDS = 2 — Move forward or back by words
• DISPLAY_LINES = 3 — Move up or down lines (wrapped lines)
• DISPLAY_LINE_ENDS = 4 — Move to either end of a line
• PARAGRAPHS = 5 — Move up or down paragraphs (newline-ended lines)
• PARAGRAPH_ENDS = 6 — Move to either end of a paragraph
• PAGES = 7 — Move by pages
• BUFFER_ENDS = 8 — Move to ends of the buffer
• HORIZONTAL_PAGES = 9 — Move horizontally by pages

NaturalWrapMode

Enumeration.

• INHERIT = 0 — Inherit the minimum size request. In particular, this should be used with Pango.WrapMode.CHAR.
• NONE = 1 — Try not to wrap the text. This mode is the closest to GTK3's behavior but can lead to a wide label leaving lots of empty space below the text.
• WORD = 2 — Attempt to wrap at word boundaries. This is useful in particular when using Pango.WrapMode.WORD_CHAR as the wrap mode.

NotebookTab

Enumeration.

• FIRST = 0 — the first tab in the notebook
• LAST = 1 — the last tab in the notebook

NumberUpLayout

Enumeration.

• LRTB = 0
• LRBT = 1
• RLTB = 2
• RLBT = 3
• TBLR = 4
• TBRL = 5
• BTLR = 6
• BTRL = 7

Ordering

Enumeration.

• SMALLER = -1 — the first value is smaller than the second
• EQUAL = 0 — the two values are equal
• LARGER = 1 — the first value is larger than the second

Orientation

Enumeration.

• HORIZONTAL = 0 — The element is in horizontal orientation.
• VERTICAL = 1 — The element is in vertical orientation.

Overflow

Enumeration.

• VISIBLE = 0 — No change is applied. Content is drawn at the specified position.
• HIDDEN = 1 — Content is clipped to the bounds of the area. Content outside the area is not drawn and cannot be interacted with.

PackType

Enumeration.

• START = 0 — The child is packed into the start of the widget
• END = 1 — The child is packed into the end of the widget

PadActionType

Enumeration.

• BUTTON = 0 — Action is triggered by a pad button
• RING = 1 — Action is triggered by a pad ring
• STRIP = 2 — Action is triggered by a pad strip
• DIAL = 3 — Action is triggered by a pad dial

PageOrientation

Enumeration.

• PORTRAIT = 0 — Portrait mode.
• LANDSCAPE = 1 — Landscape mode.
• REVERSE_PORTRAIT = 2 — Reverse portrait mode.
• REVERSE_LANDSCAPE = 3 — Reverse landscape mode.

PageSet

Enumeration.

• ALL = 0 — All pages.
• EVEN = 1 — Even pages.
• ODD = 2 — Odd pages.

PanDirection

Enumeration.

• LEFT = 0 — panned towards the left
• RIGHT = 1 — panned towards the right
• UP = 2 — panned upwards
• DOWN = 3 — panned downwards

PickFlags

Bit flags.

• DEFAULT = 0 — The default behavior, include widgets that are receiving events
• INSENSITIVE = 1 — Include widgets that are insensitive
• NON_TARGETABLE = 2 — Include widgets that are marked as non-targetable. See Widget.can-target

PolicyType

Enumeration.

• ALWAYS = 0 — The scrollbar is always visible. The view size is independent of the content.
• AUTOMATIC = 1 — The scrollbar will appear and disappear as necessary. For example, when all of a GtkTreeView can not be seen.
• NEVER = 2 — The scrollbar should never appear. In this mode the content determines the size.
• EXTERNAL = 3 — Don't show a scrollbar, but don't force the size to follow the content. This can be used e.g. to make multiple scrolled windows share a scrollbar.

PopoverMenuFlags

Bit flags.

• SLIDING = 0 — Submenus are presented as sliding submenus that replace the main menu.
• NESTED = 1 — Submenus are presented as traditional, nested popovers.

PositionType

Enumeration.

• LEFT = 0 — The feature is at the left edge.
• RIGHT = 1 — The feature is at the right edge.
• TOP = 2 — The feature is at the top edge.
• BOTTOM = 3 — The feature is at the bottom edge.

PrintCapabilities

Bit flags.

• PAGE_SET = 1 — Print dialog will offer printing even/odd pages.
• COPIES = 2 — Print dialog will allow to print multiple copies.
• COLLATE = 4 — Print dialog will allow to collate multiple copies.
• REVERSE = 8 — Print dialog will allow to print pages in reverse order.
• SCALE = 16 — Print dialog will allow to scale the output.
• GENERATE_PDF = 32 — The program will send the document to the printer in PDF format
• GENERATE_PS = 64 — The program will send the document to the printer in Postscript format
• PREVIEW = 128 — Print dialog will offer a preview
• NUMBER_UP = 256 — Print dialog will offer printing multiple pages per sheet
• NUMBER_UP_LAYOUT = 512 — Print dialog will allow to rearrange pages when printing multiple pages per sheet

PrintDuplex

Enumeration.

• SIMPLEX = 0 — No duplex.
• HORIZONTAL = 1 — Horizontal duplex.
• VERTICAL = 2 — Vertical duplex.

PrintError

Enumeration.

• GENERAL = 0 — An unspecified error occurred.
• INTERNAL_ERROR = 1 — An internal error occurred.
• NOMEM = 2 — A memory allocation failed.
• INVALID_FILE = 3 — An error occurred while loading a page setup or paper size from a key file.

PrintOperationAction

Enumeration.

• PRINT_DIALOG = 0 — Show the print dialog.
• PRINT = 1 — Start to print without showing the print dialog, based on the current print settings, if possible. Depending on the platform, a print dialog might appear anyway.
• PREVIEW = 2 — Show the print preview.
• EXPORT = 3 — Export to a file. This requires the export-filename property to be set.

PrintOperationResult

Enumeration.

• ERROR = 0 — An error has occurred.
• APPLY = 1 — The print settings should be stored.
• CANCEL = 2 — The print operation has been canceled, the print settings should not be stored.
• IN_PROGRESS = 3 — The print operation is not complete yet. This value will only be returned when running asynchronously.

PrintPages

Enumeration.

• ALL = 0 — All pages.
• CURRENT = 1 — Current page.
• RANGES = 2 — Range of pages.
• SELECTION = 3 — Selected pages.

PrintQuality

Enumeration.

• LOW = 0 — Low quality.
• NORMAL = 1 — Normal quality.
• HIGH = 2 — High quality.
• DRAFT = 3 — Draft quality.

PrintStatus

Enumeration.

• INITIAL = 0 — The printing has not started yet; this status is set initially, and while the print dialog is shown.
• PREPARING = 1 — This status is set while the begin-print signal is emitted and during pagination.
• GENERATING_DATA = 2 — This status is set while the pages are being rendered.
• SENDING_DATA = 3 — The print job is being sent off to the printer.
• PENDING = 4 — The print job has been sent to the printer, but is not printed for some reason, e.g. the printer may be stopped.
• PENDING_ISSUE = 5 — Some problem has occurred during printing, e.g. a paper jam.
• PRINTING = 6 — The printer is processing the print job.
• FINISHED = 7 — The printing has been completed successfully.
• FINISHED_ABORTED = 8 — The printing has been aborted.

PropagationLimit

Enumeration.

• NONE = 0 — Events are handled regardless of what their target is.
• SAME_NATIVE = 1 — Events are only handled if their target is in the same Native (or widget with Widget.limit-events set) as the event controllers widget. Note that some event types have two targets (origin and destination).

PropagationPhase

Enumeration.

• NONE = 0 — Events are not delivered.
• CAPTURE = 1 — Events are delivered in the capture phase. The capture phase happens before the bubble phase, runs from the toplevel down to the event widget. This option should only be used on containers that might possibly handle events before their children do.
• BUBBLE = 2 — Events are delivered in the bubble phase. The bubble phase happens after the capture phase, and before the default handlers are run. This phase runs from the event widget, up to the toplevel.
• TARGET = 3 — Events are delivered in the default widget event handlers, note that widget implementations must chain up on button, motion, touch and grab broken handlers for controllers in this phase to be run.

RecentManagerError

Enumeration.

• NOT_FOUND = 0 — the URI specified does not exists in the recently used resources list.
• INVALID_URI = 1 — the URI specified is not valid.
• INVALID_ENCODING = 2 — the supplied string is not UTF-8 encoded.
• NOT_REGISTERED = 3 — no application has registered the specified item.
• READ = 4 — failure while reading the recently used resources file.
• WRITE = 5 — failure while writing the recently used resources file.
• UNKNOWN = 6 — unspecified error.

ReducedMotion

Enumeration.

• NO_PREFERENCE = 0 — The user has made no preference known to the system
• REDUCE = 1 — The user has notified the system that they prefer an interface that removes or replaces the types of motion-based animation that either trigger discomfort for those with vestibular motion sensitivity, or distraction for those with attention deficits

ResponseType

Enumeration.

• NONE = -1 — Returned if an action widget has no response id, or if the dialog gets programmatically hidden or destroyed
• REJECT = -2 — Generic response id, not used by GTK dialogs
• ACCEPT = -3 — Generic response id, not used by GTK dialogs
• DELETE_EVENT = -4 — Returned if the dialog is deleted
• OK = -5 — Returned by OK buttons in GTK dialogs
• CANCEL = -6 — Returned by Cancel buttons in GTK dialogs
• CLOSE = -7 — Returned by Close buttons in GTK dialogs
• YES = -8 — Returned by Yes buttons in GTK dialogs
• NO = -9 — Returned by No buttons in GTK dialogs
• APPLY = -10 — Returned by Apply buttons in GTK dialogs
• HELP = -11 — Returned by Help buttons in GTK dialogs

RevealerTransitionType

Enumeration.

• NONE = 0 — No transition
• CROSSFADE = 1 — Fade in
• SLIDE_RIGHT = 2 — Slide in from the left
• SLIDE_LEFT = 3 — Slide in from the right
• SLIDE_UP = 4 — Slide in from the bottom
• SLIDE_DOWN = 5 — Slide in from the top
• SWING_RIGHT = 6 — Floop in from the left
• SWING_LEFT = 7 — Floop in from the right
• SWING_UP = 8 — Floop in from the bottom
• SWING_DOWN = 9 — Floop in from the top
• FADE_SLIDE_RIGHT = 10 — Combination of RevealerTransitionType.CROSSFADE and RevealerTransitionType.SLIDE_RIGHT.
• FADE_SLIDE_LEFT = 11 — Combination of RevealerTransitionType.CROSSFADE and RevealerTransitionType.SLIDE_LEFT.
• FADE_SLIDE_UP = 12 — Combination of RevealerTransitionType.CROSSFADE and RevealerTransitionType.SLIDE_UP.
• FADE_SLIDE_DOWN = 13 — Combination of RevealerTransitionType.CROSSFADE and RevealerTransitionType.SLIDE_DOWN.

ScrollStep

Enumeration.

• STEPS = 0 — Scroll in steps.
• PAGES = 1 — Scroll by pages.
• ENDS = 2 — Scroll to ends.
• HORIZONTAL_STEPS = 3 — Scroll in horizontal steps.
• HORIZONTAL_PAGES = 4 — Scroll by horizontal pages.
• HORIZONTAL_ENDS = 5 — Scroll to the horizontal ends.

ScrollType

Enumeration.

• NONE = 0 — No scrolling.
• JUMP = 1 — Jump to new location.
• STEP_BACKWARD = 2 — Step backward.
• STEP_FORWARD = 3 — Step forward.
• PAGE_BACKWARD = 4 — Page backward.
• PAGE_FORWARD = 5 — Page forward.
• STEP_UP = 6 — Step up.
• STEP_DOWN = 7 — Step down.
• PAGE_UP = 8 — Page up.
• PAGE_DOWN = 9 — Page down.
• STEP_LEFT = 10 — Step to the left.
• STEP_RIGHT = 11 — Step to the right.
• PAGE_LEFT = 12 — Page to the left.
• PAGE_RIGHT = 13 — Page to the right.
• START = 14 — Scroll to start.
• END = 15 — Scroll to end.

ScrollablePolicy

Enumeration.

• MINIMUM = 0 — Scrollable adjustments are based on the minimum size
• NATURAL = 1 — Scrollable adjustments are based on the natural size

SelectionMode

Enumeration.

• NONE = 0 — No selection is possible.
• SINGLE = 1 — Zero or one element may be selected.
• BROWSE = 2 — Exactly one element is selected. In some circumstances, such as initially or during a search operation, it’s possible for no element to be selected with SelectionMode.BROWSE. What is really enforced is that the user can’t deselect a currently selected element except by selecting another element.
• MULTIPLE = 3 — Any number of elements may be selected. The Ctrl key may be used to enlarge the selection, and Shift key to select between the focus and the child pointed to. Some widgets may also allow Click-drag to select a range of elements.

SensitivityType

Enumeration.

• AUTO = 0 — The control is made insensitive if no action can be triggered
• ON = 1 — The control is always sensitive
• OFF = 2 — The control is always insensitive

ShortcutActionFlags

Bit flags.

• EXCLUSIVE = 1 — The action is the only action that can be activated. If this flag is not set, a future activation may select a different action.

ShortcutScope

Enumeration.

• LOCAL = 0 — Shortcuts are handled inside the widget the controller belongs to.
• MANAGED = 1 — Shortcuts are handled by the first ancestor that is a ShortcutManager
• GLOBAL = 2 — Shortcuts are handled by the root widget.

ShortcutType

Enumeration.

• ACCELERATOR = 0 — The shortcut is a keyboard accelerator. The GtkShortcutsShortcut:accelerator property will be used.
• GESTURE_PINCH = 1 — The shortcut is a pinch gesture. GTK provides an icon and subtitle.
• GESTURE_STRETCH = 2 — The shortcut is a stretch gesture. GTK provides an icon and subtitle.
• GESTURE_ROTATE_CLOCKWISE = 3 — The shortcut is a clockwise rotation gesture. GTK provides an icon and subtitle.
• GESTURE_ROTATE_COUNTERCLOCKWISE = 4 — The shortcut is a counterclockwise rotation gesture. GTK provides an icon and subtitle.
• GESTURE_TWO_FINGER_SWIPE_LEFT = 5 — The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
• GESTURE_TWO_FINGER_SWIPE_RIGHT = 6 — The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
• GESTURE = 7 — The shortcut is a gesture. The GtkShortcutsShortcut:icon property will be used.
• GESTURE_SWIPE_LEFT = 8 — The shortcut is a swipe gesture. GTK provides an icon and subtitle.
• GESTURE_SWIPE_RIGHT = 9 — The shortcut is a swipe gesture. GTK provides an icon and subtitle.

SizeGroupMode

Enumeration.

• NONE = 0 — group has no effect
• HORIZONTAL = 1 — group affects horizontal requisition
• VERTICAL = 2 — group affects vertical requisition
• BOTH = 3 — group affects both horizontal and vertical requisition

SizeRequestMode

Enumeration.

• HEIGHT_FOR_WIDTH = 0 — Prefer height-for-width geometry management
• WIDTH_FOR_HEIGHT = 1 — Prefer width-for-height geometry management
• CONSTANT_SIZE = 2 — Don’t trade height-for-width or width-for-height

SortType

Enumeration.

• ASCENDING = 0 — Sorting is in ascending order.
• DESCENDING = 1 — Sorting is in descending order.

SorterChange

Enumeration.

• DIFFERENT = 0 — The sorter change cannot be described by any of the other enumeration values
• INVERTED = 1 — The sort order was inverted. Comparisons that returned Ordering.SMALLER now return Ordering.LARGER and vice versa. Other comparisons return the same values as before.
• LESS_STRICT = 2 — The sorter is less strict: Comparisons may now return Ordering.EQUAL that did not do so before.
• MORE_STRICT = 3 — The sorter is more strict: Comparisons that did return Ordering.EQUAL may not do so anymore.

SorterOrder

Enumeration.

• PARTIAL = 0 — A partial order. Any GtkOrdering is possible.
• NONE = 1 — No order, all elements are considered equal. Sorter.compare will only return Ordering.EQUAL.
• TOTAL = 2 — A total order. Sorter.compare will only return Ordering.EQUAL if an item is compared with itself. Two different items will never cause this value to be returned.

SpinButtonUpdatePolicy

Enumeration.

• ALWAYS = 0 — When refreshing your GtkSpinButton, the value is always displayed
• IF_VALID = 1 — When refreshing your GtkSpinButton, the value is only displayed if it is valid within the bounds of the spin button's adjustment

SpinType

Enumeration.

• STEP_FORWARD = 0 — Increment by the adjustments step increment.
• STEP_BACKWARD = 1 — Decrement by the adjustments step increment.
• PAGE_FORWARD = 2 — Increment by the adjustments page increment.
• PAGE_BACKWARD = 3 — Decrement by the adjustments page increment.
• HOME = 4 — Go to the adjustments lower bound.
• END = 5 — Go to the adjustments upper bound.
• USER_DEFINED = 6 — Change by a specified amount.

StackTransitionType

Enumeration.

• NONE = 0 — No transition
• CROSSFADE = 1 — A cross-fade
• SLIDE_RIGHT = 2 — Slide from left to right
• SLIDE_LEFT = 3 — Slide from right to left
• SLIDE_UP = 4 — Slide from bottom up
• SLIDE_DOWN = 5 — Slide from top down
• SLIDE_LEFT_RIGHT = 6 — Slide from left or right according to the children order
• SLIDE_UP_DOWN = 7 — Slide from top down or bottom up according to the order
• OVER_UP = 8 — Cover the old page by sliding up
• OVER_DOWN = 9 — Cover the old page by sliding down
• OVER_LEFT = 10 — Cover the old page by sliding to the left
• OVER_RIGHT = 11 — Cover the old page by sliding to the right
• UNDER_UP = 12 — Uncover the new page by sliding up
• UNDER_DOWN = 13 — Uncover the new page by sliding down
• UNDER_LEFT = 14 — Uncover the new page by sliding to the left
• UNDER_RIGHT = 15 — Uncover the new page by sliding to the right
• OVER_UP_DOWN = 16 — Cover the old page sliding up or uncover the new page sliding down, according to order
• OVER_DOWN_UP = 17 — Cover the old page sliding down or uncover the new page sliding up, according to order
• OVER_LEFT_RIGHT = 18 — Cover the old page sliding left or uncover the new page sliding right, according to order
• OVER_RIGHT_LEFT = 19 — Cover the old page sliding right or uncover the new page sliding left, according to order
• ROTATE_LEFT = 20 — Pretend the pages are sides of a cube and rotate that cube to the left
• ROTATE_RIGHT = 21 — Pretend the pages are sides of a cube and rotate that cube to the right
• ROTATE_LEFT_RIGHT = 22 — Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order

StateFlags

Bit flags.

• NORMAL = 0 — State during normal operation
• ACTIVE = 1 — Widget is active
• PRELIGHT = 2 — Widget has a mouse pointer over it
• SELECTED = 4 — Widget is selected
• INSENSITIVE = 8 — Widget is insensitive
• INCONSISTENT = 16 — Widget is inconsistent
• FOCUSED = 32 — Widget has the keyboard focus
• BACKDROP = 64 — Widget is in a background toplevel window
• DIR_LTR = 128 — Widget is in left-to-right text direction
• DIR_RTL = 256 — Widget is in right-to-left text direction
• LINK = 512 — Widget is a link
• VISITED = 1024 — The location the widget points to has already been visited
• CHECKED = 2048 — Widget is checked
• DROP_ACTIVE = 4096 — Widget is highlighted as a drop target for DND
• FOCUS_VISIBLE = 8192 — Widget has the visible focus
• FOCUS_WITHIN = 16384 — Widget contains the keyboard focus

StringFilterMatchMode

Enumeration.

• EXACT = 0 — The search string and text must match exactly
• SUBSTRING = 1 — The search string must be contained as a substring inside the text
• PREFIX = 2 — The text must begin with the search string

StyleContextPrintFlags

Bit flags.

• NONE = 0 — Default value.
• RECURSE = 1 — Print the entire tree of CSS nodes starting at the style context's node
• SHOW_STYLE = 2 — Show the values of the CSS properties for each node
• SHOW_CHANGE = 4 — Show information about what changes affect the styles

SvgError

Enumeration.

• INVALID_SYNTAX = 0 — The XML syntax is broken in some way
• INVALID_ELEMENT = 1 — An XML element is invalid (either because it is not part of SVG, or because it is in the wrong place, or because it not implemented in GTK)
• INVALID_ATTRIBUTE = 2 — An attribute is invalid (either because it is not part of SVG, or because it is not implemented in GTK, or its value is problematic)
• MISSING_ATTRIBUTE = 3 — A required attribute is missing
• INVALID_REFERENCE = 4 — A reference does not point to a suitable element
• FAILED_UPDATE = 5 — An animation could not be updated
• FAILED_RENDERING = 6 — Rendering is not according to expecations
• IGNORED_ELEMENT = 7 — An XML element is ignored, but it should not affect rendering (this error code is used for metadata and exension elements)
• LIMITS_EXCEEDED = 8 — An implementation limit has been hit, such as the number of loaded shapes.
• NOT_IMPLEMENTED = 9 — The SVG uses features that are not supported by GtkSvg. It may be advisable to use a different SVG renderer.

SvgFeatures

Bit flags.

• ANIMATIONS = 1 — Whether to run animations. If disabled, state changes are applied without transitions
• SYSTEM_RESOURCES = 2 — Whether to use system resources, such as fonts. If disabled, only embedded fonts are used
• EXTERNAL_RESOURCES = 4 — Whether to load external resources, such as images. If disabled, only embedded images are loaded
• EXTENSIONS = 8 — Whether to allow gpa extensions, such as states and transitions
• TRADITIONAL_SYMBOLIC = 16 — This feature is meant for compatibility with old symbolic icons. If this is enabled, fill and stroke attributes are ignored. The used colors are derived from symbolic style classes if present, and the default fill color is the symbolic foreground color.

SymbolicColor

Enumeration.

• FOREGROUND = 0 — The default foreground color
• ERROR = 1 — Indication color for errors
• WARNING = 2 — Indication color for warnings
• SUCCESS = 3 — Indication color for success
• ACCENT = 4 — The system accent color.

SystemSetting

Enumeration.

• DPI = 0 — the Settings.gtk-xft-dpi setting has changed
• FONT_NAME = 1 — The Settings.gtk-font-name setting has changed
• FONT_CONFIG = 2 — The font configuration has changed in a way that requires text to be redrawn. This can be any of the Settings.gtk-xft-antialias, Settings.gtk-xft-hinting, Settings.gtk-xft-hintstyle, Settings.gtk-xft-rgba or Settings.gtk-fontconfig-timestamp settings
• DISPLAY = 3 — The display has changed
• ICON_THEME = 4 — The icon theme has changed in a way that requires icons to be looked up again

TextBufferNotifyFlags

Bit flags.

• BEFORE_INSERT = 1 — Be notified before text is inserted into the underlying buffer.
• AFTER_INSERT = 2 — Be notified after text has been inserted into the underlying buffer.
• BEFORE_DELETE = 4 — Be notified before text is deleted from the underlying buffer.
• AFTER_DELETE = 8 — Be notified after text has been deleted from the underlying buffer.

TextDirection

Enumeration.

• NONE = 0 — No direction.
• LTR = 1 — Left to right text direction.
• RTL = 2 — Right to left text direction.

TextExtendSelection

Enumeration.

• WORD = 0 — Selects the current word. It is triggered by a double-click for example.
• LINE = 1 — Selects the current line. It is triggered by a triple-click for example.

TextSearchFlags

Bit flags.

• VISIBLE_ONLY = 1 — Search only visible data. A search match may have invisible text interspersed.
• TEXT_ONLY = 2 — Search only text. A match may have paintables or child widgets mixed inside the matched range.
• CASE_INSENSITIVE = 4 — The text will be matched regardless of what case it is in.

TextViewLayer

Enumeration.

• BELOW_TEXT = 0 — The layer rendered below the text (but above the background).
• ABOVE_TEXT = 1 — The layer rendered above the text.

TextWindowType

Enumeration.

• WIDGET = 1 — Window that floats over scrolling areas.
• TEXT = 2 — Scrollable text window.
• LEFT = 3 — Left side border window.
• RIGHT = 4 — Right side border window.
• TOP = 5 — Top border window.
• BOTTOM = 6 — Bottom border window.

TreeModelFlags

Bit flags.

• ITERS_PERSIST = 1 — iterators survive all signals emitted by the tree
• LIST_ONLY = 2 — the model is a list only, and never has children

TreeViewColumnSizing

Enumeration.

• GROW_ONLY = 0 — Columns only get bigger in reaction to changes in the model
• AUTOSIZE = 1 — Columns resize to be the optimal size every time the model changes.
• FIXED = 2 — Columns are a fixed numbers of pixels wide.

TreeViewDropPosition

Enumeration.

• BEFORE = 0 — dropped row is inserted before
• AFTER = 1 — dropped row is inserted after
• INTO_OR_BEFORE = 2 — dropped row becomes a child or is inserted before
• INTO_OR_AFTER = 3 — dropped row becomes a child or is inserted after

TreeViewGridLines

Enumeration.

• NONE = 0 — No grid lines.
• HORIZONTAL = 1 — Horizontal grid lines.
• VERTICAL = 2 — Vertical grid lines.
• BOTH = 3 — Horizontal and vertical grid lines.

Unit

Enumeration.

• NONE = 0 — No units.
• POINTS = 1 — Dimensions in points.
• INCH = 2 — Dimensions in inches.
• MM = 3 — Dimensions in millimeters

WindowGravity

Enumeration.

• TOP_LEFT = 0 — The top left corner
• TOP = 1 — The top edge
• TOP_RIGHT = 2 — The top right corner
• LEFT = 3 — The left edge
• CENTER = 4 — The center pointer
• RIGHT = 5 — The right edge
• BOTTOM_LEFT = 6 — The bottom left corner
• BOTTOM = 7 — the bottom edge
• BOTTOM_RIGHT = 8 — The bottom right corner
• TOP_START = 9 — The top left or top right corner, depending on the text direction
• TOP_END = 10 — The top right or top left corner, depending on the text direction
• START = 11 — The left or right edge, depending on the text direction
• END = 12 — The right or left edge, depending on the text direction
• BOTTOM_START = 13 — The bottom left or top right corner, depending on the text direction
• BOTTOM_END = 14 — The bottom right or top left corner, depending on the text direction

WrapMode

Enumeration.

• NONE = 0 — do not wrap lines; just make the text area wider
• CHAR = 1 — wrap text, breaking lines anywhere the cursor can appear (between characters, usually - if you want to be technical, between graphemes, see Pango.get_log_attrs)
• WORD = 2 — wrap text, breaking lines in between words
• WORD_CHAR = 3 — wrap text, breaking lines in between words, or if that is not enough, also between graphemes

Constants

ACCESSIBLE_ATTRIBUTE_BACKGROUND

ACCESSIBLE_ATTRIBUTE_BACKGROUND: str

An attribute for the background color, expressed as an RGB value encoded in a string using the format: {r8},{g8},{b8}.

ACCESSIBLE_ATTRIBUTE_FAMILY

ACCESSIBLE_ATTRIBUTE_FAMILY: str

An attribute for the font family name.

ACCESSIBLE_ATTRIBUTE_FOREGROUND

ACCESSIBLE_ATTRIBUTE_FOREGROUND: str

An attribute for the foreground color, expressed as an RGB value encoded in a string using the format: {r8},{g8},{b8}.

ACCESSIBLE_ATTRIBUTE_OVERLINE

ACCESSIBLE_ATTRIBUTE_OVERLINE: str

An attribute for the overline style.

Possible values are:

• ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE
• ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE

ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE

ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE: str

The "none" overline value for ACCESSIBLE_ATTRIBUTE_OVERLINE.

ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE

ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE: str

The "single" overline value for ACCESSIBLE_ATTRIBUTE_OVERLINE.

ACCESSIBLE_ATTRIBUTE_SIZE

ACCESSIBLE_ATTRIBUTE_SIZE: str

An attribute for the font size, expressed in points.

ACCESSIBLE_ATTRIBUTE_STRETCH

ACCESSIBLE_ATTRIBUTE_STRETCH: str

An attribute for the font stretch type.

Possible values are:

• ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED
• ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED
• ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED
• ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED

ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED

ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED: str

The "condensed" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED

ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED: str

The "expanded" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED

ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED: str

The "extra condensed" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED

ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED: str

The "extra expanded" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL

ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL: str

The "normal" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED

ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED: str

The "semi condensed" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED

ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED: str

The "semi expanded" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED

ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED: str

The "ultra condensed" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED

ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED: str

The "ultra expanded" stretch value for ACCESSIBLE_ATTRIBUTE_STRETCH.

ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH

ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH: str

An attribute for strikethrough text.

Possible values are true or false.

ACCESSIBLE_ATTRIBUTE_STYLE

ACCESSIBLE_ATTRIBUTE_STYLE: str

An attribute for the font style.

Possible values are:

• ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL
• ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE
• ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC

ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC

ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC: str

The "italic" style value for ACCESSIBLE_ATTRIBUTE_STYLE.

ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL

ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL: str

The "normal" style value for ACCESSIBLE_ATTRIBUTE_STYLE.

ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE

ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE: str

The "oblique" style value for ACCESSIBLE_ATTRIBUTE_STYLE.

ACCESSIBLE_ATTRIBUTE_UNDERLINE

ACCESSIBLE_ATTRIBUTE_UNDERLINE: str

An attribute for the underline style.

Possible values are:

• ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE
• ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE
• ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE
• ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR

ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE

ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE: str

The "double" underline value for ACCESSIBLE_ATTRIBUTE_UNDERLINE.

ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR

ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR: str

The "error" underline value for ACCESSIBLE_ATTRIBUTE_UNDERLINE.

ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE

ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE: str

The "none" underline value for ACCESSIBLE_ATTRIBUTE_UNDERLINE.

ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE

ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE: str

The "single" underline value for ACCESSIBLE_ATTRIBUTE_UNDERLINE.

ACCESSIBLE_ATTRIBUTE_VARIANT

ACCESSIBLE_ATTRIBUTE_VARIANT: str

An attribute for the font variant.

Possible values are:

• ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS
• ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS
• ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS
• ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS
• ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE
• ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS

ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS

ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS: str

The "all petite caps" variant value for ACCESSIBLE_ATTRIBUTE_VARIANT.

ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS

ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS: str

The "all small caps" variant value for ACCESSIBLE_ATTRIBUTE_VARIANT.

ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS

ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS: str

The "petite caps" variant value for ACCESSIBLE_ATTRIBUTE_VARIANT.

ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS

ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS: str

The "small caps" variant value for ACCESSIBLE_ATTRIBUTE_VARIANT.

ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS

ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS: str

The "title caps" variant value for ACCESSIBLE_ATTRIBUTE_VARIANT.

ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE

ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE: str

The "unicase" variant value for ACCESSIBLE_ATTRIBUTE_VARIANT.

ACCESSIBLE_ATTRIBUTE_WEIGHT

ACCESSIBLE_ATTRIBUTE_WEIGHT: str

An attribute for the font weight.

ACCESSIBLE_VALUE_UNDEFINED

ACCESSIBLE_VALUE_UNDEFINED: int

An undefined value. The accessible attribute is either unset, or its value is undefined.

BINARY_AGE

BINARY_AGE: int

Like get_binary_age, but from the headers used at application compile time, rather than from the library linked against at application run time.

IM_MODULE_EXTENSION_POINT_NAME

IM_MODULE_EXTENSION_POINT_NAME: str

The default name of the extension point.

INPUT_ERROR

INPUT_ERROR: int

Constant to return from a signal handler for the ::input signal in case of conversion failure.

See SpinButton.input.

INTERFACE_AGE

INTERFACE_AGE: int

Like get_interface_age, but from the headers used at application compile time, rather than from the library linked against at application run time.

INVALID_LIST_POSITION

INVALID_LIST_POSITION: int

The value used to refer to a guaranteed invalid position in a GListModel.

This value may be returned from some functions, others may accept it as input. Its interpretation may differ for different functions.

Refer to each function's documentation for if this value is allowed and what it does.

LEVEL_BAR_OFFSET_FULL

LEVEL_BAR_OFFSET_FULL: str

The name used for the stock full offset included by GtkLevelBar.

LEVEL_BAR_OFFSET_HIGH

LEVEL_BAR_OFFSET_HIGH: str

The name used for the stock high offset included by GtkLevelBar.

LEVEL_BAR_OFFSET_LOW

LEVEL_BAR_OFFSET_LOW: str

The name used for the stock low offset included by GtkLevelBar.

MAJOR_VERSION

MAJOR_VERSION: int

Like get_major_version, but from the headers used at application compile time, rather than from the library linked against at application run time.

MAX_COMPOSE_LEN

MAX_COMPOSE_LEN: int

Evaluates to the maximum length of a compose sequence.

This macro is longer used by GTK.

MEDIA_FILE_EXTENSION_POINT_NAME

MEDIA_FILE_EXTENSION_POINT_NAME: str

The default extension point name for media file.

MICRO_VERSION

MICRO_VERSION: int

Like get_micro_version, but from the headers used at application compile time, rather than from the library linked against at application run time.

MINOR_VERSION

MINOR_VERSION: int

Like get_minor_version, but from the headers used at application compile time, rather than from the library linked against at application run time.

PAPER_NAME_A3

PAPER_NAME_A3: str

Name for the A3 paper size.

PAPER_NAME_A4

PAPER_NAME_A4: str

Name for the A4 paper size.

PAPER_NAME_A5

PAPER_NAME_A5: str

Name for the A5 paper size.

PAPER_NAME_B5

PAPER_NAME_B5: str

Name for the B5 paper size.

PAPER_NAME_EXECUTIVE

PAPER_NAME_EXECUTIVE: str

Name for the Executive paper size.

PAPER_NAME_LEGAL

PAPER_NAME_LEGAL: str

Name for the Legal paper size.

PAPER_NAME_LETTER

PAPER_NAME_LETTER: str

Name for the Letter paper size.

PRINT_SETTINGS_COLLATE

PRINT_SETTINGS_COLLATE: str

The key used by the “Print to file” printer to store whether to collate the printed pages.

PRINT_SETTINGS_DEFAULT_SOURCE

PRINT_SETTINGS_DEFAULT_SOURCE: str

The key used by the “Print to file” printer to store the default source.

PRINT_SETTINGS_DITHER

PRINT_SETTINGS_DITHER: str

The key used by the “Print to file” printer to store the dither used.

PRINT_SETTINGS_DUPLEX

PRINT_SETTINGS_DUPLEX: str

The key used by the “Print to file” printer to store whether to print the output in duplex.

PRINT_SETTINGS_FINISHINGS

PRINT_SETTINGS_FINISHINGS: str

The key used by the “Print to file” printer to store the finishings.

PRINT_SETTINGS_MEDIA_TYPE

PRINT_SETTINGS_MEDIA_TYPE: str

The key used by the “Print to file” printer to store the media type.

The set of media types is defined in PWG 5101.1-2002 PWG.

PRINT_SETTINGS_NUMBER_UP

PRINT_SETTINGS_NUMBER_UP: str

The key used by the “Print to file” printer to store the number of pages per sheet.

PRINT_SETTINGS_NUMBER_UP_LAYOUT

PRINT_SETTINGS_NUMBER_UP_LAYOUT: str

The key used by the “Print to file” printer to store the number of pages per sheet in number-up mode.

PRINT_SETTINGS_N_COPIES

PRINT_SETTINGS_N_COPIES: str

The key used by the “Print to file” printer to store the number of copies.

PRINT_SETTINGS_ORIENTATION

PRINT_SETTINGS_ORIENTATION: str

The key used by the “Print to file” printer to store the orientation.

PRINT_SETTINGS_OUTPUT_BASENAME

PRINT_SETTINGS_OUTPUT_BASENAME: str

The key used by the “Print to file” printer to store the file name of the output without the path to the directory and the file extension.

PRINT_SETTINGS_OUTPUT_BIN

PRINT_SETTINGS_OUTPUT_BIN: str

The key used by the “Print to file” printer to store the output bin.

PRINT_SETTINGS_OUTPUT_DIR

PRINT_SETTINGS_OUTPUT_DIR: str

The key used by the “Print to file” printer to store the directory to which the output should be written.

PRINT_SETTINGS_OUTPUT_FILE_FORMAT

PRINT_SETTINGS_OUTPUT_FILE_FORMAT: str

The key used by the “Print to file” printer to store the format of the output. The supported values are “PS” and “PDF”.

PRINT_SETTINGS_OUTPUT_URI

PRINT_SETTINGS_OUTPUT_URI: str

The key used by the “Print to file” printer to store the URI to which the output should be written. GTK itself supports only “file://” URIs.

PRINT_SETTINGS_PAGE_RANGES

PRINT_SETTINGS_PAGE_RANGES: str

The key used by the “Print to file” printer to store the array of page ranges to print.

PRINT_SETTINGS_PAGE_SET

PRINT_SETTINGS_PAGE_SET: str

The key used by the “Print to file” printer to store the set of pages to print.

PRINT_SETTINGS_PAPER_FORMAT

PRINT_SETTINGS_PAPER_FORMAT: str

The key used by the “Print to file” printer to store the page format.

PRINT_SETTINGS_PAPER_HEIGHT

PRINT_SETTINGS_PAPER_HEIGHT: str

The key used by the “Print to file” printer to store the page height.

PRINT_SETTINGS_PAPER_WIDTH

PRINT_SETTINGS_PAPER_WIDTH: str

The key used by the “Print to file” printer to store the paper width.

PRINT_SETTINGS_PRINTER

PRINT_SETTINGS_PRINTER: str

The key used by the “Print to file” printer to store the printer name.

PRINT_SETTINGS_PRINTER_LPI

PRINT_SETTINGS_PRINTER_LPI: str

The key used by the “Print to file” printer to store the resolution in lines per inch.

PRINT_SETTINGS_PRINT_PAGES

PRINT_SETTINGS_PRINT_PAGES: str

The key used by the “Print to file” printer to store which pages to print.

PRINT_SETTINGS_QUALITY

PRINT_SETTINGS_QUALITY: str

The key used by the “Print to file” printer to store the printing quality.

PRINT_SETTINGS_RESOLUTION

PRINT_SETTINGS_RESOLUTION: str

The key used by the “Print to file” printer to store the resolution in DPI.

PRINT_SETTINGS_RESOLUTION_X

PRINT_SETTINGS_RESOLUTION_X: str

The key used by the “Print to file” printer to store the horizontal resolution in DPI.

PRINT_SETTINGS_RESOLUTION_Y

PRINT_SETTINGS_RESOLUTION_Y: str

The key used by the “Print to file” printer to store the vertical resolution in DPI.

PRINT_SETTINGS_REVERSE

PRINT_SETTINGS_REVERSE: str

The key used by the “Print to file” printer to store whether to reverse the order of the printed pages.

PRINT_SETTINGS_SCALE

PRINT_SETTINGS_SCALE: str

The key used by the “Print to file” printer to store the scale.

PRINT_SETTINGS_USE_COLOR

PRINT_SETTINGS_USE_COLOR: str

The key used by the “Print to file” printer to store whether to print with colors.

PRINT_SETTINGS_WIN32_DRIVER_EXTRA

PRINT_SETTINGS_WIN32_DRIVER_EXTRA: str

The key used by the “Print to file” printer to store 32-bit Windows extra driver.

PRINT_SETTINGS_WIN32_DRIVER_VERSION

PRINT_SETTINGS_WIN32_DRIVER_VERSION: str

The key used by the “Print to file” printer to store the 32-bit Windows driver version.

PRIORITY_RESIZE

PRIORITY_RESIZE: int

Use this priority for functionality related to size allocation.

It is used internally by GTK+ to compute the sizes of widgets. This priority is higher than Gdk.PRIORITY_REDRAW to avoid resizing a widget which was just redrawn.

STYLE_PROVIDER_PRIORITY_APPLICATION

STYLE_PROVIDER_PRIORITY_APPLICATION: int

A priority that can be used when adding a GtkStyleProvider for application-specific style information.

STYLE_PROVIDER_PRIORITY_FALLBACK

STYLE_PROVIDER_PRIORITY_FALLBACK: int

The priority used for default style information that is used in the absence of themes.

Note that this is not very useful for providing default styling for custom style classes - themes are likely to override styling provided at this priority with catch-all * {...} rules.

STYLE_PROVIDER_PRIORITY_SETTINGS

STYLE_PROVIDER_PRIORITY_SETTINGS: int

The priority used for style information provided via GtkSettings.

This priority is higher than STYLE_PROVIDER_PRIORITY_THEME to let settings override themes.

STYLE_PROVIDER_PRIORITY_THEME

STYLE_PROVIDER_PRIORITY_THEME: int

The priority used for style information provided by themes.

STYLE_PROVIDER_PRIORITY_USER

STYLE_PROVIDER_PRIORITY_USER: int

The priority used for the style information from $XDG_CONFIG_HOME/gtk-4.0/gtk.css.

You should not use priorities higher than this, to give the user the last word.

SVG_DEFAULT_FEATURES

SVG_DEFAULT_FEATURES: int

The GtkSvgFeatures that are enabled by default.

TEXT_VIEW_PRIORITY_VALIDATE

TEXT_VIEW_PRIORITY_VALIDATE: int

The priority at which the text view validates onscreen lines in an idle job in the background.

TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID

TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: int

Uses the default sort function in a TreeSortable.

See also: TreeSortable.set_sort_column_id

TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID

TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: int

Disables sorting in a TreeSortable.

See also: TreeSortable.set_sort_column_id

Callbacks

AssistantPageFunc

AssistantPageFunc = Callable[[current_page: int], int]

CellAllocCallback

CellAllocCallback = Callable[[renderer: CellRenderer, cell_area: Gdk.Rectangle, cell_background: Gdk.Rectangle], bool]

CellCallback

CellCallback = Callable[[renderer: CellRenderer], bool]

CellLayoutDataFunc

CellLayoutDataFunc = Callable[[cell_layout: CellLayout, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter], None]

CustomAllocateFunc

CustomAllocateFunc = Callable[[widget: Widget, width: int, height: int, baseline: int], None]

CustomFilterFunc

CustomFilterFunc = Callable[[item: GObject.Object], bool]

CustomMeasureFunc

CustomMeasureFunc = Callable[[widget: Widget, orientation: Orientation | int, for_size: int], None]

CustomRequestModeFunc

CustomRequestModeFunc = Callable[[widget: Widget], SizeRequestMode | int]

DrawingAreaDrawFunc

DrawingAreaDrawFunc = Callable[[drawing_area: DrawingArea, cr: cairo.Context[cairo.Surface], width: int, height: int], None]

EntryCompletionMatchFunc

EntryCompletionMatchFunc = Callable[[completion: EntryCompletion, key: str, iter: TreeIter], bool]

ExpressionNotify

ExpressionNotify = Callable[[], None]

FlowBoxCreateWidgetFunc

FlowBoxCreateWidgetFunc = Callable[[item: GObject.Object], Widget]

FlowBoxFilterFunc

FlowBoxFilterFunc = Callable[[child: FlowBoxChild], bool]

FlowBoxForeachFunc

FlowBoxForeachFunc = Callable[[box: FlowBox, child: FlowBoxChild], None]

FlowBoxSortFunc

FlowBoxSortFunc = Callable[[child1: FlowBoxChild, child2: FlowBoxChild], int]

FontFilterFunc

FontFilterFunc = Callable[[family: Pango.FontFamily, face: Pango.FontFace], bool]

IconViewForeachFunc

IconViewForeachFunc = Callable[[icon_view: IconView, path: TreePath], None]

ListBoxCreateWidgetFunc

ListBoxCreateWidgetFunc = Callable[[item: GObject.Object], Widget]

ListBoxFilterFunc

ListBoxFilterFunc = Callable[[row: ListBoxRow], bool]

ListBoxForeachFunc

ListBoxForeachFunc = Callable[[box: ListBox, row: ListBoxRow], None]

ListBoxSortFunc

ListBoxSortFunc = Callable[[row1: ListBoxRow, row2: ListBoxRow], int]

ListBoxUpdateHeaderFunc

ListBoxUpdateHeaderFunc = Callable[[row: ListBoxRow, before: ListBoxRow | None], None]

MapListModelMapFunc

MapListModelMapFunc = Callable[[item: GObject.Object], GObject.Object]

MenuButtonCreatePopupFunc

MenuButtonCreatePopupFunc = Callable[[menu_button: MenuButton], None]

PageSetupDoneFunc

PageSetupDoneFunc = Callable[[page_setup: PageSetup], None]

PrintJobCompleteFunc

PrintJobCompleteFunc = Callable[[print_job: PrintJob, error: GLib.Error], None]

PrintSettingsFunc

PrintSettingsFunc = Callable[[key: str, value: str], None]

PrinterFunc

PrinterFunc = Callable[[printer: Printer], bool]

ScaleFormatValueFunc

ScaleFormatValueFunc = Callable[[scale: Scale, value: float], str]

ShortcutFunc

ShortcutFunc = Callable[[widget: Widget, args: GLib.Variant | None], bool]

TextBufferCommitNotify

TextBufferCommitNotify = Callable[[buffer: TextBuffer, flags: TextBufferNotifyFlags | int, position: int, length: int], None]

TextCharPredicate

TextCharPredicate = Callable[[ch: str], bool]

TextTagTableForeach

TextTagTableForeach = Callable[[tag: TextTag], None]

TickCallback

TickCallback = Callable[[widget: Widget, frame_clock: Gdk.FrameClock], bool]

TreeCellDataFunc

TreeCellDataFunc = Callable[[tree_column: TreeViewColumn, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter], None]

TreeIterCompareFunc

TreeIterCompareFunc = Callable[[model: TreeModel, a: TreeIter, b: TreeIter], int]

TreeListModelCreateModelFunc

TreeListModelCreateModelFunc = Callable[[item: GObject.Object], Gio.ListModel]

TreeModelFilterModifyFunc

TreeModelFilterModifyFunc = Callable[[model: TreeModel, iter: TreeIter, column: int], None]

TreeModelFilterVisibleFunc

TreeModelFilterVisibleFunc = Callable[[model: TreeModel, iter: TreeIter], bool]

TreeModelForeachFunc

TreeModelForeachFunc = Callable[[model: TreeModel, path: TreePath, iter: TreeIter], bool]

TreeSelectionForeachFunc

TreeSelectionForeachFunc = Callable[[model: TreeModel, path: TreePath, iter: TreeIter], None]

TreeSelectionFunc

TreeSelectionFunc = Callable[[selection: TreeSelection, model: TreeModel, path: TreePath, path_currently_selected: bool], bool]

TreeViewColumnDropFunc

TreeViewColumnDropFunc = Callable[[tree_view: TreeView, column: TreeViewColumn, prev_column: TreeViewColumn, next_column: TreeViewColumn], bool]

TreeViewMappingFunc

TreeViewMappingFunc = Callable[[tree_view: TreeView, path: TreePath], None]

TreeViewRowSeparatorFunc

TreeViewRowSeparatorFunc = Callable[[model: TreeModel, iter: TreeIter], bool]

TreeViewSearchEqualFunc

TreeViewSearchEqualFunc = Callable[[model: TreeModel, column: int, key: str, iter: TreeIter], bool]

WidgetActionActivateFunc

WidgetActionActivateFunc = Callable[[widget: Widget, action_name: str, parameter: GLib.Variant | None], None]