Expand description
Rust GTK 4 bindings
The project website is here.
Rust bindings of GTK 4, part of gtk4-rs.
This library contains safe Rust bindings for GTK 4, a multi-platform GUI toolkit. It is a part of gtk-rs.
Most of this documentation is generated from the C API. Until all parts of the documentation have been reviewed there will be incongruities with the actual Rust API.
For a gentle introduction to gtk-rs we recommend the online book GUI development with Rust and GTK 4.
See also:
- gtk-rs project overview
- General
GLibfamily types and object system overview - GTK documentation
- GTK Visual Index
Minimum supported Rust version
Currently, the minimum supported Rust version is 1.63.0.
“Hello, World!” example program
GTK needs to be initialized before use by calling init. Creating an
Application will call init for you.
The gtk4 crate is usually renamed to gtk. You can find an example in
the features section for how to do this globally in your Cargo.toml.
use gtk4 as gtk;
use gtk::prelude::*;
use gtk::{Application, ApplicationWindow};
fn main() {
let app = Application::builder()
.application_id("org.example.HelloWorld")
.build();
app.connect_activate(|app| {
// We create the main window.
let window = ApplicationWindow::builder()
.application(app)
.default_width(320)
.default_height(200)
.title("Hello, World!")
.build();
// Show the window.
window.show();
});
app.run();
}The main loop
In a typical GTK application you set up the UI, assign signal handlers and run the main event loop.
use gtk4 as gtk;
use gtk::prelude::*;
use gtk::{Application, ApplicationWindow, Button};
fn main() {
let application = Application::builder()
.application_id("com.example.FirstGtkApp")
.build();
application.connect_activate(|app| {
let window = ApplicationWindow::builder()
.application(app)
.title("First GTK Program")
.default_width(350)
.default_height(70)
.build();
let button = Button::with_label("Click me!");
button.connect_clicked(|_| {
eprintln!("Clicked!");
});
window.set_child(Some(&button));
window.show();
});
application.run();
}Threads
GTK is not thread-safe. Accordingly, none of this crate’s structs implement
Send or Sync.
The thread where init was called is considered the main thread. OS X has
its own notion of the main thread and init must be called on that thread.
After successful initialization, calling any gtk or gdk
functions (including init) from other threads will panic.
Any thread can schedule a closure to be run by the main loop on the main
thread via glib::idle_add or
glib::timeout_add. While
working with GTK you might need the glib::idle_add_local
or glib::timeout_add_local version without the
Send bound. Those may only be called from the main thread.
Panics
The gtk and gdk crates have some run-time safety and contract
checks.
-
Any constructor or free function will panic if called before
initor on a non-main thread. -
Any
&stror&Pathparameter with an interior null (\0) character will cause a panic. -
Some functions will panic if supplied out-of-range integer parameters. All such cases will be documented individually but they are not yet.
-
A panic in a closure that handles signals or in any other closure passed to a
gtkfunction will abort the process.
Features
Library versions
By default this crate provides only GTK 4.0 APIs. You can access additional
functionality by selecting one of the v4_2, v4_4, etc. features.
Cargo.toml example:
[dependencies.gtk]
package = "gtk4"
version = "0.x.y"
features = ["v4_2"]
Take care when choosing the version to target: some of your users might not have easy access to the latest ones. The higher the version, the fewer users will have it installed.
Documentation
- The Rust API Stable/Development
- Book Stable/Development
- Examples
- The C API
- GTK Installation Instructions
Using
We recommend using crates from crates.io, as demonstrated here.
If you want to track the bleeding edge, use the git dependency instead:
[dependencies]
gtk = { git = "https://github.com/gtk-rs/gtk4-rs.git", package = "gtk4" }
Avoid mixing versioned and git crates like this:
# This will not compile
[dependencies]
gdk = {version = "0.1", package = "gdk4"}
gtk = { git = "https://github.com/gtk-rs/gtk4-rs.git", package = "gtk4" }
Features
| Feature | Description |
|---|---|
v4_10 | Enable the new APIs part of the to be released GTK 4.10 |
v4_8 | Enable the new APIs part of GTK 4.8 |
v4_6 | Enable the new APIs part of GTK 4.6 |
v4_4 | Enable the new APIs part of GTK 4.4 |
v4_2 | Enable the new APIs part of GTK 4.2 |
gnome_43 | Enable all version feature flags of this crate and its dependencies to match the GNOME 43 SDK |
gnome_42 | Enable all version feature flags of this crate and its dependencies to match the GNOME 42 SDK |
unsafe-assume-initialized | Disable checks that gtk is initialized, for use in C ABI libraries |
xml_validation | Enable xml_validation feature of gtk4-macros |
See Also
License
The Rust bindings of gtk4 are available under the MIT License, please refer to it.
Re-exports
pub use ffi;pub use cairo;pub use gdk;pub use gdk_pixbuf;pub use gio;pub use glib;pub use graphene;pub use gsk;pub use pango;pub use subclass::widget::TemplateChild;Modules
Builder pattern types.
Traits intended for blanket imports.
Traits intended for creating custom types.
Structs
ATContext is an abstract class provided by GTK to communicate to
platform-specific assistive technologies API.The
AboutDialog offers a simple way to display information about
a program.Accessible is an interface for describing UI elements for
Assistive Technologies.AccessibleRange
v4_10This interface describes ranged controls, e.g. controls which have a single
value within an allowed range and that can optionally be changed by the user.
The
Actionable interface provides a convenient way of asscociating
widgets with actions.A
ShortcutAction that calls gtk_widget_activate().Adjustment is a model for a numeric value.AlertDialog
v4_10A
AlertDialog object collects the arguments that
are needed to present a message to the user.A
ShortcutTrigger that combines two triggers.The application selection widgets should be
implemented according to the design of each platform and/or
application requiring them.
AppChooser is an interface for widgets which allow the user to
choose an application.The application selection widgets should be
implemented according to the design of each platform and/or
application requiring them.
The
AppChooserButton lets the user select an application.The application selection widgets should be
implemented according to the design of each platform and/or
application requiring them.
AppChooserDialog shows a AppChooserWidget inside a Dialog.The application selection widgets should be
implemented according to the design of each platform and/or
application requiring them.
AppChooserWidget is a widget for selecting applications.Application is a high-level API for writing applications.Types of user actions that may be blocked by
Application.AspectFrame preserves the aspect ratio of its child.AssistantPage is an auxiliary object used by `GtkAssistant.BinLayout is a LayoutManager subclass useful for create “bins” of
widgets.An opaque, stack-allocated struct for iterating
over the elements of a
Bitset.BookmarkList is a list model that wraps GBookmarkFile.BoolFilter evaluates a boolean Expression
to determine whether to include items.A struct that specifies a border around a rectangular area.
The list of flags that can be passed to gtk_builder_create_closure().
BuilderListItemFactory is a ListItemFactory that creates
widgets by instantiating Builder UI templates.An implementation of
BuilderScope that can bind Rust callbacks.BuilderScope is an interface to provide language binding support
to Builder.The
Button widget is generally used to trigger a callback function that is
called when the button is pressed.A
ShortcutAction that invokes a callback.List views use widgets for displaying their
contents
An abstract class for laying out
CellRenderersList views use widgets for displaying their
contents
A cell area that renders GtkCellRenderers into a row or a column
Stores geometrical information for a series of rows in a GtkCellArea
List views use widgets for displaying their
contents. See
Editable for editable text widgets
Interface for widgets that can be used for editing cellsList views use widgets to display their contents.
See
LayoutManager for layout manager delegate objects
An interface for packing cellsList views use widgets for displaying their
contents
An object for rendering a single cell
Applications editing keyboard accelerators should
provide their own implementation according to platform design
guidelines
Renders a keyboard accelerator in a cell
List views use widgets to display their contents. You
should use
DropDown instead
Renders a combobox in a cellList views use widgets to display their contents.
You should use
ProgressBar instead
Renders numbers as progress barsList views use widgets to display their contents.
You should use
SpinButton instead
Renders a spin button in a cellList views use widgets to display their contents.
You should use
Spinner instead
Renders a spinning animation in a cellTells how a cell is to be rendered.
List views use widgets to display their contents.
You should use
Inscription or Label instead
Renders text in a cellList views use widgets to display their contents.
You should use
ToggleButton instead
Renders a toggle button in a cellList views use widgets to display their contents.
You can use
Box instead
A widget displaying a single row of a GtkTreeModelCenterBox arranges three children in a row, keeping the middle child
centered as well as possible.CenterLayout is a layout manager that manages up to three children.A
CheckButton places a label next to an indicator.An expression using a custom
GClosure to compute the value from
its parameters.Use
ColorDialogButton instead
The ColorButton allows to open a color chooser dialog to change
the color.Use
ColorDialog and ColorDialogButton
instead of widgets implementing ColorChooser
ColorChooser is an interface that is implemented by widgets
for choosing colors.Use
ColorDialog instead
A dialog for choosing a color.Direct use of
ColorChooserWidget is deprecated.
The ColorChooserWidget widget lets the user select a color.ColorDialog
v4_10A
ColorDialog object collects the arguments that
are needed to present a color chooser dialog to the
user, such as a title for the dialog and whether it
should be modal.ColorDialogButton
v4_10The
ColorDialogButton is a wrapped around a ColorDialog
and allows to open a color chooser dialog to change the color.ColumnView presents a large dynamic list of items using multiple columns
with headers.ColumnViewColumn represents the columns being added to ColumnView.ColumnViewSorter
v4_10ColumnViewSorter is a sorter implementation that
is geared towards the needs of ColumnView.Use
DropDown with a StringList
instead
A ComboBoxText is a simple variant of ComboBox for text-only
use cases.A constant value in a
Expression.Constraint describes a constraint between attributes of two widgets,
expressed as a linear equation.A
ConstraintGuide is an invisible layout element in a
ConstraintLayout.A layout manager using constraints to describe relations between widgets.
LayoutChild subclass for children in a ConstraintLayout.The
ConstraintTarget interface is implemented by objects that
can be used as source or target in Constraints.Represents a location in a file or other source of data parsed
by the CSS engine.
CssProvider is an object implementing the StyleProvider interface
for CSS.Defines a part of a CSS document.
CustomFilter determines whether to include items with a callback.CustomSorter is a Sorter implementation that sorts via a callback
function.Flags to use with gtk_set_debug_flags().
Dialogs are a convenient way to prompt the user for a small amount
of input.
Flags used to influence dialog construction.
DirectoryList is a list model that wraps g_file_enumerate_children_async().DragSource is an event controller to initiate Drag-And-Drop operations.DrawingArea is a widget that allows drawing with cairo.DropControllerMotion is an event controller tracking
the pointer during Drag-and-Drop operations.DropTarget is an event controller to receive Drag-and-Drop operations.DropTargetAsync is an event controller to receive Drag-and-Drop
operations, asynchronously.A
EditableLabel is a label that allows users to
edit the text by switching to an “edit mode”.The
EmojiChooser is used by text widgets such as Entry or
TextView to let users insert Emoji characters.A
EntryBuffer hold the text displayed in a Text widget.EntryCompletion is an auxiliary object to provide completion functionality
for Entry.EventController is the base class for event controllers.EventControllerFocus is an event controller to keep track of
keyboard focus.EventControllerKey is an event controller that provides access
to key events.EventControllerLegacy is an event controller that provides raw
access to the event stream.EventControllerMotion is an event controller tracking the pointer
position.EventControllerScroll is an event controller that handles scroll
events.Describes the behavior of a
EventControllerScroll.EveryFilter matches an item when each of its filters matches.Expression provides a way to describe references to values.An opaque structure representing a watched
Expression.Use
FileDialog instead
FileChooser is an interface that can be implemented by file
selection widgets.Use
FileDialog instead
FileChooserDialog is a dialog suitable for use with
“File Open” or “File Save” commands.Use
FileDialog instead
FileChooserNative is an abstraction of a dialog suitable
for use with “File Open” or “File Save as” commands.Direct use of
FileChooserWidget is deprecated
FileChooserWidget is a widget for choosing files.FileDialog
v4_10A
FileDialog object collects the arguments that
are needed to present a file chooser dialog to the
user, such as a title for the dialog and whether it
should be modal.FileFilter filters files by name or mime type.FileLauncher
v4_10A
FileLauncher object collects the arguments that are needed to open a uri
with an application.A
Filter object describes the filtering to be performed by a
FilterListModel.FilterListModel is a list model that filters the elements of
the underlying model according to a Filter.FixedLayout is a layout manager which can place child widgets
at fixed positions.LayoutChild subclass for children in a FixedLayout.FlattenListModel is a list model that concatenates other list models.FlowBoxChild is the kind of widget that can be added to a FlowBox.Use
FontDialogButton instead
The FontButton allows to open a font chooser dialog to change
the font.Use
FontDialog and FontDialogButton
instead
FontChooser is an interface that can be implemented by widgets
for choosing fonts.Use
FontDialog instead
The FontChooserDialog widget is a dialog for selecting a font.Specifies the granularity of font selection
that is desired in a
FontChooser.Direct use of
FontChooserWidget is deprecated.
The FontChooserWidget widget lets the user select a font.FontDialog
v4_10A
FontDialog object collects the arguments that
are needed to present a font chooser dialog to the
user, such as a title for the dialog and whether it
should be modal.FontDialogButton
v4_10The
FontDialogButton is wrapped around a FontDialog
and allows to open a font chooser dialog to change the font.GestureClick is a Gesture implementation for clicks.GestureDrag is a Gesture implementation for drags.GestureLongPress is a Gesture for long presses.GesturePan is a Gesture for pan gestures.GestureRotate is a Gesture for 2-finger rotations.GestureSingle is a GtkGestures subclass optimized for singe-touch
and mouse gestures.GestureStylus is a Gesture specific to stylus input.GestureSwipe is a Gesture for swipe gestures.GestureZoom is a Gesture for 2-finger pinch/zoom gestures.GridLayout is a layout manager which arranges child widgets in
rows and columns.LayoutChild subclass for children in a GridLayout.IMContextSimple is an input method supporting table-based input methods.IMMulticontext is an input method context supporting multiple,
switchable input methods.Used to specify options for gtk_icon_theme_lookup_icon().
Contains information found when looking up an icon in
IconTheme.Whether to propagate the signal to the default handler.
Describes hints that might be taken into account by input methods
or applications.
Inscription
v4_8Inscription is a widget to show text in a predefined area.A
ShortcutTrigger that triggers when a specific keyval and modifiers are pressed.LayoutChild is the base class for objects that are meant to hold
layout properties.Layout managers are delegate classes that handle the preferred size
and the allocation of a widget.
A
LinkButton is a button with a hyperlink.ListBoxRow is the kind of widget that can be added to a ListBox.A
ListItemFactory creates widgets for the items taken from a GListModel.LockButton is a widget to obtain and revoke authorizations
needed to operate the controls.A
MapListModel maps the items in a list model to different items.MediaControls is a widget to show controls for a video.MediaFile implements MediaStream for files.MediaStream is the integration point for media playback inside GTK.The
MenuButton widget is used to display a popup when clicked.Use
AlertDialog instead
MessageDialog presents a dialog with some message text.A
ShortcutAction that calls gtk_widget_mnemonic_activate().A
ShortcutTrigger that triggers when a specific mnemonic is pressed.MountOperation is an implementation of GMountOperation.MultiFilter is the base class for filters that combine multiple filters.MultiSelection is a SelectionModel that allows selecting multiple
elements.MultiSorter combines multiple sorters by trying them
in turn.A
ShortcutAction that activates an action by name.Native is the interface implemented by all widgets that have
their own gdk::Surface.Native dialogs are platform dialogs that don’t use
Dialog.A
ShortcutTrigger that never triggers.NoSelection is a SelectionModel that does not allow selecting
anything.NotebookPage is an auxiliary object used by Notebook.A
ShortcutAction that does nothing.NumericSorter is a Sorter that compares numbers.A
GObject value in a Expression.The
Orientable interface is implemented by all widgets that can be
oriented horizontally or vertically.Overlay is a container which contains a single main child, on top
of which it can place “overlay” widgets.OverlayLayout is the layout manager used by Overlay.LayoutChild subclass for children in a OverlayLayout.Struct defining a pad action entry.
PadController is an event controller for the pads found in drawing
tablets.A range of pages to print.
PageSetupUnixDialogLinux
PageSetupUnixDialog implements a page setup dialog for platforms
which don’t provide a native page setup dialog, like Unix.A widget with two panes, arranged either horizontally or vertically.
A
GParamSpec for properties holding a Expression.PasswordEntry is an entry that has been tailored for entering secrets.A
EntryBuffer that locks the underlying memory to prevent it
from being swapped to disk.Flags that influence the behavior of
WidgetExt::pick().The
Picture widget displays a gdk::Paintable.PopoverMenu is a subclass of Popover that implements menu
behavior.PopoverMenuBar presents a horizontal bar of items that pop
up popover menus when clicked.Flags that affect how popover menus are created from
a menu model.
PrintCapabilitiesLinux
Specifies which features the print dialog should offer.
A
PrintContext encapsulates context information that is required when
drawing pages for printing.PrintOperation is the high-level, portable printing API.PrintOperationPreview is the interface that is used to
implement print preview.A
PrintSettings object represents the settings of a print dialog in
a system-independent way.PrintUnixDialogLinux
PrintUnixDialog implements a print dialog for platforms
which don’t provide a native print dialog, like Unix.ProgressBar is typically used to display the progress of a long
running operation.A
GObject property value in a Expression.Meta-data to be passed to gtk_recent_manager_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.A
Requisition represents the desired size of a widget. See
GtkWidget’s geometry management section for
more information.ScaleButton provides a button which pops up a scale widget.Scrollable is an interface for widgets with native scrolling ability.ScrolledWindow is a container that makes its child scrollable.SearchEntry is an entry widget that has been tailored for use
as a search entry.SelectionFilterModel is a list model that presents the selection from
a SelectionModel.SelectionModel is an interface that add support for selection to list models.ShortcutAction encodes an action that can be triggered by a
keyboard shortcut.List of flags that can be passed to action activation.
ShortcutController is an event controller that manages shortcuts.ShortcutLabel displays a single keyboard shortcut or gesture.The
ShortcutManager interface is used to implement
shortcut scopes.ShortcutTrigger tracks how a Shortcut should be activated.A
ShortcutsGroup represents a group of related keyboard shortcuts
or gestures.A
ShortcutsSection collects all the keyboard shortcuts and gestures
for a major application mode.A
ShortcutsShortcut represents a single keyboard shortcut or gesture
with a short text.A
ShortcutsWindow shows information about the keyboard shortcuts
and gestures of an application.A
ShortcutAction that emits a signal.SignalListItemFactory is a ListItemFactory that emits signals
to to manage listitems.SingleSelection is a SelectionModel that allows selecting a single
item.SliceListModel is a list model that presents a slice of another model.Snapshot assists in creating gsk::RenderNodes for widgets.A
GListModel that sorts the elements of an underlying model
according to a Sorter.A
SpinButton is an ideal way to allow the user to set the
value of some attribute.A
StackSidebar uses a sidebar to switch between Stack pages.The
StackSwitcher shows a row of buttons to switch between Stack
pages.Describes a widget state.
StringFilter determines whether to include items by comparing
strings to a fixed search term.StringList is a list model that wraps an array of strings.StringObject is the type of items in a StringList.StringSorter is a Sorter that compares strings.The relevant API has been moved to
Widget
where applicable; otherwise, there is no replacement for querying the
style machinery. Stylable UI elements should use widgets.
StyleContext stores styling information affecting a widget.Flags that modify the behavior of gtk_style_context_to_string().
StyleProvider is an interface for style information used by
StyleContext.SymbolicPaintable is an interface that support symbolic colors in
paintables.Stores text and attributes for display in a
TextView.A
TextChildAnchor is a spot in a TextBuffer where child widgets can
be “anchored”.An iterator for the contents of a
TextBuffer.Flags affecting how a search is done.
A tag that can be applied to text contained in a
TextBuffer.The collection of tags in a
TextBufferA widget that displays the contents of a
TextBuffer.A
ToggleButton is a button which remains “pressed-in” when
clicked.List views use widgets to display their contents.
You can use
DropTarget to implement a drop destination
Interface for Drag-and-Drop destinations in TreeView.List views use widgets to display their contents.
You can use
DragSource to implement a drag source
Interface for Drag-and-Drop destinations in TreeView.TreeExpander is a widget that provides an expander for a list.TreeListModel is a list model that can create child models on demand.TreeListRow is used by TreeListModel to represent items.TreeListRowSorter is a special-purpose sorter that will apply a given
sorter to the levels in a tree.Use
gio::ListModel instead
The tree interface used by GtkTreeViewUse
FilterListModel instead.
A TreeModel which hides parts of an underlying tree modelThese flags indicate various properties of a
TreeModel.Use
SortListModel instead
A GtkTreeModel which makes an underlying tree model sortableAn opaque structure representing a path to a row in a model.
A GtkTreeRowReference tracks model changes so that it always refers to the
same row (a
TreePath refers to a position, not a fixed row). Create a
new GtkTreeRowReference with gtk_tree_row_reference_new().Use
SelectionModel instead
The selection object for GtkTreeViewThere is no replacement for this interface. You should
use
SortListModel to wrap your list model instead
The interface for sortable models used by GtkTreeViewUse
TreeListModel instead
A tree-like data structure that can be used with the TreeView.Use
ListView for lists, and ColumnView
for tabular lists
A widget for displaying both trees and listsUse
ColumnView and ColumnViewColumn
instead of TreeView to show a tabular list
A visible column in a TreeView widgetVideo is a widget to show a MediaStream with media controls.VolumeButton is a ScaleButton subclass tailored for
volume control.The base class for all widgets.
WidgetPaintable is a gdk::Paintable that displays the contents
of a widget.WindowControls shows window frame controls.WindowGroup makes group of windows behave like separate applications.WindowHandle is a titlebar area widget.Enums
The possible values for the
AccessibleProperty::Autocomplete
accessible property.The possible values for the
AccessibleState::Invalid
accessible state.The possible accessible properties of a
Accessible.The possible accessible relations of a
Accessible.The accessible role for a
Accessible implementation.The possible values for the
AccessibleProperty::Sort
accessible property.The possible accessible states of a
Accessible.The possible values for the
AccessibleState::Pressed
accessible state.Controls how a widget deals with extra space in a single dimension.
Used to indicate the direction in which an arrow should point.
Determines the page role inside a
Assistant.Baseline position in a row of widgets.
Describes how the border of a UI element should be rendered.
Error codes that identify various errors that can occur while using
Builder.Prebuilt sets of buttons for
Dialog.The available modes for
property::CellRendererAccel::accel-mode.Identifies how the user can interact with a particular cell.
Collation
v4_10Describes how a
StringSorter turns strings into sort keys to
compare them.The widget attributes that can be used when creating a
Constraint.The relation between two terms of a constraint.
The strength of a constraint, expressed as a symbolic constant.
Domain for VFL parsing errors.
ContentFit
v4_8Controls how a content should be made to fit inside an allocation.
Specifies which corner a child widget should be placed in when packed into
a
ScrolledWindowErrors that can occur while parsing CSS.
Warnings that can occur while parsing CSS.
Passed to various keybinding signals for deleting text.
DialogError
v4_10Error codes in the
GTK_DIALOG_ERROR domain that can be returned
by async dialog functions.Focus movement types.
The identifiers for
Editable properties.Specifies the side of the entry at which an icon is placed.
Describes the state of a
gdk::EventSequence in a Gesture.Describes whether a
FileChooser is being used to open existing files
or to save to a possibly new file.These identify the various errors that can occur while calling
FileChooser functions.Describes changes in a filter in more detail and allows objects
using the filter to optimize refiltering items.
Describes the known strictness of a filter.
FontLevel
v4_10The level of granularity for the font selection.
Built-in icon sizes.
Error codes for
IconTheme operations.An enum for determining where a dropped item goes.
Describes primary purpose of the input widget.
The different methods to handle text in #GtkInscription when it doesn’t
fit the available space.
Used for justifying the text inside a
Label widget.Describes how
LevelBar contents should be rendered.The type of license for an application.
The type of message being displayed in a
MessageDialog.Passed as argument to various keybinding signals for moving the
cursor position.
NaturalWrapMode
v4_6Options for selecting a different wrap mode for natural size
requests.
The parameter used in the action signals of
Notebook.Used to determine the layout of pages on a sheet when printing
multiple pages per sheet.
Describes the way two values can be compared.
Represents the orientation of widgets and other objects.
Defines how content overflowing a given area should be handled.
Represents the packing location of a children in its parent.
The type of a pad action.
See also gtk_print_settings_set_orientation().
See also gtk_print_job_set_page_set().
Describes the panning direction of a
GesturePan.Determines how the size should be computed to achieve the one of the
visibility mode for the scrollbars.
Describes which edge of a widget a certain feature is positioned at.
See also gtk_print_settings_set_duplex().
Error codes that identify various errors that can occur while
using the GTK printing support.
Determines what action the print operation should perform.
The result of a print operation.
See also gtk_print_job_set_pages()
See also gtk_print_settings_set_quality().
The status gives a rough indication of the completion of a running
print operation.
Describes limits of a
EventController for handling events
targeting other widgets.Describes the stage at which events are fed into a
EventController.Error codes for
RecentManager operationsPredefined values for use as response ids in gtk_dialog_add_button().
These enumeration values describe the possible transitions
when the child of a
Revealer widget is shown or hidden.Passed as argument to various keybinding signals.
Scrolling types.
Defines the policy to be used in a scrollable widget when updating
the scrolled window adjustments in a given orientation.
Used to control what selections users are allowed to make.
Determines how GTK handles the sensitivity of various controls,
such as combo box buttons.
Describes where
Shortcuts added to a
ShortcutController get handled.GtkShortcutType specifies the kind of shortcut that is being described.
The mode of the size group determines the directions in which the size
group affects the requested sizes of its component widgets.
Specifies a preference for height-for-width or
width-for-height geometry management.
Determines the direction of a sort.
Describes changes in a sorter in more detail and allows users
to optimize resorting.
Describes the type of order that a
Sorter may produce.Determines whether the spin button displays values outside the adjustment
bounds.
The values of the GtkSpinType enumeration are used to specify the
change to make in gtk_spin_button_spin().
Possible transitions between pages in a
Stack widget.Specifies how search strings are matched inside text.
SymbolicColor
v4_6The indexes of colors passed to symbolic color rendering, such as
vfunc::Gtk::SymbolicPaintable::snapshot_symbolic.Values that can be passed to the
vfunc::Gtk::Widget::system_setting_changed
vfunc.Reading directions for text.
Granularity types that extend the text selection. Use the
GtkTextView::extend-selection signal to customize the selection.Used to reference the layers of
TextView for the purpose of customized
drawing with the ::snapshot_layer vfunc.Used to reference the parts of
TextView.The sizing method the column uses to determine its width. Please note
that
Autosize are inefficient for large views, and
can make columns appear choppy.An enum for determining where a dropped row goes.
Used to indicate which grid lines to draw in a tree view.
See also gtk_print_settings_set_paper_width().
Describes a type of line wrapping.
Constants
An undefined value. The accessible attribute is either unset, or its
value is undefined.
The value used to refer to a guaranteed invalid position
in a
GListModel.Use this priority for functionality related to size allocation.
A priority that can be used when adding a
StyleProvider
for application-specific style information.The priority used for default style information
that is used in the absence of themes.
The priority used for style information provided
via
Settings.The priority used for style information provided
by themes.
The priority used for the style information from
$XDG_CONFIG_HOME/gtk-4.0/gtk.css.The priority at which the text view validates onscreen lines
in an idle job in the background.
Statics
The name used for the stock full offset included by
LevelBar.The name used for the stock high offset included by
LevelBar.The name used for the stock low offset included by
LevelBar.Name for the A3 paper size.
Name for the A4 paper size.
Name for the A5 paper size.
Name for the B5 paper size.
Name for the Executive paper size.
Name for the Legal paper size.
Name for the Letter paper size.
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.
The key used by the “Print to file” printer to store the
directory to which the output should be written.
The key used by the “Print to file” printer to store the format
of the output. The supported values are “PS” and “PDF”.
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.
Functions
Gets the modifier mask.
Converts an accelerator keyval and modifier mask into a string
which can be used to represent the accelerator to the user.
Converts an accelerator keyval and modifier mask
into a string that can be displayed to the user.
Converts an accelerator keyval and modifier mask into a string
parseable by gtk_accelerator_parse().
Converts an accelerator keyval and modifier mask
into a string parseable by gtk_accelerator_parse_with_keycode().
Parses a string representing an accelerator.
Parses a string representing an accelerator.
Determines whether a given keyval and modifier mask constitute
a valid keyboard accelerator.
Returns the binary age as passed to
libtool.Checks that the GTK library in use is compatible with the
given version.
Returns the GTK debug flags that are currently active.
Returns the
pango::Language for the default language
currently in effect.Prevents
gtk_init and gtk_init_check from automatically calling
setlocale (LC_ALL, "").enumerate_printersLinux
Calls a function for all
Printers.Converts a color from HSV space to RGB.
Tries to initialize GTK.
Returns the interface age as passed to
libtool.Returns
true if GTK has been initialized.Returns
true if GTK has been initialized and this is the main thread.Get the direction of the current locale. This is the expected
reading direction for text and UI.
Returns the major version number of the GTK library.
Returns the micro version number of the GTK library.
Returns the minor version number of the GTK library.
Runs a page setup dialog, letting the user modify the values from
@page_setup. If the user cancels the dialog, the returned
PageSetup
is identical to the passed in @page_setup, otherwise it contains the
modifications done in the dialog.Runs a page setup dialog, letting the user modify the values from @page_setup.
Renders an activity indicator (such as in
Spinner).
The state StateFlags::CHECKED determines whether there is
activity going on.Renders an arrow pointing to @angle.
Renders the background of an element.
Renders a checkmark (as in a
CheckButton).Renders an expander (as used in
TreeView and Expander) in the area
defined by @x, @y, @width, @height. The state StateFlags::CHECKED
determines whether the expander is collapsed or expanded.Renders a focus indicator on the rectangle determined by @x, @y, @width, @height.
Renders a frame around the rectangle defined by @x, @y, @width, @height.
Renders the icon in @texture at the specified @x and @y coordinates.
Renders @layout on the coordinates @x, @y
Renders a line from (x0, y0) to (x1, y1).
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.Converts a color from RGB space to HSV.
Sets the GTK debug flags.
Informs this crate that GTK has been initialized and the current thread is the main one.
A convenience function for showing an application’s about dialog.
This function launches the default application for showing
a given uri, or shows an error dialog if that fails.
This function launches the default application for showing
a given uri.
Checks whether the
Accessible has @property set.Checks whether the
Accessible has @relation set.Checks whether the
GtkAccessible:accessible-role of the accessible
is @role.Checks whether the
Accessible has @state set.Return the type ids that have been registered after
calling gtk_test_register_all_types().
Force registration of all core GTK object types.
Enters the main loop and waits for @widget to be “drawn”.
Creates a content provider for dragging @path from @tree_model.
Obtains a @tree_model and @path from value of target type
GTK_TYPE_TREE_ROW_DATA.