Alle Klassen und Schnittstellen
Klasse
Beschreibung
A dialog showing information about the application.
Displays information about a program.
A window showing information about the application.
An interface for describing UI elements for Assistive Technologies.
The common interface for accessible objects.
Wraps a list of references to [iface@Gtk.Accessible] objects.
An interface for accessible objects containing a numeric value.
An interface for accessible objects containing formatted text.
The interface vtable for accessible objects containing text.
A range inside the text of an accessible object.
`GAction` represents a single named action.
Provides a way to associate widgets with actions.
The interface vtable for `GtkActionable`.
Presents contextual actions.
This struct defines a single action.
`GActionGroup` represents a group of actions.
The virtual function table for [type@Gio.ActionGroup].
Manages application level ActionMap and offers Facade for Action Interface
Callbacks for integer and boolean types actions
The virtual function table for [type@Gio.Action].
`GActionMap` is an interface for action containers.
The virtual function table for [iface@Gio.ActionMap].
A [class@Gtk.ListBoxRow] used to present actions.
Activates a widget.
A model for a numeric value.
A dialog presenting a message or a question.
Collects the arguments that are needed to present a message to the user.
Parameters to control the allocation of memory
Memory is usually created by allocators with a gst_allocator_alloc()
method call.
method call.
The #GstAllocator is used to create new memory.
Combines two shortcut 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.
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.
Information about an installed application and methods to launch
it (with file arguments).
it (with file arguments).
Application Information interface, for operating system portability.
`GAppInfoMonitor` monitors application information for changes.
Handles launching an application in a graphical context.
Integrating the launch with the launching application.
A base class for Adwaita applications.
`GApplication` is the core class for application support.
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.
A `GtkWindow` subclass that integrates with `GtkApplication`.
Contains the public fields of a GArray.
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`.
`GAsyncInitable` is an interface for asynchronously initializable objects.
Provides an interface for asynchronous initializing object such that
initialization may fail.
initialization may fail.
`GAsyncResult` provides a base class for implementing asynchronous function results.
Interface definition for [iface@Gio.AsyncResult].
Communicates with platform-specific assistive technologies API.
The #GstAtomicQueue object implements a queue that can be used from multiple
threads without performing any blocking operations.
threads without performing any blocking operations.
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 bar with contextual information.
A widget with one child.
#GstBin is an element that can contain other #GstElement, allowing them to be
managed as a group.
managed as a group.
Subclasses can override #GstBinClass::add_element and #GstBinClass::remove_element
to update the list of children in the bin.
to update the list of children in the bin.
`GObject` instance (or source) and another property on another `GObject`
instance (or target).
instance (or target).
`GBindingGroup` can be used to bind multiple properties
from an object collectively.
from an object collectively.
A layout manager for widgets with a single child.
A fundamental type that describes a 64-bit bitmask
A set of unsigned integers.
Iterates over the elements of a [struct@Gtk.Bitset].
A render node applying a blending function between its two child nodes.
A render node applying a blur effect to its single child.
`GBookmarkFile` lets you parse, edit or create files containing bookmarks.
A list model that wraps `GBookmarkFile`.
Evaluates a boolean expression to determine whether to include items.
Specifies a border around a rectangular area.
A render node for a border.
A bottom sheet with an optional bottom bar.
A 3D box, described as the volume between a minimum and
a maximum vertices.
a maximum vertices.
Arranges child widgets into a single row or column.
Arranges children in a single row or column.
Describes a breakpoint for [class@Window] or [class@Dialog].
A widget that changes layout based on available size.
Describes condition for an [class@Breakpoint].
A Broadway based renderer.
Buffers are the basic unit of data transfer in GStreamer.
Buffered input stream implements [class@Gio.FilterInputStream] and provides
for buffered reads.
for buffered reads.
Buffered output stream implements [class@Gio.FilterOutputStream] and provides
for buffered writes.
for buffered writes.
Buffer lists are an object containing a list of buffers.
A #GstBufferPool is an object that can be used to pre-allocate and recycle
buffers of the same size and with the same properties.
buffers of the same size and with the same properties.
Parameters passed to the gst_buffer_pool_acquire_buffer() function to control the
allocation of the buffer.
allocation of the buffer.
The #GstBufferPool class.
Allows objects to extend and customize deserialization from ui files.
Contains methods to let `GtkBuilder` construct an object from
a `GtkBuilder` UI definition.
a `GtkBuilder` UI definition.
A sub-parser for `GtkBuildable` implementations.
Reads XML descriptions of a user interface and instantiates the described objects.
A `GtkBuilderScope` implementation for the C language.
A `GtkListItemFactory` that creates widgets by instantiating `GtkBuilder`
UI templates.
UI templates.
Provides language binding support to `GtkBuilder`.
The virtual function table to implement for `GtkBuilderScope` implementations.
The #GstBus is an object responsible for delivering #GstMessage packets in
a first-in first-out way from the streaming threads (see #GstTask) to the
application.
a first-in first-out way from the streaming threads (see #GstTask) to the
application.
GStreamer bus class.
Calls a callback function when the button is clicked.
A helper widget for creating buttons.
An event related to a button on a pointer device.
A [class@Gtk.ListBoxRow] that looks like a button.
Contains the public fields of a GByteArray.
Interface for an array of bytes.
A simple reference counted data type representing an immutable sequence of
zero or more bytes from an unspecified origin.
zero or 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.
Represents the platform-specific draw context.
A render node for a Cairo surface.
A GSK renderer that is using cairo.
Displays a Gregorian calendar, one month at a time.
Invokes a callback.
An [class@AnimationTarget] that calls a given callback during the
animation.
animation.
Handler to callback resource.
`GCancellable` allows operations to be cancelled.
Caps (capabilities) are lightweight refcounted objects describing media types.
#GstCapsFeatures can optionally be set on a #GstCaps to add requirements
for additional features for a specific #GstStructure.
for additional features for a specific #GstStructure.
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`.
Arranges three children in a row, keeping the middle child
centered as well as possible.
centered as well as possible.
Manages up to three children.
`GCharsetConverter` is an implementation of [iface@Gio.Converter] based on
[struct@GLib.IConv].
[struct@GLib.IConv].
Places a label next to an indicator.
GLib provides a generic API for computing checksums (or ‘digests’)
for a sequence of arbitrary bytes, using various hashing algorithms
like MD5, SHA-1 and SHA-256.
for a sequence of arbitrary bytes, using various hashing algorithms
like MD5, SHA-1 and SHA-256.
This interface abstracts handling of property sets for elements with
children.
children.
#GstChildProxy interface.
Contains the parameters that define a colorstate with cicp parameters.
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.
Represents data shared between applications or inside an application.
A render node applying a rectangular clip to its single child node.
GStreamer uses a global clock to synchronize the plugins in a pipeline.
GStreamer clock class.
All pending timeouts or periodic notifies are converted into
an entry.
an entry.
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.
Asynchronous API to present a color chooser dialog.
Opens a color chooser dialog to select a color.
A render node controlling the color matrix of its single child node.
A render node for a solid color.
Provides information to interpret colors and pixels in a variety of ways.
A color stop in a gradient node.
Presents a large dynamic list of items using multiple columns with headers.
Represents items in a cell in [class@Gtk.ColumnView].
`GtkColumnViewColumn` represents the columns being added to a `GtkColumnView`.
Configures how rows are displayed in a [class@Gtk.ColumnView].
Sorts [class@Gtk.ColumnView] columns.
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.
`GCompletion` provides support for automatic completion of a string
using any group of target strings.
using any group of target strings.
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`.
Describes a constraint between attributes of two widgets,
expressed as a linear equation.
expressed as a linear equation.
An invisible layout element in a `GtkConstraintLayout`.
Uses constraints to describe relations between widgets.
`GtkLayoutChild` subclass for children in a `GtkConstraintLayout`.
Makes it possible to use an object as source or target in a
[class@Gtk.Constraint].
[class@Gtk.Constraint].
A render node that can contain other render nodes.
Deserializes content received via inter-application data transfers.
Used to advertise and negotiate the format of content.
Creates `GdkContentFormats` objects.
Provides content for the clipboard or for drag-and-drop operations
in a number of formats.
in a number of formats.
Class structure for `GdkContentProvider`.
Serializes content for inter-application data transfers.
#GstContext is a container object used to store contexts like a device
context, a display server connection and similar concepts that should
be shared between multiple elements.
context, a display server connection and similar concepts that should
be shared between multiple elements.
A `PangoContext` stores global information used to control the
itemization process.
itemization process.
A base class for value mapping objects that attaches control sources to #GObject
properties.
properties.
The class structure of #GstControlBinding.
The #GstControlSource is a base class for control value sources that could
be used to get timestamp-value pairs.
be used to get timestamp-value pairs.
The class structure of #GstControlSource.
`GConverter` is an interface for streaming conversions.
Provides an interface for converting data from one type
to another type.
to another type.
Converter input stream implements [class@Gio.InputStream] and allows
conversion of data of various types during reading.
conversion of data of various types during reading.
Converter output stream implements [class@Gio.OutputStream] 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.
Points at a location inside a CSS stream.
A style provider for CSS.
Defines a part of a CSS document.
Used to create and destroy cursors.
Determines whether to include items with a callback.
Uses closures for size negotiation.
Extra custom metadata.
Sorts items via a callback function.
Interface for socket-like objects with datagram semantics.
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 [class@Gio.InputStream] and includes functions
for reading structured data directly from a binary input stream.
for reading structured data directly from a binary input stream.
Data output stream implements [class@Gio.OutputStream] and includes functions
for writing data directly to an output stream.
for writing data directly to an output stream.
`GDate` is a struct for calendrical calculations.
`GDateTime` is a structure that combines a Gregorian date and time
into a single structure.
into a single structure.
Struct to store date, time and timezone information altogether.
`GDBusActionGroup` is an implementation of the [iface@Gio.ActionGroup]
interface.
interface.
Information about an annotation.
Information about an argument for a method or a signal.
`GDBusAuthObserver` provides a mechanism for participating
in how a [class@Gio.DBusServer] (or a [class@Gio.DBusConnection])
authenticates remote peers.
in how a [class@Gio.DBusServer] (or a [class@Gio.DBusConnection])
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().
Base type for D-Bus interfaces.
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 [class@Gio.MenuModel] that can be
used as a proxy for a menu model that is exported over D-Bus with
[method@Gio.DBusConnection.export_menu_model].
used as a proxy for a menu model that is exported over D-Bus with
[method@Gio.DBusConnection.export_menu_model].
A type for representing D-Bus messages that can be sent or received
on a [class@Gio.DBusConnection].
on a [class@Gio.DBusConnection].
Information about a method on a 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 [class@Gio.DBusObjectSkeleton]) and the client side
(see [class@Gio.DBusObjectProxy]).
the service side (see [class@Gio.DBusObjectSkeleton]) and the client side
(see [class@Gio.DBusObjectProxy]).
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 [class@Gio.DBusObjectManagerServer]
(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 [class@Gio.DBusObjectManagerServer]
(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 [iface@Gio.DBusObject] instances
using the standardized
[`org.freedesktop.DBus.ObjectManager`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface.
using 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().
This is the struct that describes the categories.
`GDebugController` is an interface to expose control of debugging features and
debug output.
debug output.
`GDebugControllerDBus` is an implementation of [iface@Gio.DebugController]
which exposes debug settings as a D-Bus object.
which exposes 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 [iface@Gio.AppInfo] 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.
Represents an input device, such as a keyboard, mouse or touchpad.
#GstDevice are objects representing a device, they contain
relevant metadata about the device, such as its class and the #GstCaps
representing the media types it can produce or handle.
relevant metadata about the device, such as its class and the #GstCaps
representing the media types it can produce or handle.
The class structure for a #GstDevice object.
Applications should create a #GstDeviceMonitor when they want
to probe, list and monitor devices of a specific type.
to probe, list and monitor devices of a specific type.
Opaque device monitor class structure.
An interface for tablet pad devices.
A #GstDeviceProvider subclass is provided by a plugin that handles devices
if there is a way to programmatically list connected devices.
if there is a way to programmatically list connected devices.
The structure of the base #GstDeviceProviderClass
#GstDeviceProviderFactory is used to create instances of device providers.
A physical tool associated to a `GdkDevice`.
An adaptive dialog container.
Dialogs are a convenient way to prompt the user for a small amount
of input.
of input.
An opaque structure representing an opened directory.
A list model that wraps [method@Gio.File.enumerate_children_async].
A representation of a workstation.
Offers notification when displays appear or disappear.
Provides information about supported DMA buffer formats.
A `GdkTexture` representing a DMA buffer.
Constructs [class@Gdk.Texture] objects from DMA buffers.
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.
A fundamental type that describes a #gdouble range
Represents the source of an ongoing DND operation.
A `GtkRoot` implementation for drag icons.
An event controller to initiate Drag-And-Drop operations.
A surface that is used during DND.
Base class for objects implementing different rendering methods.
Allows drawing with cairo.
`GDrive` represents a piece of hardware connected to the machine.
Interface for creating #GDrive implementations.
Represents the target of an ongoing DND operation.
An event controller tracking the pointer during Drag-and-Drop operations.
Allows the user to choose an item from a list of options.
An event controller to receive Drag-and-Drop operations.
An event controller to receive Drag-and-Drop operations, asynchronously.
`GDtlsClientConnection` is the client-side subclass of
[iface@Gio.DtlsConnection], representing a client-side DTLS connection.
[iface@Gio.DtlsConnection], representing a client-side DTLS connection.
vtable for a #GDtlsClientConnection implementation.
`GDtlsConnection` is the base DTLS connection class type, which wraps
a [iface@Gio.DatagramBased] and provides DTLS encryption on top of it.
a [iface@Gio.DatagramBased] and provides DTLS encryption on top of it.
Virtual method table for a #GDtlsConnection implementation.
`GDtlsServerConnection` is the server-side subclass of
[iface@Gio.DtlsConnection], representing a server-side DTLS connection.
[iface@Gio.DtlsConnection], representing a server-side DTLS connection.
vtable for a #GDtlsServerConnection implementation.
#GstDynamicTypeFactory is used to represent a type that can be
automatically loaded the first time it is used.
automatically loaded the first time it is used.
Interface for single-line text editing widgets.
Allows users to edit the displayed text by switching to an “edit mode”.
GstElement is the abstract base class needed to construct an element that
can be used in a GStreamer pipeline.
can be used in a GStreamer pipeline.
GStreamer element class.
#GstElementFactory is used to create instances of elements.
`GEmblem` is an implementation of [iface@Gio.Icon] 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 [iface@Gio.Icon] that supports
adding an emblem to an icon.
adding an emblem to an icon.
Used by text widgets to let users insert Emoji characters.
A single-line text entry widget.
Holds the text that is displayed in a single-line text entry 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.
Represents windowing system events.
The event class provides factory methods to construct events for sending
and functions to query (parse) received events.
and functions to query (parse) received events.
The base class for event controllers.
Tracks keyboard focus.
Provides access to key events.
Provides raw access to the event stream.
Tracks the pointer position.
Handles scroll events.
An opaque type representing a sequence of related events.
Matches an item when each of its filters matches.
Allows the user to reveal or conceal a child widget.
A [class@Gtk.ListBoxRow] used to reveal widgets.
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 an interface for file descriptor based IO.
An interface for file descriptor based io objects.
Asynchronous API to present a file chooser dialog.
`GFileEnumerator` allows you to operate on a set of [iface@Gio.File] objects,
returning a [class@Gio.FileInfo] structure for each file enumerated (e.g.
returning a [class@Gio.FileInfo] structure for each file enumerated (e.g.
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.
Stores information about a file system object referenced by a [iface@Gio.File].
`GFileInputStream` provides input streams that take their
content from a file.
content from a file.
`GFileIOStream` provides I/O streams that both read and write to the same
file handle.
file handle.
Asynchronous API to open a file with an application.
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 render node filling the area given by [struct@Gsk.Path]
and [enum@Gsk.FillRule] with the child node.
and [enum@Gsk.FillRule] with the child node.
Describes the filtering to be performed by a [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.
A list model that filters the elements of another model.
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.
Places its child widgets at fixed positions and with fixed sizes.
Places child widgets 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 fundamental type that describes a 32-bit flag bitfield, with 32-bit
mask indicating which of the bits in the field are explicitly set.
mask indicating which of the bits in the field are explicitly set.
A structure which contains a single flags value, its name, and its
nickname.
nickname.
An adaptive container acting like a box or an overlay.
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.
Puts child widgets in a reflowing grid.
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.
Asynchronous API to present a font chooser dialog.
Opens a font chooser dialog to select a font.
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.
A format definition
A fundamental type that describes a fraction of an integer numerator
over an integer denominator
over an integer denominator
A fundamental type that describes a #GstFractionRange range
Surrounds its child with a decorative frame and an optional label.
Tells the application when to update and repaint a surface.
Holds timing information for a single frame of the application’s displays.
A 3D volume delimited by 2D clip planes.
The base class for gesture recognition.
Recognizes click gestures.
Recognizes drag gestures.
Recognizes long press gestures.
Recognizes pan gestures.
Recognizes 2-finger rotation gestures.
A `GtkGesture` subclass optimized for singe-touch and mouse gestures.
Recognizes tablet stylus input.
Recognizes swipe gestures.
Recognizes 2-finger pinch/zoom gestures.
GhostPads are useful when organizing pipelines with #GstBin like elements.
Allows drawing with OpenGL.
The `GtkGLAreaClass` structure contains only private data.
Represents a platform-specific OpenGL draw context.
A GL based renderer.
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.
Constructs [class@Gdk.Texture] objects from GL textures.
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.
Bypasses gsk rendering by passing the content of its child directly to the compositor.
Arranges its child widgets in rows and columns.
Arranges child widgets in rows and columns.
`GtkLayoutChild` subclass for children in a `GtkGridLayout`.
Presents a large dynamic grid of items.
A `GString` is an object that handles the memory management of a C string.
The #GHashTable struct is an opaque data structure to represent a
[Hash Table](data-structures.html#hash-tables).
[Hash Table](data-structures.html#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.
Creates a custom titlebar for a window.
HMACs should be used when producing a cookie or hash based on data
and a key.
and a key.
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`.
Loads themed icons.
`GtkIconView` is a widget which displays data in a grid of icons.
A #GstIdStr is string type optimized for short strings and used for structure
names, structure field names and in other places.
names, structure field names and in other places.
Displays an image.
The interface for GTK input methods.
Supports compose sequences, dead keys and numeric Unicode input.
Supports switching between multiple 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.
`GtkInfoBar` can be used to 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.
A view switcher that uses a toggle group.
Structure used for scatter/gather data input when receiving multiple
messages or packets in one go.
messages or packets in one go.
`GInputStream` is a base class for implementing streaming input.
Structure used for scatter/gather data input.
Shows text in a predefined area.
A render node for an inset shadow.
https://www.w3schools.com/java/java_data_types.asp
A fundamental type that describes a #gint64 range
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 fundamental type that describes a #gint range
The `GIOChannel` data type aims to provide a portable method for
using file descriptors, pipes, and sockets, and integrating them
into the main event loop (see [struct@GLib.MainContext]).
using file descriptors, pipes, and sockets, and integrating them
into the main event loop (see [struct@GLib.MainContext]).
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.
A GstIterator is used to retrieve multiple objects from another object in
a threadsafe way.
a threadsafe way.
Util class for location-independent access to program specific resources.
An event related to a key-based device.
`GKeyFile` parses .ini-like config files.
Represents a hardware key that can be mapped to a keyval.
Triggers when a specific keyval and modifiers are pressed.
Displays a small amount of text.
The `PangoLanguage` structure is used to
represent a language.
represent a language.
An individual layout in [class@MultiLayoutView].
A `PangoLayout` structure represents an entire paragraph of text.
The base class for objects that are meant to hold 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`.
Handles the preferred size and allocation for children 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`.
A child slot within [class@Layout].
An adaptive container acting like a box or a stack.
An auxiliary class used by [class@Leaflet].
Shows a level indicator.
A render node for a linear gradient.
A button with a hyperlink.
The #GList struct is used for each element in a doubly-linked list.
The abstract base class for GTK's list widgets.
Shows a vertical list.
The kind of widget that can be added to a `GtkListBox`.
Used by list widgets to represent the headers they display.
A ListModel that provides indices for n items.
Used by list widgets to represent items in a [iface@Gio.ListModel].
Creates widgets for the items taken from a `GListModel`.
`GListModel` is an interface that represents a mutable list of
[class@GObject.Object].
[class@GObject.Object].
The virtual function table for #GListModel.
`GListStore` is a simple implementation of [iface@Gio.ListModel] that stores
all items in memory.
all items in memory.
A list-like data structure that can be used with the [class@Gtk.TreeView].
Presents a large dynamic list of items.
`GLoadableIcon` extends the [iface@Gio.Icon] interface and adds the ability
to load icons from streams.
to 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 structure containing the result of a map operation such as
gst_memory_map().
gst_memory_map().
A list model that maps the items in another 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 render node masking one child node with another.
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.
Shows controls for video playback.
Implements the `GtkMediaStream` interface for files.
The integration point for media playback inside GTK.
GstMemory is a lightweight refcounted object that wraps a region of memory.
`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.
Constructs [class@Gdk.Texture] objects from system memory provided
via [struct@GLib.Bytes].
via [struct@GLib.Bytes].
A set of functions used to perform memory allocation.
`GMenu` is a simple implementation of [class@Gio.MenuModel].
#GMenuAttributeIter is an opaque structure type.
Displays 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.
Messages are implemented as a subclass of #GstMiniObject with a generic
#GstStructure as the content.
#GstStructure as the content.
A dialog presenting a message or a question.
`GtkMessageDialog` presents a dialog with some message text.
The #GstMeta structure should be included as the first member of a #GstBuffer
metadata structure.
metadata structure.
The #GstMetaInfo provides information about a specific metadata
structure.
structure.
Extra data passed to a "gst-copy" transform #GstMetaTransformFunction.
#GstMiniObject is a simple structure that can be used to implement refcounted
types.
types.
Activates a widget with a mnemonic.
Triggers when a specific mnemonic is pressed.
Represents the individual outputs that are associated with a `GdkDisplay`.
An event related to a pointer or touch device motion.
The `GMount` interface represents a user-visible mount, such as a mounted
file system.
file system.
Interface for implementing operations for mounts.
`GMountOperation` provides a mechanism for interacting with the user.
Asks the user for passwords and other information required to
mount a volume.
mount a volume.
Base class for filters that combine multiple filters.
A widget for switching between different layouts.
A selection model that allows selecting multiple elements.
Combines multiple sorters by trying them in turn.
The #GMutex struct is an opaque data structure to represent a mutex
(mutual exclusion).
(mutual exclusion).
Activates a named action.
An interface for widgets that have their own [class@Gdk.Surface].
Base class for platform dialogs that don't use `GtkDialog`.
Class structure for `GtkNativeDialog`.
A socket address of some unknown native type.
A page within [class@NavigationView] or [class@NavigationSplitView].
A widget presenting sidebar and content side by side or as a navigation view.
A page-based navigation container.
`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 [class@Gio.NetworkAddress] 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.
A GL based renderer.
The #GNode struct represents one node in a [n-ary tree](data-structures.html#n-ary-trees).
A selection model that does not allow selecting anything.
Switches between children using tabs.
An auxiliary object used by `GtkNotebook`.
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.
Sorts items numerically.
The base object type.
#GstObject provides a root for the object hierarchy tree filed in by the
GStreamer library.
GStreamer library.
The class structure for the GObject type.
GStreamer base object class.
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.
- %G_OPTION_ARG_NONE: %gboolean
- %G_OPTION_ARG_STRING: %gchar*
- %G_OPTION_ARG_INT: %gint
- %G_OPTION_ARG_FILENAME: %gchar*
- %G_OPTION_ARG_STRING_ARRAY: %gchar**
- %G_OPTION_ARG_FILENAME_ARRAY: %gchar**
- %G_OPTION_ARG_DOUBLE: %gdouble
If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME,
the location will contain a newly allocated string if the option
was given.
- %G_OPTION_ARG_STRING: %gchar*
- %G_OPTION_ARG_INT: %gint
- %G_OPTION_ARG_FILENAME: %gchar*
- %G_OPTION_ARG_STRING_ARRAY: %gchar**
- %G_OPTION_ARG_FILENAME_ARRAY: %gchar**
- %G_OPTION_ARG_DOUBLE: %gdouble
If @arg type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME,
the location will contain a newly allocated string if the option
was given.
A `GOptionGroup` struct defines the options in a single
group.
group.
An interface for widgets that can be 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` is a base class for implementing streaming output.
Structure used for scatter/gather data output.
A render node for an outset shadow.
Unknown type.
Places “overlay” widgets on top of a single main child.
The layout manager used by [class@Gtk.Overlay].
`GtkLayoutChild` subclass for children in a `GtkOverlayLayout`.
A widget presenting sidebar and content side by side or as an overlay.
Base type for package functions class
A #GstElement is linked to other elements via "pads", which are extremely
light-weight generic link points.
light-weight generic link points.
Struct defining a pad action entry.
Handles input from the pads found in drawing tablets.
An event related to a pad-based device.
Info passed in the #GstPadProbeCallback.
Padtemplates describe the possible media types a pad or an elementfactory can
handle.
handle.
A range of pages to print.
Stores page size, orientation and margins for printing.
Presents a page setup dialog for platforms which don’t provide
a native page setup dialog, like Unix.
a native page setup dialog, like Unix.
An interface for content that can be painted.
The list of functions that can be implemented for the `GdkPaintable`
interface.
interface.
Arranges its children in two panes, horizontally or vertically.
`GtkPaperSize` handles paper sizes.
A fundamental type that describes a #GParamSpec for arrays of
values
values
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().
A fundamental type that describes a #GParamSpec for fractional
properties
properties
`GParamSpec` encapsulates the metadata required to specify parameters, such as `GObject` properties.
A GParamSpec derived structure for arrays of values.
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 fractional
properties.
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.
The #GstParentBufferMeta is a #GstMeta which can be attached to a #GstBuffer
to hold a reference to another buffer that is only released when the child
#GstBuffer is released.
to hold a reference to another buffer that is only released when the child
#GstBuffer is released.
Opaque structure.
A location in a parse buffer.
A single-line text entry widget for entering passwords and other 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.
Describes lines and curves that are more complex than simple rectangles.
`GPathBuf` is a helper type that allows you to easily build paths from
individual elements, using the platform specific conventions for path
separators.
individual elements, using the platform specific conventions for path
separators.
Constructs `GskPath` objects.
Performs measurements on paths such as determining the length of the path.
An opaque type representing a point on a path.
A `GPatternSpec` struct is the ‘compiled’ form of a glob-style pattern.
A `GPermission` represents the status of the caller’s permission to
perform a certain action.
perform a certain action.
Displays a `GdkPaintable`.
A #GstPipeline is a special #GstBin used as the toplevel container for
the filter graph.
the filter graph.
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.
GStreamer is extensible, so #GstElement instances can be loaded at runtime.
A plugin should export a variable of this type called plugin_desc.
This is a base class for anything that can be added to a #GstPlugin.
A point with two coordinates.
A point with three components: X, Y, and Z.
`GPollableInputStream` is implemented by [class@Gio.InputStream]s 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 [class@Gio.OutputStream]s 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.
A file descriptor object.
Presents a bubble-like popup.
A subclass of `GtkPopover` that implements menu behavior.
Presents a horizontal bar of items that pop up menus when clicked.
A surface that is attached to another surface.
Contains information that is necessary position a [iface@Gdk.Popup]
relative to its parent.
relative to its parent.
`GPowerProfileMonitor` makes it possible for applications as well as OS
components to monitor system power profiles and act upon them.
components to monitor system power profiles and act upon them.
The virtual function table for #GPowerProfileMonitor.
A dialog showing application's preferences.
A group of preference rows.
A page from [class@PreferencesDialog].
A [class@Gtk.ListBoxRow] used to present preferences.
A window to present an application's preferences.
This interface offers methods to query and manipulate parameter preset sets.
#GstPreset interface.
Encapsulates context information that is required when
drawing pages for printing.
drawing pages for printing.
Asynchronous API to present a print dialog to the user.
Represents a printer.
Represents a job that is sent to a printer.
High-level, portable printing API.
The interface that is used to implement print preview.
Collects the settings of a print dialog in a system-independent way.
An auxiliary object for printing that allows decoupling the setup from the printing.
A print dialog for platforms which don’t provide a native
print dialog, like Unix.
print dialog, like Unix.
The #GPrivate struct is an opaque data structure to represent a
thread-local data key.
thread-local data key.
Displays the progress of a long-running operation.
The #GstPromise object implements the container for values that may
be available later. i.e. a Future or a Promise in
<https://en.wikipedia.org/wiki/Futures_and_promises>.
be available later. i.e. a Future or a Promise in
<https://en.wikipedia.org/wiki/Futures_and_promises>.
A `GPropertyAction` is a way to get a [iface@Gio.Action] with a state value
reflecting and controlling the value of a [class@GObject.Object] property.
reflecting and controlling the value of a [class@GObject.Object] 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`.
Metadata type that holds information about a sample from a protection-protected
track, including the information needed to decrypt it (if it is encrypted).
track, including the information needed to decrypt it (if it is encrypted).
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.
A [class@Gio.InetSocketAddress] representing a connection via a proxy server.
Class structure for #GProxyAddress.
`GProxyAddressEnumerator` is a wrapper around
[class@Gio.SocketAddressEnumerator] which takes the [class@Gio.SocketAddress]
instances returned by the [class@Gio.SocketAddressEnumerator]
and wraps them in [class@Gio.ProxyAddress] instances, using the given
[property@Gio.ProxyAddressEnumerator:proxy-resolver].
[class@Gio.SocketAddressEnumerator] which takes the [class@Gio.SocketAddress]
instances returned by the [class@Gio.SocketAddressEnumerator]
and wraps them in [class@Gio.ProxyAddress] instances, using the given
[property@Gio.ProxyAddressEnumerator: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.
Queries can be performed on pads (gst_pad_query()) and elements
(gst_element_query()).
(gst_element_query()).
Contains the public fields of a
[Queue](data-structures.html#double-ended-queues).
[Queue](data-structures.html#double-ended-queues).
A render node for a radial gradient.
The GRand struct is an opaque data structure.
Base class for widgets which visualize an 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.
Contains the metadata associated with an item in the
recently used files list.
recently used files list.
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.
Represents a rectangle.
The `PangoRectangle` structure represents a rectangle.
#GstReferenceTimestampMeta can be used to attach alternative timestamps and
possibly durations to a #GstBuffer.
possibly durations to a #GstBuffer.
A `GRegex` is the "compiled" form of a regular expression pattern.
One registry holds the metadata of a set of plugins.
The `GRemoteActionGroup` interface is implemented by [iface@Gio.ActionGroup]
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.
A class that renders a scene graph defined via a tree of
[class@Gsk.RenderNode] instances.
[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.
Represents the desired size of a widget.
The object that handles DNS resolution.
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.
Animates the transition of its child from invisible to visible.
Represents a color, in a way that is compatible with cairo’s notion of color.
An interface for widgets that can act as the root of a widget hierarchy.
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 #GstSample is a small object containing data, a type, timing and
extra arbitrary information.
extra arbitrary information.
Allows to select a numeric value with a slider control.
Provides a button which pops up a scale widget.
`GScanner` provides a general-purpose 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.
An interface for widgets with native scrolling ability.
Shows a horizontal or vertical scrollbar.
Makes its child scrollable.
An event related to a scrolling motion.
Provides detailed information on how a scroll operation should be performed.
Reveals a search entry when search is started.
A single-line text entry widget for use as a search entry.
Represents a collection of input devices that belong to a user.
An interface that adds support for sections to list models.
The list of virtual functions for the `GtkSectionModel` interface.
`GSeekable` is implemented by streams (implementations of
[class@Gio.InputStream] or [class@Gio.OutputStream]) that support seeking.
[class@Gio.InputStream] or [class@Gio.OutputStream]) that support seeking.
Provides an interface for implementing seekable functionality on I/O Streams.
This helper structure holds the relevant values for tracking the region of
interest in a media file, called a segment.
interest in a media file, called a segment.
A list model that presents the selection from a `GtkSelectionModel`.
An interface that adds support for selection to list models.
The list of virtual functions for the `GtkSelectionModel` interface.
Draws a horizontal or vertical line to separate other widgets.
The `GSettings` class provides a convenient API for storing and retrieving
application settings.
application settings.
Provides a mechanism to share global settings between 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 [struct@Gio.SettingsSchemaSource] 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.
Builds 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.
The #GstSharedTaskPool object.
The #GstSharedTaskPoolClass object.
Describes a keyboard shortcut.
Encodes an action that can be triggered by a keyboard shortcut.
Manages keyboard shortcuts and their activation.
`GtkShortcutLabel` displays a single keyboard shortcut or gesture.
An interface that is used to implement 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.
Tracks how a `GtkShortcut` can be activated.
Emits a signal on a widget.
`GSignalGroup` manages a collection of signals on a `GObject`.
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.
A `GtkListItemFactory` that emits signals to manage listitems.
A structure holding in-depth information for a specific signal.
A `GSimpleAction` is the obvious simple implementation of the
[iface@Gio.Action] interface.
[iface@Gio.Action] interface.
`GSimpleActionGroup` is a hash table filled with [iface@Gio.Action] objects,
implementing the [iface@Gio.ActionGroup] and [iface@Gio.ActionMap]
interfaces.
implementing the [iface@Gio.ActionGroup] and [iface@Gio.ActionMap]
interfaces.
As of GLib 2.46, `GSimpleAsyncResult` is deprecated in favor of
[class@Gio.Task], which provides a simpler API.
[class@Gio.Task], which provides a simpler API.
`GSimpleIOStream` creates a [class@Gio.IOStream] from an arbitrary
[class@Gio.InputStream] and [class@Gio.OutputStream].
[class@Gio.InputStream] and [class@Gio.OutputStream].
`GSimplePermission` is a trivial implementation of [class@Gio.Permission]
that represents a permission that is either always or never allowed.
that represents a permission that is either always or never allowed.
`GSimpleProxyResolver` is a simple [iface@Gio.ProxyResolver] 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.
A selection model that allows selecting a single item.
A size.
Groups widgets together so they all request the same size.
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.
Assists in creating [class@Gsk.RenderNode]s for widgets.
A `GSocket` is a low-level networking primitive.
`GSocketAddress` is the equivalent of
[`struct sockaddr`](man:sockaddr(3type)) and its subtypes in the BSD sockets
API.
[`struct sockaddr`](man:sockaddr(3type)) and its subtypes in the BSD sockets
API.
`GSocketAddressEnumerator` is an enumerator type for
[class@Gio.SocketAddress] instances.
[class@Gio.SocketAddress] 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 [class@Gio.IOStream] for a connected socket.
A `GSocketControlMessage` is a special-purpose utility message that
can be sent to or received from a [class@Gio.Socket].
can be sent to or received from a [class@Gio.Socket].
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.
Describes sorting criteria for a [class@Gtk.SortListModel].
The virtual table for `GtkSorter`.
A list model that sorts the elements of another model.
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.
Allows to enter or change numeric values.
A widget showing a loading spinner.
Displays an icon-size spinning animation.
A paintable showing a loading spinner.
An [class@ActionRow] with an embedded spin button.
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].
A single target host/port that a network service is running on.
Shows one of its children at a time.
An auxiliary class used by `GtkStack`.
Uses a sidebar to switch between `GtkStack` pages.
Shows a row of buttons to switch between `GtkStack` pages.
Data structure to initialize #GstCaps from a string description usually
used in conjunction with GST_STATIC_CAPS() and gst_static_caps_get() to
instantiate a #GstCaps.
used in conjunction with GST_STATIC_CAPS() and gst_static_caps_get() to
instantiate a #GstCaps.
A #GStaticMutex works like a #GMutex.
Structure describing the #GstStaticPadTemplate.
A #GStaticPrivate works almost like a #GPrivate, but it has one
significant advantage.
significant advantage.
A #GStaticRecMutex works like a #GStaticMutex, but it can be locked
multiple times by one thread.
multiple times by one thread.
`GStaticResource` is an opaque data structure and can only be accessed
using the following functions.
using the following functions.
The #GStaticRWLock struct represents a read-write lock.
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.
A high-level object representing a single stream.
GstStream class structure
A collection of #GstStream that are available.
GstStreamCollection class structure
Determines whether to include items by comparing strings to a fixed search term.
A list model that wraps an array of strings.
The type of items in a `GtkStringList`.
Sorts items by comparing strings.
Collects the parameters that are needed when stroking a path.
A render node that will fill the area determined by stroking the the given
[struct@Gsk.Path] using the [struct@Gsk.Stroke] attributes.
[struct@Gsk.Path] using the [struct@Gsk.Stroke] attributes.
A #GstStructure is a collection of key/value pairs.
`GStrvBuilder` is a helper object to build a %NULL-terminated string arrays.
`GtkStyleContext` stores styling information affecting a widget.
A class for managing application-wide styling.
An interface for style information used by [class@Gtk.StyleContext].
`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 render node that potentially diverts a part of the scene graph to a subsurface.
Represents a rectangular region on the screen.
An interface for swipeable widgets.
An interface for swipeable widgets.
A swipe tracker used in [class@Carousel], [class@NavigationView] and
[class@OverlaySplitView].
[class@OverlaySplitView].
Shows a "light switch" that has two states: on or off.
A [class@Gtk.ListBoxRow] used to represent two states.
An interface that supports symbolic colors in paintables.
The list of virtual functions for the `GtkSymbolicPaintable` interface.
The GStreamer core provides a GstSystemClock based on the system time.
A `PangoTabArray` contains an array of tab stops.
A tab bar for [class@TabView].
A button that displays the number of [class@TabView] pages.
A tab overview for [class@TabView].
An auxiliary class used by [class@TabView].
A dynamic tabbed container.
List of tags and values used to describe media metadata.
Element interface that allows setting of media metadata.
#GstTagSetterInterface interface.
A `GTask` represents and manages a cancellable ‘task’.
#GstTask is used by #GstElement and #GstPad to provide the data passing
threads in a #GstPipeline.
threads in a #GstPipeline.
This object provides an abstraction for creating threads.
The #GstTaskPoolClass object.
This is the subclass of [class@Gio.SocketConnection] that is created
for TCP/IP sockets.
for TCP/IP sockets.
A `GTcpWrapperConnection` can be used to wrap a [class@Gio.IOStream] that is
based on a [class@Gio.Socket], but which is not actually a
[class@Gio.SocketConnection].
based on a [class@Gio.Socket], but which is not actually a
[class@Gio.SocketConnection].
A helper class for testing code which uses D-Bus without touching the user’s
session bus.
session bus.
A single-line text entry.
Stores text and attributes for display in a `GtkTextView`.
The class structure for `GtkTextBuffer`.
Marks a spot in a `GtkTextBuffer` where child widgets can be “anchored”.
Iterates over the contents of a `GtkTextBuffer`.
Marks a position in a `GtkTextbuffer` that is preserved
across modifications.
across modifications.
A render node drawing a set of glyphs.
Can be applied to text contained in a `GtkTextBuffer`.
Collects the tags in a `GtkTextBuffer`.
Refers to pixel data in various forms.
Used to download the contents of a [class@Gdk.Texture].
A render node for a `GdkTexture`.
A render node for a `GdkTexture`, with control over scaling.
Displays the contents of a [class@Gtk.TextBuffer].
`GThemedIcon` is an implementation of [iface@Gio.Icon] that supports icon
themes.
themes.
The #GThread struct represents a running thread.
#GThreadedResolver is an implementation of #GResolver which calls the libc
lookup functions in threads to allow them to run asynchronously.
lookup functions in threads to allow them to run asynchronously.
A `GThreadedSocketService` is a simple subclass of [class@Gio.SocketService]
that handles incoming connections by creating a worker thread and
dispatching the connection to it by emitting the
[signal@Gio.ThreadedSocketService::run signal] in the new thread.
that handles incoming connections by creating a worker thread and
dispatching the connection to it by emitting the
[signal@Gio.ThreadedSocketService::run signal] in the new thread.
This function table is no longer used by g_thread_init()
to initialize the thread system.
to initialize the thread system.
The `GThreadPool` struct represents a thread pool.
Stores a single event in a motion history.
A time-based [class@Animation].
Structure for storing a timestamp and a value.
Represents a precise time, with seconds and microseconds.
A `GTimeZone` represents a time zone, at no particular point in time.
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
[class@Gio.TlsConnection], representing a client-side TLS connection.
[class@Gio.TlsConnection], representing a client-side TLS connection.
vtable for a #GTlsClientConnection implementation.
`GTlsConnection` is the base TLS connection class type, which wraps
a [class@Gio.IOStream] and provides TLS encryption on top of it.
a [class@Gio.IOStream] 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 [class@Gio.TlsDatabase] objects which
load their certificate information from a file.
load 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.
An abstract interface representing a password used in TLS.
Class structure for #GTlsPassword.
`GTlsServerConnection` is the server-side subclass of
[class@Gio.TlsConnection], representing a server-side TLS connection.
[class@Gio.TlsConnection], representing a server-side TLS connection.
vtable for a #GTlsServerConnection implementation.
A helper object for [class@ToastOverlay].
A widget showing toasts above its content.
#GstToc functions are used to create/free #GstToc and #GstTocEntry structures.
Element interface that allows setting of the TOC.
#GstTocSetterInterface interface.
A toggle within [class@ToggleGroup].
Shows a button which remains “pressed-in” when clicked.
A group of exclusive toggles.
A union holding the value of the token.
A widget containing a page, as well as top and/or bottom bars.
Represents a widget tooltip.
A freestanding toplevel surface.
Contains information that is necessary to present a sovereign
window on screen.
window on screen.
An event related to a touch-based device.
An event related to a gesture on a touchpad device.
Tracing modules will subclass #GstTracer and register through
gst_tracer_register().
gst_tracer_register().
Use gst_tracer_factory_get_list() to get a list of tracer factories known to
GStreamer.
GStreamer.
Tracing modules will create instances of this class to announce the data they
will log and create a log formatter.
will log and create a log formatter.
Describes a 3D transform.
A render node applying a `GskTransform` to its single child node.
A `GTrashStack` is an efficient way to keep a stack of unused allocated
memory chunks.
memory chunks.
The GTree struct is an opaque data structure representing a
[balanced binary tree](data-structures.html#binary-trees).
[balanced binary tree](data-structures.html#binary-trees).
Interface for Drag-and-Drop destinations in `GtkTreeView`.
Interface for Drag-and-Drop destinations in `GtkTreeView`.
Provides an expander for a tree-like list.
The `GtkTreeIter` is the primary structure
for accessing a `GtkTreeModel`.
for accessing a `GtkTreeModel`.
A list model that can create child models on demand.
The type of item used by `GtkTreeListModel`.
Applies a gives 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 [class@Gtk.TreeView].
A widget for displaying both trees and lists
<picture>
<source srcset="list-and-tree-dark.png" media="(prefers-color-scheme: dark)">
<img alt="An example GtkTreeView" src="list-and-tree.png">
</picture>
Widget that displays any object that implements the [iface@Gtk.TreeModel] interface.
<picture>
<source srcset="list-and-tree-dark.png" media="(prefers-color-scheme: dark)">
<img alt="An example GtkTreeView" src="list-and-tree.png">
</picture>
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.
The #GTuples struct is used to return records (or tuples) from the
#GRelation by g_relation_select().
#GRelation by g_relation_select().
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 union holding one collected value.
The following functions allow you to detect the media type of an unknown
stream.
stream.
These functions allow querying information about registered typefind
functions.
functions.
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.
- `'i'`: Integers, passed as `collect_values[].v_int`
- `'l'`: Longs, passed as `collect_values[].v_long`
- `'d'`: Doubles, passed as `collect_values[].v_double`
- `'p'`: Pointers, passed as `collect_values[].v_pointer`
It should be noted that for variable argument list construction,
ANSI C promotes every type smaller than an integer to an int, and
floats to doubles.
- `'l'`: Longs, passed as `collect_values[].v_long`
- `'d'`: Doubles, passed as `collect_values[].v_double`
- `'p'`: Pointers, passed as `collect_values[].v_pointer`
It should be noted that for variable argument list construction,
ANSI C promotes every type smaller than an integer to an int, and
floats to doubles.
Load user interface from XML descriptions (.ui file).
This is the subclass of [class@Gio.SocketConnection] that is created
for UNIX domain sockets.
for UNIX domain sockets.
This [class@Gio.SocketControlMessage] contains a [class@Gio.Credentials]
instance.
instance.
Class structure for #GUnixCredentialsMessage.
A `GUnixFDList` contains a list of file descriptors.
This [class@Gio.SocketControlMessage] contains a [class@Gio.UnixFDList].
`GUnixInputStream` implements [class@Gio.InputStream] for reading from a UNIX
file descriptor, including asynchronous operations.
file descriptor, including asynchronous operations.
Defines a Unix mount entry (e.g.
Watches for changes to the set of mount entries and mount points in the
system.
system.
Defines a Unix mount point (e.g.
`GUnixOutputStream` implements [class@Gio.OutputStream] for writing to a UNIX
file descriptor, including asynchronous operations.
file descriptor, including asynchronous operations.
A Unix pipe.
Support for UNIX-domain (also known as local) sockets, corresponding to
`struct sockaddr_un`.
`struct sockaddr_un`.
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.
A #GstUri object can be used to parse and split a URI string into its
constituent parts.
constituent parts.
The #GstURIHandler is an interface that is implemented by Source and Sink
#GstElement to unify handling of URI.
#GstElement to unify handling of URI.
Any #GstElement using this interface should implement these methods.
Asynchronous API to open a uri with an application.
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` is a container structure to hold an array of generic values.
A fundamental type that describes an ordered list of #GValue
A fundamental type that describes an unordered list of #GValue
VTable for the #GValue @type.
`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.
A type in the [type@GLib.Variant] 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.
Shows a `GtkMediaStream` with media controls.
Implements scrollability for widgets that don't support scrolling
on their own.
on their own.
A view container for [class@ViewSwitcher].
An auxiliary class used by [class@ViewStack].
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.
Represents the platform-specific Vulkan draw context.
A GSK renderer that is using Vulkan.
A structure containing a weak reference to a #GObject.
The base class for all widgets.
A `GdkPaintable` that displays the contents of a widget.
A freeform window.
A toplevel window which can contain other widgets.
Shows window frame controls.
Creates groups of windows that behave like separate applications.
Implements titlebar functionality for a window.
A helper widget for setting a window's title and subtitle.
A box-like widget that can wrap into multiple lines.
A box-like layout that can wrap into multiple lines.
`GZlibCompressor` is an implementation of [iface@Gio.Converter] that
compresses data using zlib.
compresses data using zlib.
`GZlibDecompressor` is an implementation of [iface@Gio.Converter] that
decompresses data compressed with zlib.
decompresses data compressed with zlib.