All Classes and Interfaces
Class
Description
The `GtkAboutDialog` offers a simple way to display information about
a program.
a program.
A window showing information about the application.
`GtkAccessible` is an interface for describing UI elements for
Assistive Technologies.
Assistive Technologies.
#GAction represents a single named action.
The `GtkActionable` interface provides a convenient way of asscociating
widgets with actions.
widgets with actions.
The interface vtable for `GtkActionable`.
`GtkActionBar` is designed to present contextual actions.
This struct defines a single action.
#GActionGroup represents a group of actions.
The virtual function table for #GActionGroup.
Manages application level ActionMap and offers Facade for Action Interface
Callbacks for integer and boolean types actions
The virtual function table for #GAction.
The GActionMap interface is implemented by #GActionGroup
implementations that operate by containing a number of
named #GAction instances, such as #GSimpleActionGroup.
implementations that operate by containing a number of
named #GAction instances, such as #GSimpleActionGroup.
The virtual function table for #GActionMap.
A [class@Gtk.ListBoxRow] used to present actions.
A `GtkShortcutAction` that calls gtk_widget_activate().
`GtkAdjustment` is a model for a numeric value.
A `GtkShortcutTrigger` that combines two triggers.
The `PangoAnalysis` structure stores information about
the properties of a segment of text.
the properties of a segment of text.
A base class for animations.
Represents a value [class@Animation] can animate.
`GtkAnyFilter` matches an item when at least one of its filters matches.
`GtkAppChooser` is an interface for widgets which allow the user to
choose an application.
choose an application.
The `GtkAppChooserButton` lets the user select an application.
`GtkAppChooserDialog` shows a `GtkAppChooserWidget` inside a `GtkDialog`.
`GtkAppChooserWidget` is a widget for selecting applications.
#GAppInfo and #GAppLaunchContext are used for describing and launching
applications installed on the system.
applications installed on the system.
Application Information interface, for operating system portability.
#GAppInfoMonitor is a very simple object used for monitoring the app
info database for changes (ie: newly installed or removed
applications).
info database for changes (ie: newly installed or removed
applications).
`GdkAppLaunchContext` handles launching an application in a graphical context.
Integrating the launch with the launching application.
A base class for Adwaita applications.
A #GApplication is the foundation of an application.
`GtkApplication` is a high-level API for writing applications.
Virtual function table for #GApplication.
#GApplicationCommandLine represents a command-line invocation of
an application.
an application.
The #GApplicationCommandLineClass-struct
contains private data only.
contains private data only.
A freeform application window.
`GtkApplicationWindow` is a `GtkWindow` subclass that integrates with
`GtkApplication`.
`GtkApplication`.
Contains the public fields of a GArray.
`GtkAspectFrame` preserves the aspect ratio of its child.
`GtkAssistant` is used to represent a complex as a series of steps.
`GtkAssistantPage` is an auxiliary object used by `GtkAssistant.
This is the asynchronous version of #GInitable; it behaves the same
in all ways except that initialization is asynchronous.
in all ways except that initialization is asynchronous.
Provides an interface for asynchronous initializing object such that
initialization may fail.
initialization may fail.
Provides a base class for implementing asynchronous function results.
Interface definition for #GAsyncResult.
`GtkATContext` is an abstract class provided by GTK to communicate to
platform-specific assistive technologies API.
platform-specific assistive technologies API.
The `PangoAttrClass` structure stores the type and operations for
a particular type of attribute.
a particular type of attribute.
The `PangoAttrColor` structure is used to represent attributes that
are colors.
are colors.
The `PangoAttrFloat` structure is used to represent attributes with
a float or double value.
a float or double value.
The `PangoAttrFontDesc` structure is used to store an attribute that
sets all aspects of the font description at once.
sets all aspects of the font description at once.
The `PangoAttrFontFeatures` structure is used to represent OpenType
font features as an attribute.
font features as an attribute.
The `PangoAttribute` structure represents the common portions of all
attributes.
attributes.
The `PangoAttrInt` structure is used to represent attributes with
an integer or enumeration value.
an integer or enumeration value.
A `PangoAttrIterator` is used to iterate through a `PangoAttrList`.
The `PangoAttrLanguage` structure is used to represent attributes that
are languages.
are languages.
A `PangoAttrList` represents a list of attributes that apply to a section
of text.
of text.
The `PangoAttrShape` structure is used to represent attributes which
impose shape restrictions.
impose shape restrictions.
The `PangoAttrSize` structure is used to represent attributes which
set font size.
set font size.
The `PangoAttrString` structure is used to represent attributes with
a string value.
a string value.
A widget displaying an image, with a generated fallback.
A widget with one child.
#GBinding is the representation of a binding between a property on a
#GObject instance (or source) and another property on another #GObject
instance (or target).
#GObject instance (or source) and another property on another #GObject
instance (or target).
The #GBindingGroup can be used to bind multiple properties
from an object collectively.
from an object collectively.
`GtkBinLayout` is a `GtkLayoutManager` subclass useful for create "bins" of
widgets.
widgets.
A `GtkBitset` represents a set of unsigned integers.
An opaque, stack-allocated struct for iterating
over the elements of a `GtkBitset`.
over the elements of a `GtkBitset`.
A render node applying a blending function between its two child nodes.
A render node applying a blur effect to its single child.
`GtkBookmarkList` is a list model that wraps `GBookmarkFile`.
`GtkBoolFilter` evaluates a boolean `GtkExpression`
to determine whether to include items.
to determine whether to include items.
A struct that specifies a border around a rectangular area.
A render node for a border.
A 3D box, described as the volume between a minimum and
a maximum vertices.
a maximum vertices.
The `GtkBox` widget arranges child widgets into a single row or column.
`GtkBoxLayout` is a layout manager that arranges children in a single
row or column.
row or column.
Buffered input stream implements #GFilterInputStream and provides
for buffered reads.
for buffered reads.
Buffered output stream implements #GFilterOutputStream and provides
for buffered writes.
for buffered writes.
`GtkBuildable` allows objects to extend and customize their deserialization
from ui files.
from ui files.
The `GtkBuildableIface` interface contains methods that are
necessary to allow `GtkBuilder` to construct an object from
a `GtkBuilder` UI definition.
necessary to allow `GtkBuilder` to construct an object from
a `GtkBuilder` UI definition.
A sub-parser for `GtkBuildable` implementations.
A `GtkBuilder` reads XML descriptions of a user interface and
instantiates the described objects.
instantiates the described objects.
A `GtkBuilderScope` implementation for the C language.
`GtkBuilderListItemFactory` is a `GtkListItemFactory` that creates
widgets by instantiating `GtkBuilder` UI templates.
widgets by instantiating `GtkBuilder` UI templates.
`GtkBuilderScope` is an interface to provide language binding support
to `GtkBuilder`.
to `GtkBuilder`.
The virtual function table to implement for `GtkBuilderScope` implementations.
The `GtkButton` widget is generally used to trigger a callback function that is
called when the button is pressed.
called when the button is pressed.
A helper widget for creating buttons.
An event related to a button on a pointer device.
Contains the public fields of a GByteArray.
A simple refcounted data type representing an immutable sequence of zero or
more bytes from an unspecified origin.
more bytes from an unspecified origin.
#GBytesIcon specifies an image held in memory in a common format (usually
png) to be used as icon.
png) to be used as icon.
`GdkCairoContext` is an object representing the platform-specific
draw context.
draw context.
A render node for a Cairo surface.
A GSK renderer that is using cairo.
`GtkCalendar` is a widget that displays a Gregorian calendar, one month
at a time.
at a time.
A `GtkShortcutAction` that invokes a callback.
An [class@AnimationTarget] that calls a given callback during the
animation.
animation.
Handler to callback resource.
GCancellable is a thread-safe operation cancellation stack used
throughout GIO to allow for cancellation of synchronous and
asynchronous operations.
throughout GIO to allow for cancellation of synchronous and
asynchronous operations.
A paginated scrolling widget.
A dots indicator for [class@Carousel].
A lines indicator for [class@Carousel].
A #GCClosure is a specialization of #GClosure for C function callbacks.
A variant of `GtkClosureExpression` using a C closure.
An abstract class for laying out `GtkCellRenderer`s
The `GtkCellArea` is an abstract class for [iface@Gtk.CellLayout]
widgets (also referred to as "layouting widgets") to interface with
an arbitrary number of [class@Gtk.CellRenderer]s and interact with the user
for a given [iface@Gtk.TreeModel] row.
The `GtkCellArea` is an abstract class for [iface@Gtk.CellLayout]
widgets (also referred to as "layouting widgets") to interface with
an arbitrary number of [class@Gtk.CellRenderer]s and interact with the user
for a given [iface@Gtk.TreeModel] row.
A cell area that renders GtkCellRenderers into a row or a column
The `GtkCellAreaBox` renders cell renderers into a row or a column
depending on its `GtkOrientation`.
The `GtkCellAreaBox` renders cell renderers into a row or a column
depending on its `GtkOrientation`.
Stores geometrical information for a series of rows in a GtkCellArea
The `GtkCellAreaContext` object is created by a given `GtkCellArea`
implementation via its `GtkCellAreaClass.create_context()` virtual
method and is used to store cell sizes and alignments for a series of
`GtkTreeModel` rows that are requested and rendered in the same context.
The `GtkCellAreaContext` object is created by a given `GtkCellArea`
implementation via its `GtkCellAreaClass.create_context()` virtual
method and is used to store cell sizes and alignments for a series of
`GtkTreeModel` rows that are requested and rendered in the same context.
Interface for widgets that can be used for editing cells
The `GtkCellEditable` interface must be implemented for widgets to be usable
to edit the contents of a `GtkTreeView` cell.
The `GtkCellEditable` interface must be implemented for widgets to be usable
to edit the contents of a `GtkTreeView` cell.
An interface for packing cells
`GtkCellLayout` is an interface to be implemented by all objects which
want to provide a `GtkTreeViewColumn` like API for packing cells,
setting attributes and data funcs.
`GtkCellLayout` is an interface to be implemented by all objects which
want to provide a `GtkTreeViewColumn` like API for packing cells,
setting attributes and data funcs.
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`.
The `GtkCellRenderer` is a base class of a set of objects used for
rendering a cell to a `cairo_t`.
Renders a keyboard accelerator in a cell
`GtkCellRendererAccel` displays a keyboard accelerator (i.e. a key
combination like `Control + a`).
`GtkCellRendererAccel` displays a keyboard accelerator (i.e. a key
combination like `Control + a`).
Renders a combobox in a cell
`GtkCellRendererCombo` renders text in a cell like `GtkCellRendererText` from
which it is derived.
`GtkCellRendererCombo` renders text in a cell like `GtkCellRendererText` from
which it is derived.
Renders a pixbuf in a cell
A `GtkCellRendererPixbuf` can be used to render an image in a cell.
A `GtkCellRendererPixbuf` can be used to render an image in a cell.
Renders numbers as progress bars
`GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
`GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
Renders a spin button in a cell
`GtkCellRendererSpin` renders text in a cell like `GtkCellRendererText` from
which it is derived.
`GtkCellRendererSpin` renders text in a cell like `GtkCellRendererText` from
which it is derived.
Renders a spinning animation in a cell
`GtkCellRendererSpinner` renders a spinning animation in a cell, very
similar to `GtkSpinner`.
`GtkCellRendererSpinner` renders a spinning animation in a cell, very
similar to `GtkSpinner`.
Renders text in a cell
A `GtkCellRendererText` renders a given text in its cell, using the font, color and
style information provided by its properties.
A `GtkCellRendererText` renders a given text in its cell, using the font, color and
style information provided by its properties.
Renders a toggle button in a cell
`GtkCellRendererToggle` renders a toggle button in a cell.
`GtkCellRendererToggle` renders a toggle button in a cell.
A widget displaying a single row of a GtkTreeModel
A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
and `GtkCellAreaContext`.
A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
and `GtkCellAreaContext`.
`GtkCenterBox` arranges three children in a row, keeping the middle child
centered as well as possible.
centered as well as possible.
`GtkCenterLayout` is a layout manager that manages up to three children.
#GCharsetConverter is an implementation of #GConverter based on
GIConv.
GIConv.
A `GtkCheckButton` places a label next to an indicator.
An opaque structure representing a checksumming operation.
A widget constraining its child to a given size.
A layout manager constraining its children to a given size.
A scrollable [class@Clamp].
Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-GeoClue2-Client.top_of_page">org.freedesktop.GeoClue2.Client</link>.
Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-GeoClue2-Client.top_of_page">org.freedesktop.GeoClue2.Client</link>.
The #GClueClientProxy structure contains only private data and should only be accessed using the provided API.
Class structure for #GClueClientProxy.
The #GClueClientSkeleton structure contains only private data and should only be accessed using the provided API.
Class structure for #GClueClientSkeleton.
The `GdkClipboard` object represents data shared between applications or
inside an application.
inside an application.
A render node applying a rectangular clip to its single child node.
A #GClosure represents a callback supplied by the programmer.
An expression using a custom `GClosure` to compute the value from
its parameters.
its parameters.
The `PangoColor` structure is used to
represent a color in an uncalibrated RGB color-space.
represent a color in an uncalibrated RGB color-space.
The `GtkColorButton` allows to open a color chooser dialog to change
the color.
the color.
`GtkColorChooser` is an interface that is implemented by widgets
for choosing colors.
for choosing colors.
A dialog for choosing a color.
The `GtkColorChooserWidget` widget lets the user select a color.
A render node controlling the color matrix of its single child node.
A render node for a solid color.
A color stop in a gradient node.
`GtkColumnView` presents a large dynamic list of items using multiple columns
with headers.
with headers.
`GtkColumnViewColumn` represents the columns being added to `GtkColumnView`.
A `GtkComboBox` is a widget that allows the user to choose from a list of
valid choices.
valid choices.
A `GtkComboBoxText` is a simple variant of `GtkComboBox` for text-only
use cases.
use cases.
A [class@Gtk.ListBoxRow] used to choose from a list of items.
The #GCond struct is an opaque data structure that represents a
condition.
condition.
A render node for a conic gradient.
A constant value in a `GtkExpression`.
`GtkConstraint` describes a constraint between attributes of two widgets,
expressed as a linear equation.
expressed as a linear equation.
A `GtkConstraintGuide` is an invisible layout element in a
`GtkConstraintLayout`.
`GtkConstraintLayout`.
A layout manager using constraints to describe relations between widgets.
`GtkLayoutChild` subclass for children in a `GtkConstraintLayout`.
The `GtkConstraintTarget` interface is implemented by objects that
can be used as source or target in `GtkConstraint`s.
can be used as source or target in `GtkConstraint`s.
A render node that can contain other render nodes.
A `GdkContentDeserializer` is used to deserialize content received via
inter-application data transfers.
inter-application data transfers.
The `GdkContentFormats` structure is used to advertise and negotiate the
format of content.
format of content.
A `GdkContentFormatsBuilder` is an auxiliary struct used to create
new `GdkContentFormats`, and should not be kept around.
new `GdkContentFormats`, and should not be kept around.
A `GdkContentProvider` is used to provide content for the clipboard or
for drag-and-drop operations in a number of formats.
for drag-and-drop operations in a number of formats.
Class structure for `GdkContentProvider`.
A `GdkContentSerializer` is used to serialize content for
inter-application data transfers.
inter-application data transfers.
A `PangoContext` stores global information used to control the
itemization process.
itemization process.
#GConverter is implemented by objects that convert
binary data in various ways.
binary data in various ways.
Provides an interface for converting data from one type
to another type.
to another type.
Converter input stream implements #GInputStream and allows
conversion of data of various types during reading.
conversion of data of various types during reading.
Converter output stream implements #GOutputStream and allows
conversion of data of various types during reading.
conversion of data of various types during reading.
A `PangoCoverage` structure is a map from Unicode characters
to [enum@Pango.CoverageLevel] values.
to [enum@Pango.CoverageLevel] values.
The #GCredentials type is a reference-counted wrapper for native
credentials.
credentials.
A render node cross fading between two child nodes.
An event caused by a pointing device moving between surfaces.
Represents a location in a file or other source of data parsed
by the CSS engine.
by the CSS engine.
`GtkCssProvider` is an object implementing the `GtkStyleProvider` interface
for CSS.
for CSS.
Defines a part of a CSS document.
`GdkCursor` is used to create and destroy cursors.
`GtkCustomFilter` determines whether to include items with a callback.
`GtkCustomLayout` uses closures for size negotiation.
`GtkCustomSorter` is a `GtkSorter` implementation that sorts via a callback
function.
function.
A #GDatagramBased is a networking interface for representing datagram-based
communications.
communications.
Provides an interface for socket-like objects which have datagram semantics,
following the Berkeley sockets API.
following the Berkeley sockets API.
Data input stream implements #GInputStream and includes functions for
reading structured data directly from a binary input stream.
reading structured data directly from a binary input stream.
Data output stream implements #GOutputStream and includes functions for
writing data directly to an output stream.
writing data directly to an output stream.
Represents a day between January 1, Year 1 and a few thousand years in
the future.
the future.
An opaque structure that represents a date and time, including a time zone.
#GDBusActionGroup is an implementation of the #GActionGroup
interface that can be used as a proxy for an action group
that is exported over D-Bus with g_dbus_connection_export_action_group().
interface that can be used as a proxy for an action group
that is exported over D-Bus with g_dbus_connection_export_action_group().
Information about an annotation.
Information about an argument for a method or a signal.
The #GDBusAuthObserver type provides a mechanism for participating
in how a #GDBusServer (or a #GDBusConnection) authenticates remote
peers.
in how a #GDBusServer (or a #GDBusConnection) authenticates remote
peers.
The #GDBusConnection type is used for D-Bus connections to remote
peers such as a message buses.
peers such as a message buses.
Struct used in g_dbus_error_register_error_domain().
The #GDBusInterface type is the base type for D-Bus interfaces both
on the service side (see #GDBusInterfaceSkeleton) and client side
(see #GDBusProxy).
on the service side (see #GDBusInterfaceSkeleton) and client side
(see #GDBusProxy).
Base type for D-Bus interfaces.
Information about a D-Bus interface.
Abstract base class for D-Bus interfaces on the service side.
Class structure for #GDBusInterfaceSkeleton.
Virtual table for handling properties and method calls for a D-Bus
interface.
interface.
#GDBusMenuModel is an implementation of #GMenuModel that can be used
as a proxy for a menu model that is exported over D-Bus with
g_dbus_connection_export_menu_model().
as a proxy for a menu model that is exported over D-Bus with
g_dbus_connection_export_menu_model().
A type for representing D-Bus messages that can be sent or received
on a #GDBusConnection.
on a #GDBusConnection.
Information about a method on an D-Bus interface.
Instances of the #GDBusMethodInvocation class are used when
handling D-Bus method calls.
handling D-Bus method calls.
Information about nodes in a remote object hierarchy.
The #GDBusObject type is the base type for D-Bus objects on both
the service side (see #GDBusObjectSkeleton) and the client side
(see #GDBusObjectProxy).
the service side (see #GDBusObjectSkeleton) and the client side
(see #GDBusObjectProxy).
Base object type for D-Bus objects.
The #GDBusObjectManager type is the base type for service- and
client-side implementations of the standardized
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface.
client-side implementations of the standardized
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface.
#GDBusObjectManagerClient is used to create, monitor and delete object
proxies for remote objects exported by a #GDBusObjectManagerServer (or any
code implementing the
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface).
proxies for remote objects exported by a #GDBusObjectManagerServer (or any
code implementing the
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface).
Class structure for #GDBusObjectManagerClient.
Base type for D-Bus object managers.
#GDBusObjectManagerServer is used to export #GDBusObject instances using
the standardized
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface.
the standardized
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface.
Class structure for #GDBusObjectManagerServer.
A #GDBusObjectProxy is an object used to represent a remote object
with one or more D-Bus interfaces.
with one or more D-Bus interfaces.
Class structure for #GDBusObjectProxy.
A #GDBusObjectSkeleton instance is essentially a group of D-Bus
interfaces.
interfaces.
Class structure for #GDBusObjectSkeleton.
Information about a D-Bus property on a D-Bus interface.
#GDBusProxy is a base class used for proxies to access a D-Bus
interface on a remote object.
interface on a remote object.
Class structure for #GDBusProxy.
#GDBusServer is a helper for listening to and accepting D-Bus
connections.
connections.
Information about a signal on a D-Bus interface.
Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().
#GDebugController is an interface to expose control of debugging features and
debug output.
debug output.
#GDebugControllerDBus is an implementation of #GDebugController which exposes
debug settings as a D-Bus object.
debug settings as a D-Bus object.
The virtual function table for #GDebugControllerDBus.
The virtual function table for #GDebugController.
Associates a string with a bit flag.
A render node that emits a debugging message when drawing its
child node.
child node.
An event related to closing a top-level surface.
#GDesktopAppInfo is an implementation of #GAppInfo based on
desktop files.
desktop files.
#GDesktopAppInfoLookup is an opaque data structure and can only be accessed
using the following functions.
using the following functions.
Interface that is used by backends to associate default
handlers with URI schemes.
handlers with URI schemes.
The `GdkDevice` object represents an input device, such
as a keyboard, a mouse, or a touchpad.
as a keyboard, a mouse, or a touchpad.
`GdkDevicePad` is an interface implemented by devices of type
%GDK_SOURCE_TABLET_PAD
It allows querying the features provided by the pad device.
%GDK_SOURCE_TABLET_PAD
It allows querying the features provided by the pad device.
A physical tool associated to a `GdkDevice`.
Dialogs are a convenient way to prompt the user for a small amount
of input.
of input.
`GtkDirectoryList` is a list model that wraps g_file_enumerate_children_async().
`GdkDisplay` objects are the GDK representation of a workstation.
A singleton object that offers notification when displays appear or
disappear.
disappear.
An event related to drag and drop operations.
The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign,
mantissa and exponent of IEEE floats and doubles.
mantissa and exponent of IEEE floats and doubles.
The `GdkDrag` object represents the source of an ongoing DND operation.
`GtkDragIcon` is a `GtkRoot` implementation for drag icons.
`GtkDragSource` is an event controller to initiate Drag-And-Drop operations.
A `GdkDragSurface` is an interface for surfaces used during DND.
Base class for objects implementing different rendering methods.
`GtkDrawingArea` is a widget that allows drawing with cairo.
#GDrive - this represent a piece of hardware connected to the machine.
Interface for creating #GDrive implementations.
The `GdkDrop` object represents the target of an ongoing DND operation.
`GtkDropControllerMotion` is an event controller tracking
the pointer during Drag-and-Drop operations.
the pointer during Drag-and-Drop operations.
`GtkDropDown` is a widget that allows the user to choose an item
from a list of options.
from a list of options.
`GtkDropTarget` is an event controller to receive Drag-and-Drop operations.
`GtkDropTargetAsync` is an event controller to receive Drag-and-Drop
operations, asynchronously.
operations, asynchronously.
#GDtlsClientConnection is the client-side subclass of
#GDtlsConnection, representing a client-side DTLS connection.
#GDtlsConnection, representing a client-side DTLS connection.
vtable for a #GDtlsClientConnection implementation.
#GDtlsConnection is the base DTLS connection class type, which wraps
a #GDatagramBased and provides DTLS encryption on top of it.
a #GDatagramBased and provides DTLS encryption on top of it.
Virtual method table for a #GDtlsConnection implementation.
#GDtlsServerConnection is the server-side subclass of #GDtlsConnection,
representing a server-side DTLS connection.
representing a server-side DTLS connection.
vtable for a #GDtlsServerConnection implementation.
`GtkEditable` is an interface for text editing widgets.
A `GtkEditableLabel` is a label that allows users to
edit the text by switching to an “edit mode”.
edit the text by switching to an “edit mode”.
#GEmblem is an implementation of #GIcon that supports
having an emblem, which is an icon with additional properties.
having an emblem, which is an icon with additional properties.
#GEmblemedIcon is an implementation of #GIcon that supports
adding an emblem to an icon.
adding an emblem to an icon.
The `GtkEmojiChooser` is used by text widgets such as `GtkEntry` or
`GtkTextView` to let users insert Emoji characters.
`GtkTextView` to let users insert Emoji characters.
`GtkEntry` is a single line text entry widget.
A `GtkEntryBuffer` hold the text displayed in a `GtkText` widget.
Class structure for `GtkEntry`.
`GtkEntryCompletion` is an auxiliary object to provide completion functionality
for `GtkEntry`.
for `GtkEntry`.
A [class@Gtk.ListBoxRow] with an embedded text entry.
The class of an enumeration type holds information about its
possible values.
possible values.
`AdwEnumListItem` is the type of items in a [class@EnumListModel].
A [iface@Gio.ListModel] representing values of a given enum.
A structure which contains a single enum value, its name, and its
nickname.
nickname.
The `GError` structure contains information about
an error that has occurred.
an error that has occurred.
Describe a rotation using Euler angles.
`GdkEvent`s are immutable data structures, created by GDK to
represent windowing system events.
represent windowing system events.
`GtkEventController` is the base class for event controllers.
`GtkEventControllerFocus` is an event controller to keep track of
keyboard focus.
keyboard focus.
`GtkEventControllerKey` is an event controller that provides access
to key events.
to key events.
`GtkEventControllerLegacy` is an event controller that provides raw
access to the event stream.
access to the event stream.
`GtkEventControllerMotion` is an event controller tracking the pointer
position.
position.
`GtkEventControllerScroll` is an event controller that handles scroll
events.
events.
`GdkEventSequence` is an opaque type representing a sequence
of related touch events.
of related touch events.
`GtkEveryFilter` matches an item when each of its filters matches.
`GtkExpander` allows the user to reveal its child by clicking
on an expander triangle.
on an expander triangle.
A [class@Gtk.ListBoxRow] used to reveal widgets.
`GtkExpression` provides a way to describe references to values.
An opaque structure representing a watched `GtkExpression`.
#GFile is a high level abstraction for manipulating files on a
virtual file system.
virtual file system.
Information about a specific attribute.
Acts as a lightweight registry for possible valid file attributes.
Determines if a string matches a file attribute.
`GtkFileChooser` is an interface that can be implemented by file
selection widgets.
selection widgets.
`GtkFileChooserDialog` is a dialog suitable for use with
“File Open” or “File Save” commands.
“File Open” or “File Save” commands.
`GtkFileChooserNative` is an abstraction of a dialog suitable
for use with “File Open” or “File Save as” commands.
for use with “File Open” or “File Save as” commands.
`GtkFileChooserWidget` is a widget for choosing files.
#GFileDescriptorBased is implemented by streams (implementations of
#GInputStream or #GOutputStream) that are based on file descriptors.
#GInputStream or #GOutputStream) that are based on file descriptors.
An interface for file descriptor based io objects.
#GFileEnumerator allows you to operate on a set of #GFiles,
returning a #GFileInfo structure for each file enumerated (e.g.
returning a #GFileInfo structure for each file enumerated (e.g.
`GtkFileFilter` filters files by name or mime type.
#GFileIcon specifies an icon by pointing to an image file
to be used as icon.
to be used as icon.
An interface for writing VFS file handles.
Functionality for manipulating basic metadata for files.
GFileInputStream provides input streams that take their
content from a file.
content from a file.
GFileIOStream provides io streams that both read and write to the same
file handle.
file handle.
An opaque type representing a list of files.
Monitors a file or directory for changes.
Completes partial file and directory names given a partial string by
looking in the file system for clues.
looking in the file system for clues.
GFileOutputStream provides output streams that write their
content to a file.
content to a file.
A `GtkFilter` object describes the filtering to be performed by a
[class@Gtk.FilterListModel].
[class@Gtk.FilterListModel].
Base class for input stream implementations that perform some
kind of filtering operation on a base stream.
kind of filtering operation on a base stream.
`GtkFilterListModel` is a list model that filters the elements of
the underlying model according to a `GtkFilter`.
the underlying model according to a `GtkFilter`.
Base class for output stream implementations that perform some
kind of filtering operation on a base stream.
kind of filtering operation on a base stream.
`GtkFixed` places its child widgets at fixed positions and with fixed sizes.
`GtkFixedLayout` is a layout manager which can place child widgets
at fixed positions.
at fixed positions.
`GtkLayoutChild` subclass for children in a `GtkFixedLayout`.
The class of a flags type holds information about its
possible values.
possible values.
A structure which contains a single flags value, its name, and its
nickname.
nickname.
An adaptive container acting like a box or an overlay.
`GtkFlattenListModel` is a list model that concatenates other list models.
The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign,
mantissa and exponent of IEEE floats and doubles.
mantissa and exponent of IEEE floats and doubles.
A `GtkFlowBox` puts child widgets in reflowing grid.
`GtkFlowBoxChild` is the kind of widget that can be added to a `GtkFlowBox`.
An event related to a keyboard focus change.
A `PangoFont` is used to represent a font in a
rendering-system-independent manner.
rendering-system-independent manner.
`PangoCairoFont` is an interface exported by fonts for
use with Cairo.
use with Cairo.
The `GtkFontButton` allows to open a font chooser dialog to change
the font.
the font.
`GtkFontChooser` is an interface that can be implemented by widgets
for choosing fonts.
for choosing fonts.
The `GtkFontChooserDialog` widget is a dialog for selecting a font.
The `GtkFontChooserWidget` widget lets the user select a font.
A `PangoFontDescription` describes a font in an implementation-independent
manner.
manner.
A `PangoFontFace` is used to represent a group of fonts with
the same family, slant, weight, and width, but varying sizes.
the same family, slant, weight, and width, but varying sizes.
A `PangoFontFamily` is used to represent a family of related
font faces.
font faces.
A `PangoFontMap` represents the set of fonts available for a
particular rendering system.
particular rendering system.
`PangoCairoFontMap` is an interface exported by font maps for
use with Cairo.
use with Cairo.
The `PangoFontMapClass` structure holds the virtual functions for
a particular `PangoFontMap` implementation.
a particular `PangoFontMap` implementation.
A `PangoFontMetrics` structure holds the overall metric information
for a font.
for a font.
A `PangoFontset` represents a set of `PangoFont` to use when rendering text.
The `PangoFontsetClass` structure holds the virtual functions for
a particular `PangoFontset` implementation.
a particular `PangoFontset` implementation.
`PangoFontsetSimple` is a implementation of the abstract
`PangoFontset` base class as an array of fonts.
`PangoFontset` base class as an array of fonts.
`GtkFrame` is a widget that surrounds its child with a decorative
frame and an optional label.
frame and an optional label.
A `GdkFrameClock` tells the application when to update and repaint
a surface.
a surface.
A `GdkFrameTimings` object holds timing information for a single frame
of the application’s displays.
of the application’s displays.
A 3D volume delimited by 2D clip planes.
`GtkGesture` is the base class for gesture recognition.
`GtkGestureClick` is a `GtkGesture` implementation for clicks.
`GtkGestureDrag` is a `GtkGesture` implementation for drags.
`GtkGestureLongPress` is a `GtkGesture` for long presses.
`GtkGesturePan` is a `GtkGesture` for pan gestures.
`GtkGestureRotate` is a `GtkGesture` for 2-finger rotations.
`GtkGestureSingle` is a `GtkGestures` subclass optimized for singe-touch
and mouse gestures.
and mouse gestures.
`GtkGestureStylus` is a `GtkGesture` specific to stylus input.
`GtkGestureSwipe` is a `GtkGesture` for swipe gestures.
`GtkGestureZoom` is a `GtkGesture` for 2-finger pinch/zoom gestures.
`GtkGLArea` is a widget that allows drawing with OpenGL.
The `GtkGLAreaClass` structure contains only private data.
`GdkGLContext` is an object representing a platform-specific
OpenGL draw context.
OpenGL draw context.
A `GskGLShader` is a snippet of GLSL that is meant to run in the
fragment shader of the rendering pipeline.
fragment shader of the rendering pipeline.
A render node using a GL shader when drawing its children nodes.
A GdkTexture representing a GL texture object.
The `PangoGlyphGeometry` structure contains width and positioning
information for a single glyph.
information for a single glyph.
A `PangoGlyphInfo` structure represents a single glyph with
positioning information and visual attributes.
positioning information and visual attributes.
A `PangoGlyphItem` is a pair of a `PangoItem` and the glyphs
resulting from shaping the items text.
resulting from shaping the items text.
A `PangoGlyphItemIter` is an iterator over the clusters in a
`PangoGlyphItem`.
`PangoGlyphItem`.
A `PangoGlyphString` is used to store strings of glyphs with geometry
and visual attribute information.
and visual attribute information.
A `PangoGlyphVisAttr` structure communicates information between
the shaping and rendering phases.
the shaping and rendering phases.
An event related to a broken windowing system grab.
`GtkGrid` is a container which arranges its child widgets in
rows and columns.
rows and columns.
`GtkGridLayout` is a layout manager which arranges child widgets in
rows and columns.
rows and columns.
`GtkLayoutChild` subclass for children in a `GtkGridLayout`.
`GtkGridView` presents a large dynamic grid of items.
The GString struct contains the public fields of a GString.
The #GHashTable struct is an opaque data structure to represent a
[Hash Table][glib-Hash-Tables].
[Hash Table][glib-Hash-Tables].
A GHashTableIter structure represents an iterator that can be used
to iterate over the elements of a #GHashTable.
to iterate over the elements of a #GHashTable.
A title bar widget.
`GtkHeaderBar` is a widget for creating custom title bars for windows.
The #GHook struct represents a single hook function in a #GHookList.
The #GHookList struct represents a list of hook functions.
#GIcon is a very minimal interface for icons.
GIconIface is used to implement GIcon types for various
different systems.
different systems.
Contains information found when looking up an icon in `GtkIconTheme`.
`GtkIconTheme` provides a facility for loading themed icons.
`GtkIconView` is a widget which displays data in a grid of icons.
The `GtkImage` widget displays an image.
`GtkIMContext` defines the interface for GTK input methods.
`GtkIMContextSimple` is an input method supporting table-based input methods.
`GtkIMMulticontext` is an input method context supporting multiple,
switchable input methods.
switchable input methods.
#GInetAddress represents an IPv4 or IPv6 internet address.
#GInetAddressMask represents a range of IPv4 or IPv6 addresses
described by a base address and a length indicating how many bits
of the base address are relevant for matching purposes.
described by a base address and a length indicating how many bits
of the base address are relevant for matching purposes.
An IPv4 or IPv6 socket address; that is, the combination of a
#GInetAddress and a port number.
#GInetAddress and a port number.
`GtkInfoBar` can be show messages to the user without a dialog.
#GInitable is implemented by objects that can fail during
initialization.
initialization.
Provides an interface for initializing object such that initialization
may fail.
may fail.
A type for objects that have an initially floating reference.
The class structure for the GInitiallyUnowned type.
Structure used for scatter/gather data input when receiving multiple
messages or packets in one go.
messages or packets in one go.
#GInputStream has functions to read from a stream (g_input_stream_read()),
to close a stream (g_input_stream_close()) and to skip some content
(g_input_stream_skip()).
to close a stream (g_input_stream_close()) and to skip some content
(g_input_stream_skip()).
Structure used for scatter/gather data input.
`GtkInscription` is a widget to show text in a predefined area.
A render node for an inset shadow.
https://www.w3schools.com/java/java_data_types.asp
Base class for gobject interfaces
A structure that provides information to the type system which is
used specifically for managing interface types.
used specifically for managing interface types.
A data structure representing an IO Channel.
A table of functions used to handle different types of #GIOChannel
in a generic way.
in a generic way.
Provides an interface and default functions for loading and unloading
modules.
modules.
GIOStream represents an object that has both read and write streams.
The `PangoItem` structure stores information about a segment of text.
Util class for location-independent access to program specific resources.
An event related to a key-based device.
The GKeyFile struct contains only private data
and should not be accessed directly.
and should not be accessed directly.
A `GdkKeymapKey` is a hardware key that can be mapped to a keyval.
A `GtkShortcutTrigger` that triggers when a specific keyval and modifiers are pressed.
The `GtkLabel` widget displays a small amount of text.
The `PangoLanguage` structure is used to
represent a language.
represent a language.
A `PangoLayout` structure represents an entire paragraph of text.
`GtkLayoutChild` is the base class for objects that are meant to hold
layout properties.
layout properties.
A `PangoLayoutIter` can be used to iterate over the visual
extents of a `PangoLayout`.
extents of a `PangoLayout`.
A `PangoLayoutLine` represents one of the lines resulting from laying
out a paragraph via `PangoLayout`.
out a paragraph via `PangoLayout`.
Layout managers are delegate classes that handle the preferred size
and the allocation of a widget.
and the allocation of a widget.
The `GtkLayoutManagerClass` structure contains only private data, and
should only be accessed through the provided API, or when subclassing
`GtkLayoutManager`.
should only be accessed through the provided API, or when subclassing
`GtkLayoutManager`.
An adaptive container acting like a box or a stack.
An auxiliary class used by [class@Leaflet].
`GtkLevelBar` is a widget that can be used as a level indicator.
A render node for a linear gradient.
A `GtkLinkButton` is a button with a hyperlink.
The #GList struct is used for each element in a doubly-linked list.
`GtkListBase` is the abstract base class for GTK's list widgets.
`GtkListBox` is a vertical list.
`GtkListBoxRow` is the kind of widget that can be added to a `GtkListBox`.
A ListModel that provides indices for n items.
`GtkListItem` is used by list widgets to represent items in a `GListModel`.
A `GtkListItemFactory` creates widgets for the items taken from a `GListModel`.
#GListModel is an interface that represents a mutable list of
#GObjects.
#GObjects.
The virtual function table for #GListModel.
#GListStore is a simple implementation of #GListModel that stores all
items in memory.
items in memory.
A list-like data structure that can be used with the [class@Gtk.TreeView].
`GtkListView` presents a large dynamic list of items.
Extends the #GIcon interface and adds the ability to
load icons from streams.
load icons from streams.
Interface for icons that can be loaded as a stream.
Configurable loader for loading JNA API instances
Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-GeoClue2-Location.top_of_page">org.freedesktop.GeoClue2.Location</link>.
Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-GeoClue2-Location.top_of_page">org.freedesktop.GeoClue2.Location</link>.
The #GClueLocationProxy structure contains only private data and should only be accessed using the provided API.
Class structure for #GClueLocationProxy.
The #GClueLocationSkeleton structure contains only private data and should only be accessed using the provided API.
Class structure for #GClueLocationSkeleton.
`GtkLockButton` is a widget to obtain and revoke authorizations
needed to operate the controls.
needed to operate the controls.
The `PangoLogAttr` structure stores information about the attributes of a
single character.
single character.
Structure representing a single field in a structured log entry.
The `GMainContext` struct is an opaque data
type representing a set of sources to be handled in a main loop.
type representing a set of sources to be handled in a main loop.
The `GMainLoop` struct is an opaque data type
representing the main event loop of a GLib or GTK+ application.
representing the main event loop of a GLib or GTK+ application.
Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-GeoClue2-Manager.top_of_page">org.freedesktop.GeoClue2.Manager</link>.
Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-GeoClue2-Manager.top_of_page">org.freedesktop.GeoClue2.Manager</link>.
The #GClueManagerProxy structure contains only private data and should only be accessed using the provided API.
Class structure for #GClueManagerProxy.
The #GClueManagerSkeleton structure contains only private data and should only be accessed using the provided API.
Class structure for #GClueManagerSkeleton.
A `GtkMapListModel` maps the items in a list model to different items.
The #GMappedFile represents a file mapping created with
g_mapped_file_new().
g_mapped_file_new().
A parse context is used to parse a stream of bytes that
you expect to contain marked-up text.
you expect to contain marked-up text.
Any of the fields in #GMarkupParser can be %NULL, in which case they
will be ignored.
will be ignored.
A GMatchInfo is an opaque struct used to return information about
matches.
matches.
A structure capable of holding a 4x4 matrix.
A `PangoMatrix` specifies a transformation between user-space
and device coordinates.
and device coordinates.
`GtkMediaControls` is a widget to show controls for a video.
`GtkMediaFile` implements `GtkMediaStream` for files.
`GtkMediaStream` is the integration point for media playback inside GTK.
#GMemoryInputStream is a class for using arbitrary
memory chunks as input for GIO streaming input operations.
memory chunks as input for GIO streaming input operations.
#GMemoryMonitor will monitor system memory and suggest to the application
when to free memory so as to leave more room for other applications.
when to free memory so as to leave more room for other applications.
The virtual function table for #GMemoryMonitor.
#GMemoryOutputStream is a class for using arbitrary
memory chunks as output for GIO streaming output operations.
memory chunks as output for GIO streaming output operations.
A `GdkTexture` representing image data in memory.
A set of functions used to perform memory allocation.
#GMenu is a simple implementation of #GMenuModel.
#GMenuAttributeIter is an opaque structure type.
The `GtkMenuButton` widget is used to display a popup when clicked.
#GMenuItem is an opaque structure type.
#GMenuLinkIter is an opaque structure type.
#GMenuModel represents the contents of a menu -- an ordered list of
menu items.
menu items.
A dialog presenting a message or a question.
`GtkMessageDialog` presents a dialog with some message text.
A `GtkShortcutAction` that calls gtk_widget_mnemonic_activate().
A `GtkShortcutTrigger` that triggers when a specific mnemonic is pressed.
`GdkMonitor` objects represent the individual outputs that are
associated with a `GdkDisplay`.
associated with a `GdkDisplay`.
An event related to a pointer or touch device motion.
The #GMount interface represents user-visible mounts.
Interface for implementing operations for mounts.
#GMountOperation provides a mechanism for interacting with the user.
`GtkMountOperation` is an implementation of `GMountOperation`.
`GtkMultiFilter` is the base class for filters that combine multiple filters.
`GtkMultiSelection` is a `GtkSelectionModel` that allows selecting multiple
elements.
elements.
`GtkMultiSorter` combines multiple sorters by trying them
in turn.
in turn.
The #GMutex struct is an opaque data structure to represent a mutex
(mutual exclusion).
(mutual exclusion).
A `GtkShortcutAction` that activates an action by name.
`GtkNative` is the interface implemented by all widgets that have
their own `GdkSurface`.
their own `GdkSurface`.
Native dialogs are platform dialogs that don't use `GtkDialog`.
Class structure for `GtkNativeDialog`.
A socket address of some unknown native type.
#GNetworkAddress provides an easy way to resolve a hostname and
then attempt to connect to that host, handling the possibility of
multiple IP addresses and multiple address families.
then attempt to connect to that host, handling the possibility of
multiple IP addresses and multiple address families.
#GNetworkMonitor provides an easy-to-use cross-platform API
for monitoring network connectivity.
for monitoring network connectivity.
The virtual function table for #GNetworkMonitor.
Like #GNetworkAddress does with hostnames, #GNetworkService
provides an easy way to resolve a SRV record, and then attempt to
connect to one of the hosts that implements that service, handling
service priority/weighting, multiple IP addresses, and multiple
address families.
provides an easy way to resolve a SRV record, and then attempt to
connect to one of the hosts that implements that service, handling
service priority/weighting, multiple IP addresses, and multiple
address families.
A `GtkShortcutTrigger` that never triggers.
The #GNode struct represents one node in a [n-ary tree][glib-N-ary-Trees].
`GtkNoSelection` is a `GtkSelectionModel` that does not allow selecting
anything.
anything.
`GtkNotebook` is a container whose children are pages switched
between using tabs.
between using tabs.
`GtkNotebookPage` is an auxiliary object used by `GtkNotebook`.
A `GtkShortcutAction` that does nothing.
#GNotification is a mechanism for creating a notification to be shown
to the user -- typically as a pop-up notification presented by the
desktop environment shell.
to the user -- typically as a pop-up notification presented by the
desktop environment shell.
`GtkNumericSorter` is a `GtkSorter` that compares numbers.
The base object type.
The class structure for the GObject type.
The GObjectConstructParam struct is an auxiliary structure used to hand
#GParamSpec/#GValue pairs to the @constructor of a #GObjectClass.
#GParamSpec/#GValue pairs to the @constructor of a #GObjectClass.
A `GObject` value in a `GtkExpression`.
A #GOnce struct controls a one-time initialization function.
A render node controlling the opacity of its single child node.
A GOptionEntry struct defines a single option.
A `GOptionGroup` struct defines the options in a single
group.
group.
The `GtkOrientable` interface is implemented by all widgets that can be
oriented horizontally or vertically.
oriented horizontally or vertically.
Structure used for scatter/gather data output when sending multiple
messages or packets in one go.
messages or packets in one go.
#GOutputStream has functions to write to a stream (g_output_stream_write()),
to close a stream (g_output_stream_close()) and to flush pending writes
(g_output_stream_flush()).
to close a stream (g_output_stream_close()) and to flush pending writes
(g_output_stream_flush()).
Structure used for scatter/gather data output.
A render node for an outset shadow.
Unknown type.
`GtkOverlay` is a container which contains a single main child, on top
of which it can place “overlay” widgets.
of which it can place “overlay” widgets.
`GtkOverlayLayout` is the layout manager used by `GtkOverlay`.
`GtkLayoutChild` subclass for children in a `GtkOverlayLayout`.
Base type for package functions class
Struct defining a pad action entry.
`GtkPadController` is an event controller for the pads found in drawing
tablets.
tablets.
An event related to a pad-based device.
A range of pages to print.
A `GtkPageSetup` object stores the page size, orientation and margins.
`GtkPageSetupUnixDialog` implements a page setup dialog for platforms
which don’t provide a native page setup dialog, like Unix.
which don’t provide a native page setup dialog, like Unix.
`GdkPaintable` is a simple interface used by GTK to represent content that
can be painted.
can be painted.
The list of functions that can be implemented for the `GdkPaintable`
interface.
interface.
A widget with two panes, arranged either horizontally or vertically.
`GtkPaperSize` handles paper sizes.
The GParameter struct is an auxiliary structure used
to hand parameter name/value pairs to g_object_newv().
to hand parameter name/value pairs to g_object_newv().
#GParamSpec is an object structure that encapsulates the metadata
required to specify parameters, such as e.g.
required to specify parameters, such as e.g.
A #GParamSpec derived structure that contains the meta data for boolean properties.
A #GParamSpec derived structure that contains the meta data for boxed properties.
A #GParamSpec derived structure that contains the meta data for character properties.
The class structure for the GParamSpec type.
A #GParamSpec derived structure that contains the meta data for double properties.
A #GParamSpec derived structure that contains the meta data for enum
properties.
properties.
A `GParamSpec` for properties holding a `GtkExpression`.
A #GParamSpec derived structure that contains the meta data for flags
properties.
properties.
A #GParamSpec derived structure that contains the meta data for float properties.
A #GParamSpec derived structure that contains the meta data for #GType properties.
A #GParamSpec derived structure that contains the meta data for integer properties.
A #GParamSpec derived structure that contains the meta data for 64bit integer properties.
A #GParamSpec derived structure that contains the meta data for long integer properties.
A #GParamSpec derived structure that contains the meta data for object properties.
A #GParamSpec derived structure that redirects operations to
other types of #GParamSpec.
other types of #GParamSpec.
A #GParamSpec derived structure that contains the meta data for %G_TYPE_PARAM
properties.
properties.
A #GParamSpec derived structure that contains the meta data for pointer properties.
A #GParamSpec derived structure that contains the meta data for string
properties.
properties.
This structure is used to provide the type system with the information
required to initialize and destruct (finalize) a parameter's class and
instances thereof.
required to initialize and destruct (finalize) a parameter's class and
instances thereof.
A #GParamSpec derived structure that contains the meta data for unsigned character properties.
A #GParamSpec derived structure that contains the meta data for unsigned integer properties.
A #GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties.
A #GParamSpec derived structure that contains the meta data for unsigned long integer properties.
A #GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties.
A #GParamSpec derived structure that contains the meta data for #GValueArray properties.
A #GParamSpec derived structure that contains the meta data for #GVariant properties.
A location in a parse buffer.
`GtkPasswordEntry` is an entry that has been tailored for entering secrets.
A `GtkEntryBuffer` that locks the underlying memory to prevent it
from being swapped to disk.
from being swapped to disk.
A [class@EntryRow] tailored for entering secrets.
A GPatternSpec struct is the 'compiled' form of a pattern.
A #GPermission represents the status of the caller's permission to
perform a certain action.
perform a certain action.
The `GtkPicture` widget displays a `GdkPaintable`.
A pixel buffer.
An opaque object representing an animation.
Modules supporting animations must derive a type from
#GdkPixbufAnimation, providing suitable implementations of the
virtual functions.
#GdkPixbufAnimation, providing suitable implementations of the
virtual functions.
An opaque object representing an iterator which points to a
certain position in an animation.
certain position in an animation.
Modules supporting animations must derive a type from
#GdkPixbufAnimationIter, providing suitable implementations of the
virtual functions.
#GdkPixbufAnimationIter, providing suitable implementations of the
virtual functions.
A `GdkPixbufFormat` contains information about the image format accepted
by a module.
by a module.
Incremental image loader.
A `GdkPixbufModule` contains the necessary functions to load and save
images in a certain file format.
images in a certain file format.
The signature prefix for a module.
An opaque struct representing a simple animation.
A 2D plane that extends infinitely in a 3D volume.
A point with two coordinates.
A point with three components: X, Y, and Z.
#GPollableInputStream is implemented by #GInputStreams that
can be polled for readiness to read.
can be polled for readiness to read.
The interface for pollable input streams.
#GPollableOutputStream is implemented by #GOutputStreams that
can be polled for readiness to write.
can be polled for readiness to write.
The interface for pollable output streams.
Represents a file descriptor, which events to poll for, and which events
occurred.
occurred.
`GtkPopover` is a bubble-like context popup.
`GtkPopoverMenu` is a subclass of `GtkPopover` that implements menu
behavior.
behavior.
`GtkPopoverMenuBar` presents a horizontal bar of items that pop
up popover menus when clicked.
up popover menus when clicked.
A `GdkPopup` is a surface that is attached to another surface.
The `GdkPopupLayout` struct contains information that is
necessary position a [iface@Gdk.Popup] relative to its parent.
necessary position a [iface@Gdk.Popup] relative to its parent.
#GPowerProfileMonitor makes it possible for applications as well as OS components
to monitor system power profiles and act upon them.
to monitor system power profiles and act upon them.
The virtual function table for #GPowerProfileMonitor.
A group of preference rows.
A page from [class@PreferencesWindow].
A [class@Gtk.ListBoxRow] used to present preferences.
A window to present an application's preferences.
A `GtkPrintContext` encapsulates context information that is required when
drawing pages for printing.
drawing pages for printing.
A `GtkPrinter` object represents a printer.
A `GtkPrintJob` object represents a job that is sent to a printer.
`GtkPrintOperation` is the high-level, portable printing API.
`GtkPrintOperationPreview` is the interface that is used to
implement print preview.
implement print preview.
A `GtkPrintSettings` object represents the settings of a print dialog in
a system-independent way.
a system-independent way.
`GtkPrintUnixDialog` implements a print dialog for platforms
which don’t provide a native print dialog, like Unix.
which don’t provide a native print dialog, like Unix.
The #GPrivate struct is an opaque data structure to represent a
thread-local data key.
thread-local data key.
`GtkProgressBar` is typically used to display the progress of a long
running operation.
running operation.
A #GPropertyAction is a way to get a #GAction with a state value
reflecting and controlling the value of a #GObject property.
reflecting and controlling the value of a #GObject property.
An [class@AnimationTarget] changing the value of a property of a
[class@GObject.Object] instance.
[class@GObject.Object] instance.
A `GObject` property value in a `GtkExpression`.
An event related to the proximity of a tool to a device.
A #GProxy handles connecting to a remote host via a given type of
proxy server.
proxy server.
Support for proxied #GInetSocketAddress.
Class structure for #GProxyAddress.
#GProxyAddressEnumerator is a wrapper around #GSocketAddressEnumerator which
takes the #GSocketAddress instances returned by the #GSocketAddressEnumerator
and wraps them in #GProxyAddress instances, using the given
#GProxyAddressEnumerator:proxy-resolver.
takes the #GSocketAddress instances returned by the #GSocketAddressEnumerator
and wraps them in #GProxyAddress instances, using the given
#GProxyAddressEnumerator:proxy-resolver.
Class structure for #GProxyAddressEnumerator.
Provides an interface for handling proxy connection and payload.
#GProxyResolver provides synchronous and asynchronous network proxy
resolution.
resolution.
The virtual function table for #GProxyResolver.
Contains the public fields of a pointer array.
A 4 vertex quadrilateral, as represented by four #graphene_point_t.
A quaternion.
Contains the public fields of a
[Queue][glib-Double-ended-Queues].
[Queue][glib-Double-ended-Queues].
A render node for a radial gradient.
`GtkRange` is the common base class for widgets which visualize an
adjustment.
adjustment.
A ray emitted from an origin in a given direction.
Meta-data to be passed to gtk_recent_manager_add_full() when
registering a recently used resource.
registering a recently used resource.
`GtkRecentInfo` contains the metadata associated with an item in the
recently used files list.
recently used files list.
`GtkRecentManager` manages and looks up recently used files.
`GtkRecentManagerClass` contains only private data.
The GRecMutex struct is an opaque data structure to represent a
recursive mutex.
recursive mutex.
Record: a structure that is not based on gobject
The location and size of a rectangle region.
A `GdkRectangle` data type for representing rectangles.
The `PangoRectangle` structure represents a rectangle.
The g_regex_*() functions implement regular
expression pattern matching using syntax and semantics similar to
Perl regular expression.
expression pattern matching using syntax and semantics similar to
Perl regular expression.
The GRemoteActionGroup interface is implemented by #GActionGroup
instances that either transmit action invocations to other processes
or receive action invocations in the local process from other
processes.
instances that either transmit action invocations to other processes
or receive action invocations in the local process from other
processes.
The virtual function table for #GRemoteActionGroup.
`GskRenderer` is a class that renders a scene graph defined via a
tree of [class@Gsk.RenderNode] instances.
tree of [class@Gsk.RenderNode] instances.
`PangoRenderer` is a base class for objects that can render text
provided as `PangoGlyphString` or `PangoLayout`.
provided as `PangoGlyphString` or `PangoLayout`.
Class structure for `PangoRenderer`.
`GskRenderNode` is the basic block in a scene graph to be
rendered using [class@Gsk.Renderer].
rendered using [class@Gsk.Renderer].
A render node for a repeating linear gradient.
A render node for a repeating radial gradient.
A render node repeating its single child node.
Represents a request of a screen object in a given orientation.
A `GtkRequisition` represents the desired size of a widget.
#GResolver provides cancellable synchronous and asynchronous DNS
resolution, for hostnames (g_resolver_lookup_by_address(),
g_resolver_lookup_by_name() and their async variants) and SRV
(service) records (g_resolver_lookup_service()).
resolution, for hostnames (g_resolver_lookup_by_address(),
g_resolver_lookup_by_name() and their async variants) and SRV
(service) records (g_resolver_lookup_service()).
Applications and libraries often contain binary or textual data that is
really part of the application, rather than user data.
really part of the application, rather than user data.
A `GtkRevealer` animates the transition of its child from invisible to visible.
A `GdkRGBA` is used to represent a color, in a way that is compatible
with cairo’s notion of color.
with cairo’s notion of color.
`GtkRoot` is the interface implemented by all widgets that can act as a toplevel
widget.
widget.
A render node applying a rounded rectangle clip to its single child.
A rectangular region with rounded corners.
The GRWLock struct is an opaque data structure to represent a
reader-writer lock.
reader-writer lock.
A `GtkScale` is a slider control used to select a numeric value.
`GtkScaleButton` provides a button which pops up a scale widget.
The data structure representing a lexical scanner.
Specifies the #GScanner parser configuration.
A `PangoScriptIter` is used to iterate through a string
and identify ranges in different scripts.
and identify ranges in different scripts.
`GtkScrollable` is an interface for widgets with native scrolling ability.
The `GtkScrollbar` widget is a horizontal or vertical scrollbar.
`GtkScrolledWindow` is a container that makes its child scrollable.
An event related to a scrolling motion.
`GtkSearchBar` is a container made to have a search entry.
`GtkSearchEntry` is an entry widget that has been tailored for use
as a search entry.
as a search entry.
The `GdkSeat` object represents a collection of input devices
that belong to a user.
that belong to a user.
#GSeekable is implemented by streams (implementations of
#GInputStream or #GOutputStream) that support seeking.
#GInputStream or #GOutputStream) that support seeking.
Provides an interface for implementing seekable functionality on I/O Streams.
`GtkSelectionFilterModel` is a list model that presents the selection from
a `GtkSelectionModel`.
a `GtkSelectionModel`.
`GtkSelectionModel` is an interface that add support for selection to list models.
The list of virtual functions for the `GtkSelectionModel` interface.
`GtkSeparator` is a horizontal or vertical separator widget.
The #GSettings class provides a convenient API for storing and retrieving
application settings.
application settings.
`GtkSettings` provides a mechanism to share global settings between
applications.
applications.
The #GSettingsBackend interface defines a generic interface for
non-strictly-typed data that is stored in a hierarchy.
non-strictly-typed data that is stored in a hierarchy.
Class structure for #GSettingsBackend.
The #GSettingsSchemaSource and #GSettingsSchema APIs provide a
mechanism for advanced control over the loading of schemas and a
mechanism for introspecting their content.
mechanism for advanced control over the loading of schemas and a
mechanism for introspecting their content.
#GSettingsSchemaKey is an opaque data structure and can only be accessed
using the following functions.
using the following functions.
This is an opaque structure type.
An object to build the uniforms data for a `GskGLShader`.
The shadow parameters in a shadow node.
A render node drawing one or more shadows behind its single child node.
A `GtkShortcut` describes a keyboard shortcut.
`GtkShortcutAction` encodes an action that can be triggered by a
keyboard shortcut.
keyboard shortcut.
`GtkShortcutController` is an event controller that manages shortcuts.
`GtkShortcutLabel` displays a single keyboard shortcut or gesture.
The `GtkShortcutManager` interface is used to implement
shortcut scopes.
shortcut scopes.
The list of functions that can be implemented for the `GtkShortcutManager`
interface.
interface.
A `GtkShortcutsGroup` represents a group of related keyboard shortcuts
or gestures.
or gestures.
A `GtkShortcutsSection` collects all the keyboard shortcuts and gestures
for a major application mode.
for a major application mode.
A `GtkShortcutsShortcut` represents a single keyboard shortcut or gesture
with a short text.
with a short text.
A `GtkShortcutsWindow` shows information about the keyboard shortcuts
and gestures of an application.
and gestures of an application.
`GtkShortcutTrigger` tracks how a `GtkShortcut` should be activated.
A `GtkShortcut`Action that emits a signal.
#GSignalGroup manages to simplify the process of connecting
many signals to a #GObject as a group.
many signals to a #GObject as a group.
GTK Signal (Callback) resource
Stores java reference to callback in a hash map
Provides functions to disconnect and free signal (with callback)
Default signal callback
The #GSignalInvocationHint structure is used to pass on additional information
to callbacks during a signal emission.
to callbacks during a signal emission.
`GtkSignalListItemFactory` is a `GtkListItemFactory` that emits signals
to to manage listitems.
to to manage listitems.
A structure holding in-depth information for a specific signal.
A #GSimpleAction is the obvious simple implementation of the #GAction
interface.
interface.
#GSimpleActionGroup is a hash table filled with #GAction objects,
implementing the #GActionGroup and #GActionMap interfaces.
implementing the #GActionGroup and #GActionMap interfaces.
As of GLib 2.46, #GSimpleAsyncResult is deprecated in favor of
#GTask, which provides a simpler API.
#GTask, which provides a simpler API.
GSimpleIOStream creates a #GIOStream from an arbitrary #GInputStream and
#GOutputStream.
#GOutputStream.
#GSimplePermission is a trivial implementation of #GPermission that
represents a permission that is either always or never allowed.
represents a permission that is either always or never allowed.
#GSimpleProxyResolver is a simple #GProxyResolver implementation
that handles a single default proxy, multiple URI-scheme-specific
proxies, and a list of hosts that proxies should not be used for.
that handles a single default proxy, multiple URI-scheme-specific
proxies, and a list of hosts that proxies should not be used for.
`GtkSingleSelection` is a `GtkSelectionModel` that allows selecting a single
item.
item.
A size.
`GtkSizeGroup` groups widgets together so they all request the same size.
`GtkSliceListModel` is a list model that presents a slice of another model.
The #GSList struct is used for each element in the singly-linked
list.
list.
Base type for snapshot operations.
`GtkSnapshot` assists in creating [class@Gsk.RenderNode]s for widgets.
A #GSocket is a low-level networking primitive.
#GSocketAddress is the equivalent of struct sockaddr in the BSD
sockets API.
sockets API.
#GSocketAddressEnumerator is an enumerator type for #GSocketAddress
instances.
instances.
Class structure for #GSocketAddressEnumerator.
#GSocketClient is a lightweight high-level utility class for connecting to
a network host using a connection oriented socket type.
a network host using a connection oriented socket type.
Objects that describe one or more potential socket endpoints
implement #GSocketConnectable.
implement #GSocketConnectable.
Provides an interface for returning a #GSocketAddressEnumerator
and #GProxyAddressEnumerator
and #GProxyAddressEnumerator
#GSocketConnection is a #GIOStream for a connected socket.
A #GSocketControlMessage is a special-purpose utility message that
can be sent to or received from a #GSocket.
can be sent to or received from a #GSocket.
Class structure for #GSocketControlMessage.
A #GSocketListener is an object that keeps track of a set
of server sockets and helps you accept sockets from any of the
socket, either sync or async.
of server sockets and helps you accept sockets from any of the
socket, either sync or async.
Class structure for #GSocketListener.
A #GSocketService is an object that represents a service that
is provided to the network or over local sockets.
is provided to the network or over local sockets.
Class structure for #GSocketService.
`GtkSorter` is an object to describe sorting criteria.
The virtual table for `GtkSorter`.
A `GListModel` that sorts the elements of an underlying model
according to a `GtkSorter`.
according to a `GtkSorter`.
The `GSource` struct is an opaque data type
representing an event source.
representing an event source.
The `GSourceCallbackFuncs` struct contains
functions for managing callback objects.
functions for managing callback objects.
The `GSourceFuncs` struct contains a table of
functions used to handle event sources in a generic manner.
functions used to handle event sources in a generic manner.
A sphere, represented by its center and radius.
A `GtkSpinButton` is an ideal way to allow the user to set the
value of some attribute.
value of some attribute.
A `GtkSpinner` widget displays an icon-size spinning animation.
A combined button and dropdown widget.
A spring-based [class@Animation].
Physical parameters of a spring for [class@SpringAnimation].
A best fit container.
An auxiliary class used by [class@Squeezer].
SRV (service) records are used by some network protocols to provide
service-specific aliasing and load-balancing.
service-specific aliasing and load-balancing.
`GtkStack` is a container which only shows one of its children
at a time.
at a time.
`GtkStackPage` is an auxiliary class used by `GtkStack`.
A `GtkStackSidebar` uses a sidebar to switch between `GtkStack` pages.
The `GtkStackSwitcher` shows a row of buttons to switch between `GtkStack`
pages.
pages.
#GStaticResource is an opaque data structure and can only be accessed
using the following functions.
using the following functions.
A `GtkStatusbar` widget is usually placed along the bottom of an application's
main [class@Gtk.Window].
main [class@Gtk.Window].
A page used for empty/error states and similar use-cases.
`GtkStringFilter` determines whether to include items by comparing
strings to a fixed search term.
strings to a fixed search term.
`GtkStringList` is a list model that wraps an array of strings.
`GtkStringObject` is the type of items in a `GtkStringList`.
`GtkStringSorter` is a `GtkSorter` that compares strings.
`GtkStyleContext` stores styling information affecting a widget.
A class for managing application-wide styling.
`GtkStyleProvider` is an interface for style information used by
`GtkStyleContext`.
`GtkStyleContext`.
#GSubprocess allows the creation of and interaction with child
processes.
processes.
This class contains a set of options for launching child processes,
such as where its standard input and output will be directed, the
argument list, the environment, and more.
such as where its standard input and output will be directed, the
argument list, the environment, and more.
A `GdkSurface` is a rectangular region on the screen.
An interface for swipeable widgets.
An interface for swipeable widgets.
A swipe tracker used in [class@Carousel], [class@Flap] and [class@Leaflet].
`GtkSwitch` is a "light switch" that has two states: on or off.
`GtkSymbolicPaintable` is an interface that support symbolic colors in
paintables.
paintables.
The list of virtual functions for the `GtkSymbolicPaintable` interface.
A `PangoTabArray` contains an array of tab stops.
A tab bar for [class@TabView].
An auxiliary class used by [class@TabView].
A dynamic tabbed container.
A #GTask represents and manages a cancellable "task".
This is the subclass of #GSocketConnection that is created
for TCP/IP sockets.
for TCP/IP sockets.
A #GTcpWrapperConnection can be used to wrap a #GIOStream that is
based on a #GSocket, but which is not actually a
#GSocketConnection.
based on a #GSocket, but which is not actually a
#GSocketConnection.
A helper class for testing code which uses D-Bus without touching the user's
session bus.
session bus.
The `GtkText` widget is a single-line text entry widget.
Stores text and attributes for display in a `GtkTextView`.
The class structure for `GtkTextBuffer`.
A `GtkTextChildAnchor` is a spot in a `GtkTextBuffer` where child widgets can
be “anchored”.
be “anchored”.
An iterator for the contents of a `GtkTextBuffer`.
A `GtkTextMark` is a position in a `GtkTextbuffer` that is preserved
across modifications.
across modifications.
A render node drawing a set of glyphs.
A tag that can be applied to text contained in a `GtkTextBuffer`.
The collection of tags in a `GtkTextBuffer`
You may wish to begin by reading the
[text widget conceptual overview](section-text-widget.html),
which gives an overview of all the objects and data types
related to the text widget and how they work together.
You may wish to begin by reading the
[text widget conceptual overview](section-text-widget.html),
which gives an overview of all the objects and data types
related to the text widget and how they work together.
`GdkTexture` is the basic element used to refer to pixel data.
A render node for a `GdkTexture`.
A widget that displays the contents of a [class@Gtk.TextBuffer].
#GThemedIcon is an implementation of #GIcon that supports icon themes.
The #GThread struct represents a running thread.
A #GThreadedSocketService is a simple subclass of #GSocketService
that handles incoming connections by creating a worker thread and
dispatching the connection to it by emitting the
#GThreadedSocketService::run signal in the new thread.
that handles incoming connections by creating a worker thread and
dispatching the connection to it by emitting the
#GThreadedSocketService::run signal in the new thread.
The #GThreadPool struct represents a thread pool.
A `GdkTimeCoord` stores a single event in a motion history.
A time-based [class@Animation].
Represents a precise time, with seconds and microseconds.
#GTimeZone is an opaque structure whose members cannot be accessed
directly.
directly.
TLS (Transport Layer Security, aka SSL) and DTLS backend.
Provides an interface for describing TLS-related types.
A certificate used for TLS authentication and encryption.
#GTlsClientConnection is the client-side subclass of
#GTlsConnection, representing a client-side TLS connection.
#GTlsConnection, representing a client-side TLS connection.
vtable for a #GTlsClientConnection implementation.
#GTlsConnection is the base TLS connection class type, which wraps
a #GIOStream and provides TLS encryption on top of it.
a #GIOStream and provides TLS encryption on top of it.
The class structure for the #GTlsConnection type.
#GTlsDatabase is used to look up certificates and other information
from a certificate or key store.
from a certificate or key store.
The class for #GTlsDatabase.
#GTlsFileDatabase is implemented by #GTlsDatabase objects which load
their certificate information from a file.
their certificate information from a file.
Provides an interface for #GTlsFileDatabase implementations.
#GTlsInteraction provides a mechanism for the TLS connection and database
code to interact with the user.
code to interact with the user.
The class for #GTlsInteraction.
Holds a password used in TLS.
Class structure for #GTlsPassword.
#GTlsServerConnection is the server-side subclass of #GTlsConnection,
representing a server-side TLS connection.
representing a server-side TLS connection.
vtable for a #GTlsServerConnection implementation.
A helper object for [class@ToastOverlay].
A widget showing toasts above its content.
A `GtkToggleButton` is a button which remains “pressed-in” when
clicked.
clicked.
A union holding the value of the token.
`GtkTooltip` is an object representing a widget tooltip.
A `GdkToplevel` is a freestanding toplevel surface.
The `GdkToplevelLayout` struct contains information that
is necessary to present a sovereign window on screen.
is necessary to present a sovereign window on screen.
An event related to a touch-based device.
An event related to a gesture on a touchpad device.
`GskTransform` is an object to describe transform matrices.
A render node applying a `GskTransform` to its single child node.
Each piece of memory that is pushed onto the stack
is cast to a GTrashStack*.
is cast to a GTrashStack*.
The GTree struct is an opaque data structure representing a
[balanced binary tree][glib-Balanced-Binary-Trees].
[balanced binary tree][glib-Balanced-Binary-Trees].
Interface for Drag-and-Drop destinations in `GtkTreeView`.
Interface for Drag-and-Drop destinations in `GtkTreeView`.
`GtkTreeExpander` is a widget that provides an expander for a list.
The `GtkTreeIter` is the primary structure
for accessing a `GtkTreeModel`.
for accessing a `GtkTreeModel`.
`GtkTreeListModel` is a list model that can create child models on demand.
`GtkTreeListRow` is used by `GtkTreeListModel` to represent items.
`GtkTreeListRowSorter` is a special-purpose sorter that will apply a given
sorter to the levels in a tree.
sorter to the levels in a tree.
The tree interface used by GtkTreeView
The `GtkTreeModel` interface defines a generic tree interface for
use by the `GtkTreeView` widget.
The `GtkTreeModel` interface defines a generic tree interface for
use by the `GtkTreeView` widget.
A `GtkTreeModel` which hides parts of an underlying tree model
A `GtkTreeModelFilter` is a tree model which wraps another tree model,
and can do the following things:
- Filter specific rows, based on data from a “visible column”, a column
storing booleans indicating whether the row should be filtered or not,
or based on the return value of a “visible function”, which gets a
model, iter and user_data and returns a boolean indicating whether the
row should be filtered or not.
A `GtkTreeModelFilter` is a tree model which wraps another tree model,
and can do the following things:
- Filter specific rows, based on data from a “visible column”, a column
storing booleans indicating whether the row should be filtered or not,
or based on the return value of a “visible function”, which gets a
model, iter and user_data and returns a boolean indicating whether the
row should be filtered or not.
A GtkTreeModel which makes an underlying tree model sortable
The `GtkTreeModelSort` is a model which implements the `GtkTreeSortable`
interface.
The `GtkTreeModelSort` is a model which implements the `GtkTreeSortable`
interface.
An 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 `GtkTreePath` refers to a position, not a fixed row).
same row (a `GtkTreePath` refers to a position, not a fixed row).
The selection object for GtkTreeView
The `GtkTreeSelection` object is a helper object to manage the selection
for a `GtkTreeView` widget.
The `GtkTreeSelection` object is a helper object to manage the selection
for a `GtkTreeView` widget.
The interface for sortable models used by GtkTreeView
`GtkTreeSortable` is an interface to be implemented by tree models which
support sorting.
`GtkTreeSortable` is an interface to be implemented by tree models which
support sorting.
A tree-like data structure that can be used with the GtkTreeView
The `GtkTreeStore` object is a list model for use with a `GtkTreeView`
widget.
The `GtkTreeStore` object is a list model for use with a `GtkTreeView`
widget.
A widget for displaying both trees and lists
Widget that displays any object that implements the [iface@Gtk.TreeModel] interface.
Widget that displays any object that implements the [iface@Gtk.TreeModel] interface.
A visible column in a [class@Gtk.TreeView] widget
The `GtkTreeViewColumn` object represents a visible column in a `GtkTreeView` widget.
The `GtkTreeViewColumn` object represents a visible column in a `GtkTreeView` widget.
A triangle.
Base Type for all c types and type like structures: Record, Class, Wrapper, Package, Interface...
An opaque structure used as the base of all classes.
A structure that provides information to the type system which is
used specifically for managing fundamental types.
used specifically for managing fundamental types.
This structure is used to provide the type system with the information
required to initialize and destruct (finalize) a type's class and
its instances.
required to initialize and destruct (finalize) a type's class and
its instances.
An opaque structure used as the base of all type instances.
An opaque structure used as the base of all interface types.
#GTypeModule provides a simple implementation of the #GTypePlugin
interface.
interface.
In order to implement dynamic loading of types based on #GTypeModule,
the @load and @unload functions in #GTypeModuleClass must be implemented.
the @load and @unload functions in #GTypeModuleClass must be implemented.
An interface that handles the lifecycle of dynamically loaded types.
The #GTypePlugin interface is used by the type system in order to handle
the lifecycle of dynamically loaded types.
the lifecycle of dynamically loaded types.
A structure holding information for a specific type.
The #GTypeValueTable provides the functions required by the #GValue
implementation, to serve as a container for values of a type.
implementation, to serve as a container for values of a type.
Load user interface from XML descriptions (.ui file).
This is the subclass of #GSocketConnection that is created
for UNIX domain sockets.
for UNIX domain sockets.
This #GSocketControlMessage contains a #GCredentials instance.
Class structure for #GUnixCredentialsMessage.
A #GUnixFDList contains a list of file descriptors.
This #GSocketControlMessage contains a #GUnixFDList.
#GUnixInputStream implements #GInputStream for reading from a UNIX
file descriptor, including asynchronous operations.
file descriptor, including asynchronous operations.
Defines a Unix mount entry (e.g.
Watches #GUnixMounts for changes.
Defines a Unix mount point (e.g.
#GUnixOutputStream implements #GOutputStream for writing to a UNIX
file descriptor, including asynchronous operations.
file descriptor, including asynchronous operations.
Support for UNIX-domain (also known as local) sockets.
The #GUri type and related functions can be used to parse URIs into
their components, and build valid URIs from individual components.
their components, and build valid URIs from individual components.
Many URI schemes include one or more attribute/value pairs as part of the URI
value.
value.
An opaque structure used to hold different types of values.
A #GValueArray contains an array of #GValue elements.
#GVariant is a variant datatype; it can contain one or more values
along with information about the type of the values.
along with information about the type of the values.
A utility type for constructing container-type #GVariant instances.
#GVariantDict is a mutable interface to #GVariant dictionaries.
#GVariantIter is an opaque data structure and can only be accessed
using the following functions.
using the following functions.
This section introduces the GVariant type system.
A structure capable of holding a vector with two dimensions, x and y.
A structure capable of holding a vector with three dimensions: x, y, and z.
A structure capable of holding a vector with four dimensions: x, y, z, and w.
Entry point for using GIO functionality.
`GtkVideo` is a widget to show a `GtkMediaStream` with media controls.
`GtkViewport` implements scrollability for widgets that lack their
own scrolling capabilities.
own scrolling capabilities.
A view container for [class@ViewSwitcher].
An auxiliary class used by [class@ViewStack].
An adaptive view switcher.
A view switcher action bar.
A view switcher title.
The #GVolume interface represents user-visible objects that can be
mounted.
mounted.
`GtkVolumeButton` is a `GtkScaleButton` subclass tailored for
volume control.
volume control.
Interface for implementing operations for mountable volumes.
#GVolumeMonitor is for listing the user interesting devices and volumes
on the computer.
on the computer.
`GdkVulkanContext` is an object representing the platform-specific
Vulkan draw context.
Vulkan draw context.
A structure containing a weak reference to a #GObject.
The base class for all widgets.
`GtkWidgetPaintable` is a `GdkPaintable` that displays the contents
of a widget.
of a widget.
A freeform window.
A `GtkWindow` is a toplevel window which can contain other widgets.
`GtkWindowControls` shows window frame controls.
`GtkWindowGroup` makes group of windows behave like separate applications.
`GtkWindowHandle` is a titlebar area widget.
A helper widget for setting a window's title and subtitle.
#GZlibCompressor is an implementation of #GConverter that
compresses data using zlib.
compresses data using zlib.
#GZlibDecompressor is an implementation of #GConverter that
decompresses data compressed with zlib.
decompresses data compressed with zlib.