Flags used when creating a #GAppInfo.
Flags used to define the behaviour of a #GApplication.
#GAskPasswordFlags are used to request specific information from the user, or to notify the user of their choices in an authentication situation.
Flags used in gio.global.busOwnName.
Flags used in gio.global.busWatchName.
An enumeration for well-known message buses.
Flags used when calling a gio.converter.Converter.convert.
Results returned from gio.converter.Converter.convert.
Enumeration describing different kinds of native credential types.
Flags used in gio.dbus_connection.DBusConnection.call and similar APIs.
Capabilities negotiated with the remote peer.
Flags used when creating a new #GDBusConnection.
Error codes for the G_DBUS_ERROR error domain.
Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
Enumeration used to describe the byte order of a D-Bus message.
Message flags used in #GDBusMessage.
Header fields used in #GDBusMessage.
Message types used in #GDBusMessage.
Flags used when constructing a #GDBusObjectManagerClient.
Flags describing the access control of a D-Bus property.
Flags used when constructing an instance of a #GDBusProxy derived class.
Flags used when sending #GDBusMessages on a #GDBusConnection.
Flags used when creating a #GDBusServer.
Flags used when subscribing to signals via gio.dbus_connection.DBusConnection.signalSubscribe.
Flags passed to gio.dbus_connection.DBusConnection.registerSubtree.
#GDataStreamByteOrder is used to ensure proper endianness of streaming data sources across various machine architectures.
#GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
Flags used when starting a drive.
Enumeration describing how a drive can be started/stopped.
GEmblemOrigin is used to add information about the origin of the emblem to #GEmblem.
Flags specifying the behaviour of an attribute.
Used by gio.file.File.setAttributesFromInfo when setting file attributes.
The data types for file attributes.
Flags used when copying or moving files.
Flags used when an operation may create a file.
Flags that can be used with gio.file.File.measureDiskUsage.
Specifies what type of event a monitor event is.
Flags used to set what a #GFileMonitor will watch for.
Flags used when querying a #GFileInfo.
Indicates the file's on-disk type.
Indicates a hint from the file system whether files should be previewed in a file manager. Returned as the value of the key G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
Error codes returned by GIO functions.
Flags for use with gio.iomodule_scope.IOModuleScope.new_.
GIOStreamSpliceFlags determine how streams should be spliced.
Memory availability warning levels.
Flags used when mounting a mount.
#GMountOperationResult is returned as a result when a request for information is send by the mounting operation.
Flags used when an unmounting a mount.
The host's network connectivity state, as reported by #GNetworkMonitor.
Priority levels for #GNotifications.
GOutputStreamSpliceFlags determine how streams should be spliced.
#GPasswordSave is used to indicate the lifespan of a saved password.
Return value for various IO operations that signal errors via the return value and not necessarily via a #GError.
An error code used with G_RESOLVER_ERROR in a #GError returned from a #GResolver routine.
Flags to modify lookup behavior.
The type of record that gio.resolver.Resolver.lookupRecords or gio.resolver.Resolver.lookupRecordsAsync should retrieve. The records are returned as lists of #GVariant tuples. Each record type has different values in the variant tuples returned.
An error code used with G_RESOURCE_ERROR in a #GError returned from a #GResource routine.
GResourceFlags give information about a particular file inside a resource bundle.
GResourceLookupFlags determine how resource path lookups are handled.
Flags used when creating a binding. These flags determine in which direction the binding works. The default is to synchronize in both directions.
Describes an event occurring on a #GSocketClient. See the #GSocketClient::event signal for more details.
The protocol family of a #GSocketAddress. (These values are identical to the system defines AF_INET, AF_INET6 and AF_UNIX, if available.)
Describes an event occurring on a #GSocketListener. See the #GSocketListener::event signal for more details.
Flags used in gio.socket.Socket.receiveMessage and gio.socket.Socket.sendMessage. The flags listed in the enum are some commonly available flags, but the values used for them are the same as on the platform, and any other flags are passed in/out as is. So to use a platform specific flag, just include the right system header and pass in the flag.
A protocol identifier is specified when creating a #GSocket, which is a family/type specific identifier, where 0 means the default protocol for the particular family/type.
Flags used when creating a #GSocket. Some protocols may not implement all the socket types.
Flags to define the behaviour of a #GSubprocess.
Flags to define future #GTestDBus behaviour.
The client authentication mode for a #GTlsServerConnection.
A set of flags describing TLS certification validation. This can be used to describe why a particular certificate was rejected (for example, in #GTlsConnection::accept-certificate).
An error code used with G_TLS_CHANNEL_BINDING_ERROR in a #GError to indicate a TLS channel binding retrieval error.
The type of TLS channel binding data to retrieve from #GTlsConnection or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The `tls-unique-for-telnet`
binding type is not currently implemented.
Flags for gio.tls_database.TlsDatabase.verifyChain.
An error code used with G_TLS_ERROR in a #GError returned from a TLS-related routine.
#GTlsInteractionResult is returned by various functions in #GTlsInteraction when finishing an interaction request.
Various flags for the password.
The TLS or DTLS protocol version used by a #GTlsConnection or #GDtlsConnection. The integer values of these versions are sequential to ensure newer known protocol versions compare greater than older known versions. Any known DTLS protocol version will compare greater than any SSL or TLS protocol version. The protocol version may be gio.types.TlsProtocolVersion.Unknown if the TLS backend supports a newer protocol version that GLib does not yet know about. This means that it's possible for an unknown DTLS protocol version to compare less than the TLS protocol versions.
When to allow rehandshaking. See gio.tls_connection.TlsConnection.setRehandshakeMode.
The type of name used by a #GUnixSocketAddress. gio.types.UnixSocketAddressType.Path indicates a traditional unix domain socket bound to a filesystem path. gio.types.UnixSocketAddressType.Anonymous indicates a socket not bound to any name (eg, a client-side socket, or a socket created with socketpair()).
Used to select the type of data format to use for #GZlibDecompressor and #GZlibCompressor.
gio.action.Action represents a single named action.
This struct defines a single action. It is for use with gio.action_map.ActionMap.addActionEntries.
gio.action_group.ActionGroup represents a group of actions.
The virtual function table for #GActionGroup.
The virtual function table for #GAction.
gio.action_map.ActionMap is an interface for action containers.
The virtual function table for #GActionMap.
Information about an installed application and methods to launch it (with file arguments).
Application Information interface, for operating system portability.
gio.app_info_monitor.AppInfoMonitor monitors application information for changes.
Integrating the launch with the launching application. This is used to handle for instance startup notification and launching the new application on the same screen as the launching window.
gio.application.Application is the core class for application support.
Virtual function table for #GApplication.
gio.application_command_line.ApplicationCommandLine represents a command-line invocation of an application.
The #GApplicationCommandLineClass-struct contains private data only.
gio.async_initable.AsyncInitable is an interface for asynchronously initializable objects.
Provides an interface for asynchronous initializing object such that initialization may fail.
gio.async_result.AsyncResult provides a base class for implementing asynchronous function results.
Interface definition for #GAsyncResult.
Buffered input stream implements #GFilterInputStream and provides for buffered reads.
Buffered output stream implements gio.filter_output_stream.FilterOutputStream and provides for buffered writes.
gio.bytes_icon.BytesIcon specifies an image held in memory in a common format (usually PNG) to be used as icon.
gio.cancellable.Cancellable allows operations to be cancelled.
gio.charset_converter.CharsetConverter is an implementation of gio.converter.Converter based on [glib.types.void*].
gio.converter.Converter is an interface for streaming conversions.
Provides an interface for converting data from one type to another type. The conversion can be stateful and may fail at any place.
Converter input stream implements gio.input_stream.InputStream and allows conversion of data of various types during reading.
Converter output stream implements gio.output_stream.OutputStream and allows conversion of data of various types during reading.
The gio.credentials.Credentials type is a reference-counted wrapper for native credentials.
Class structure for #GCredentials.
gio.dbus_action_group.DBusActionGroup is an implementation of the gio.action_group.ActionGroup interface.
Information about an annotation.
Information about an argument for a method or a signal.
gio.dbus_auth_observer.DBusAuthObserver provides a mechanism for participating in how a gio.dbus_server.DBusServer (or a gio.dbus_connection.DBusConnection) authenticates remote peers.
The gio.dbus_connection.DBusConnection type is used for D-Bus connections to remote peers such as a message buses.
Struct used in gio.global.dbusErrorRegisterErrorDomain.
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.
gio.dbus_menu_model.DBusMenuModel is an implementation of gio.menu_model.MenuModel that can be used as a proxy for a menu model that is exported over D-Bus with gio.dbus_connection.DBusConnection.exportMenuModel.
A type for representing D-Bus messages that can be sent or received on a gio.dbus_connection.DBusConnection.
Information about a method on an D-Bus interface.
Instances of the gio.dbus_method_invocation.DBusMethodInvocation class are used when handling D-Bus method calls. It provides a way to asynchronously return results and errors.
Information about nodes in a remote object hierarchy.
The gio.dbus_object.DBusObject type is the base type for D-Bus objects on both the service side (see gio.dbus_object_skeleton.DBusObjectSkeleton) and the client side (see gio.dbus_object_proxy.DBusObjectProxy). It is essentially just a container of interfaces.
Base object type for D-Bus objects.
The gio.dbus_object_manager.DBusObjectManager type is the base type for service- and client-side implementations of the standardized `org.freedesktop.DBus.ObjectManager`
interface.
gio.dbus_object_manager_client.DBusObjectManagerClient is used to create, monitor and delete object proxies for remote objects exported by a gio.dbus_object_manager_server.DBusObjectManagerServer (or any code implementing the org.freedesktop.DBus.ObjectManager
interface).
Class structure for #GDBusObjectManagerClient.
Base type for D-Bus object managers.
gio.dbus_object_manager_server.DBusObjectManagerServer is used to export gio.dbus_object.DBusObject instances using the standardized `org.freedesktop.DBus.ObjectManager`
interface. For example, remote D-Bus clients can get all objects and properties in a single call. Additionally, any change in the object hierarchy is broadcast using signals. This means that D-Bus clients can keep caches up to date by only listening to D-Bus signals.
Class structure for #GDBusObjectManagerServer.
A gio.dbus_object_proxy.DBusObjectProxy is an object used to represent a remote object with one or more D-Bus interfaces. Normally, you don’t instantiate a gio.dbus_object_proxy.DBusObjectProxy yourself — typically gio.dbus_object_manager_client.DBusObjectManagerClient is used to obtain it.
Class structure for #GDBusObjectProxy.
A gio.dbus_object_skeleton.DBusObjectSkeleton instance is essentially a group of D-Bus interfaces. The set of exported interfaces on the object may be dynamic and change at runtime.
Class structure for #GDBusObjectSkeleton.
Information about a D-Bus property on a D-Bus interface.
gio.dbus_proxy.DBusProxy is a base class used for proxies to access a D-Bus interface on a remote object. A gio.dbus_proxy.DBusProxy can be constructed for both well-known and unique names.
Class structure for #GDBusProxy.
gio.dbus_server.DBusServer is a helper for listening to and accepting D-Bus connections. This can be used to create a new D-Bus server, allowing two peers to use the D-Bus protocol for their own specialized communication. A server instance provided in this way will not perform message routing or implement the `org.freedesktop.DBus` interface.
Information about a signal on a D-Bus interface.
Virtual table for handling subtrees registered with gio.dbus_connection.DBusConnection.registerSubtree.
Data input stream implements gio.input_stream.InputStream and includes functions for reading structured data directly from a binary input stream.
Data output stream implements gio.output_stream.OutputStream and includes functions for writing data directly to an output stream.
Interface for socket-like objects with datagram semantics.
Provides an interface for socket-like objects which have datagram semantics, following the Berkeley sockets API. The interface methods are thin wrappers around the corresponding virtual methods, and no pre-processing of inputs is implemented — so implementations of this API must handle all functionality documented in the interface methods.
gio.debug_controller.DebugController is an interface to expose control of debugging features and debug output.
gio.debug_controller_dbus.DebugControllerDBus is an implementation of gio.debug_controller.DebugController which exposes debug settings as a D-Bus object.
The virtual function table for #GDebugControllerDBus.
The virtual function table for #GDebugController.
gio.desktop_app_info.DesktopAppInfo is an implementation of gio.app_info.AppInfo based on desktop files.
#GDesktopAppInfoLookup is an opaque data structure and can only be accessed using the following functions.
Interface that is used by backends to associate default handlers with URI schemes.
gio.drive.Drive represents a piece of hardware connected to the machine. It’s generally only created for removable hardware or hardware with removable media.
Interface for creating #GDrive implementations.
gio.dtls_client_connection.DtlsClientConnection is the client-side subclass of gio.dtls_connection.DtlsConnection, representing a client-side DTLS connection.
vtable for a #GDtlsClientConnection implementation.
gio.dtls_connection.DtlsConnection is the base DTLS connection class type, which wraps a gio.datagram_based.DatagramBased and provides DTLS encryption on top of it. Its subclasses, gio.dtls_client_connection.DtlsClientConnection and gio.dtls_server_connection.DtlsServerConnection, implement client-side and server-side DTLS, respectively.
Virtual method table for a #GDtlsConnection implementation.
gio.dtls_server_connection.DtlsServerConnection is the server-side subclass of gio.dtls_connection.DtlsConnection, representing a server-side DTLS connection.
vtable for a #GDtlsServerConnection implementation.
gio.emblem.Emblem is an implementation of gio.icon.Icon that supports having an emblem, which is an icon with additional properties. It can than be added to a gio.emblemed_icon.EmblemedIcon.
gio.emblemed_icon.EmblemedIcon is an implementation of gio.icon.Icon that supports adding an emblem to an icon. Adding multiple emblems to an icon is ensured via gio.emblemed_icon.EmblemedIcon.addEmblem.
gio.file.File is a high level abstraction for manipulating files on a virtual file system. gio.file.Files are lightweight, immutable objects that do no I/O upon creation. It is necessary to understand that gio.file.File objects do not represent files, merely an identifier for a file. All file content I/O is implemented as streaming operations (see gio.input_stream.InputStream and gio.output_stream.OutputStream).
Information about a specific attribute.
Acts as a lightweight registry for possible valid file attributes. The registry stores Key-Value pair formats as #GFileAttributeInfos.
Determines if a string matches a file attribute.
gio.file_descriptor_based.FileDescriptorBased is an interface for file descriptor based IO.
An interface for file descriptor based io objects.
gio.file_enumerator.FileEnumerator allows you to operate on a set of gio.file.File objects, returning a gio.file_info.FileInfo structure for each file enumerated (e.g. gio.file.File.enumerateChildren will return a gio.file_enumerator.FileEnumerator for each of the children within a directory).
gio.file_iostream.FileIOStream provides I/O streams that both read and write to the same file handle.
gio.file_icon.FileIcon specifies an icon by pointing to an image file to be used as icon.
An interface for writing VFS file handles.
Stores information about a file system object referenced by a gio.file.File.
gio.file_input_stream.FileInputStream provides input streams that take their content from a file.
Monitors a file or directory for changes.
gio.file_output_stream.FileOutputStream provides output streams that write their content to a file.
Completes partial file and directory names given a partial string by looking in the file system for clues. Can return a list of possible completion strings for widget implementations.
Base class for input stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.
Base class for output stream implementations that perform some kind of filtering operation on a base stream. Typical examples of filtering operations are character set conversion, compression and byte order flipping.
#GIOExtension is an opaque data structure and can only be accessed using the following functions.
gio.ioextension_point.IOExtensionPoint provides a mechanism for modules to extend the functionality of the library or application that loaded it in an organized fashion.
Provides an interface and default functions for loading and unloading modules. This is used internally to make GIO extensible, but can also be used by others to implement module loading.
Represents a scope for loading IO modules. A scope can be used for blocking duplicate modules, or blocking a module you don't want to load.
Opaque class for defining and scheduling IO jobs.
gio.iostream.IOStream represents an object that has both read and write streams. Generally the two streams act as separate input and output streams, but they share some common resources and state. For instance, for seekable streams, both streams may use the same position.
gio.icon.Icon is a very minimal interface for icons. It provides functions for checking the equality of two icons, hashing of icons and serializing an icon to and from strings.
GIconIface is used to implement GIcon types for various different systems. See #GThemedIcon and #GLoadableIcon for examples of how to implement this interface.
gio.inet_address.InetAddress represents an IPv4 or IPv6 internet address. Use gio.resolver.Resolver.lookupByName or gio.resolver.Resolver.lookupByNameAsync to look up the gio.inet_address.InetAddress for a hostname. Use gio.resolver.Resolver.lookupByAddress or gio.resolver.Resolver.lookupByAddressAsync to look up the hostname for a gio.inet_address.InetAddress.
gio.inet_address_mask.InetAddressMask 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. These are often given in string form. For example, 10.0.0.0/8, or fe80::/10.
An IPv4 or IPv6 socket address. That is, the combination of a gio.inet_address.InetAddress and a port number.
gio.initable.Initable is implemented by objects that can fail during initialization. If an object implements this interface then it must be initialized as the first thing after construction, either via gio.initable.Initable.init_ or gio.async_initable.AsyncInitable.initAsync (the latter is only available if it also implements gio.async_initable.AsyncInitable).
Provides an interface for initializing object such that initialization may fail.
Structure used for scatter/gather data input when receiving multiple messages or packets in one go. You generally pass in an array of empty #GInputVectors and the operation will use all the buffers as if they were one buffer, and will set @bytes_received to the total number of bytes received across all #GInputVectors.
gio.input_stream.InputStream is a base class for implementing streaming input.
Structure used for scatter/gather data input. You generally pass in an array of #GInputVectors and the operation will store the read data starting in the first buffer, switching to the next as needed.
gio.list_model.ListModel is an interface that represents a mutable list of gobject.object.ObjectG. Its main intention is as a model for various widgets in user interfaces, such as list views, but it can also be used as a convenient method of returning lists of data, with support for updates.
The virtual function table for #GListModel.
gio.list_store.ListStore is a simple implementation of gio.list_model.ListModel that stores all items in memory.
gio.loadable_icon.LoadableIcon extends the gio.icon.Icon interface and adds the ability to load icons from streams.
Interface for icons that can be loaded as a stream.
gio.memory_input_stream.MemoryInputStream is a class for using arbitrary memory chunks as input for GIO streaming input operations.
gio.memory_monitor.MemoryMonitor will monitor system memory and suggest to the application when to free memory so as to leave more room for other applications. It is implemented on Linux using the Low Memory Monitor
The virtual function table for #GMemoryMonitor.
gio.memory_output_stream.MemoryOutputStream is a class for using arbitrary memory chunks as output for GIO streaming output operations.
gio.menu.Menu is a simple implementation of gio.menu_model.MenuModel. You populate a gio.menu.Menu by adding gio.menu_item.MenuItem instances to it.
#GMenuAttributeIter is an opaque structure type. You must access it using the functions below.
#GMenuItem is an opaque structure type. You must access it using the functions below.
#GMenuLinkIter is an opaque structure type. You must access it using the functions below.
gio.menu_model.MenuModel represents the contents of a menu — an ordered list of menu items. The items are associated with actions, which can be activated through them. Items can be grouped in sections, and may have submenus associated with them. Both items and sections usually have some representation data, such as labels or icons. The type of the associated action (ie whether it is stateful, and what kind of state it has) can influence the representation of the item.
The gio.mount.Mount interface represents user-visible mounts. Note, when porting from GnomeVFS, gio.mount.Mount is the moral equivalent of GnomeVFSVolume.
Interface for implementing operations for mounts.
gio.mount_operation.MountOperation provides a mechanism for interacting with the user. It can be used for authenticating mountable operations, such as loop mounting files, hard drive partitions or server locations. It can also be used to ask the user questions or show a list of applications preventing unmount or eject operations from completing.
A socket address of some unknown native type.
gio.network_address.NetworkAddress 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.
gio.network_monitor.NetworkMonitor provides an easy-to-use cross-platform API for monitoring network connectivity. On Linux, the available implementations are based on the kernel's netlink interface and on NetworkManager.
The virtual function table for #GNetworkMonitor.
Like gio.network_address.NetworkAddress does with hostnames, gio.network_service.NetworkService 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.
gio.notification.Notification 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.
Structure used for scatter/gather data output when sending multiple messages or packets in one go. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer.
gio.output_stream.OutputStream is a base class for implementing streaming output.
Structure used for scatter/gather data output. You generally pass in an array of #GOutputVectors and the operation will use all the buffers as if they were one buffer.
A gio.permission.Permission represents the status of the caller’s permission to perform a certain action.
gio.pollable_input_stream.PollableInputStream is implemented by gio.input_stream.InputStreams that can be polled for readiness to read. This can be used when interfacing with a non-GIO API that expects UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
The interface for pollable input streams.
gio.pollable_output_stream.PollableOutputStream is implemented by gio.output_stream.OutputStreams that can be polled for readiness to write. This can be used when interfacing with a non-GIO API that expects UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
The interface for pollable output streams.
gio.power_profile_monitor.PowerProfileMonitor makes it possible for applications as well as OS components to monitor system power profiles and act upon them. It currently only exports whether the system is in “Power Saver” mode (known as “Low Power” mode on some systems).
The virtual function table for #GPowerProfileMonitor.
A gio.property_action.PropertyAction is a way to get a gio.action.Action with a state value reflecting and controlling the value of a gobject.object.ObjectG property.
A gio.proxy.Proxy handles connecting to a remote host via a given type of proxy server. It is implemented by the gio-proxy extension point. The extensions are named after their proxy protocol name. As an example, a SOCKS5 proxy implementation can be retrieved with the name socks5 using the function gio.ioextension_point.IOExtensionPoint.getExtensionByName.
A gio.inet_socket_address.InetSocketAddress representing a connection via a proxy server.
Class structure for #GProxyAddress.
gio.proxy_address_enumerator.ProxyAddressEnumerator is a wrapper around gio.socket_address_enumerator.SocketAddressEnumerator which takes the gio.socket_address.SocketAddress instances returned by the gio.socket_address_enumerator.SocketAddressEnumerator and wraps them in gio.proxy_address.ProxyAddress instances, using the given property@Gio.ProxyAddressEnumerator:proxy-resolver.
Class structure for #GProxyAddressEnumerator.
Provides an interface for handling proxy connection and payload.
gio.proxy_resolver.ProxyResolver provides synchronous and asynchronous network proxy resolution. gio.proxy_resolver.ProxyResolver is used within gio.socket_client.SocketClient through the method gio.socket_connectable.SocketConnectable.proxyEnumerate.
The virtual function table for #GProxyResolver.
The gio.remote_action_group.RemoteActionGroup interface is implemented by gio.action_group.ActionGroup 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.
The object that handles DNS resolution. Use gio.resolver.Resolver.getDefault to get the default resolver.
Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance [gtk.builder.Builder] .ui files, splashscreen images, gio.menu.Menu markup XML, CSS files, icons, etc. These are often shipped as files in $datadir/appname, or manually included as literal strings in the code.
gio.seekable.Seekable is implemented by streams (implementations of gio.input_stream.InputStream or gio.output_stream.OutputStream) that support seeking.
Provides an interface for implementing seekable functionality on I/O Streams.
The gio.settings.Settings class provides a convenient API for storing and retrieving application settings.
The gio.settings_backend.SettingsBackend interface defines a generic interface for non-strictly-typed data that is stored in a hierarchy. To implement an alternative storage backend for gio.settings.Settings, you need to implement the gio.settings_backend.SettingsBackend interface and then make it implement the extension point G_SETTINGS_BACKEND_EXTENSION_POINT_NAME.
Class structure for #GSettingsBackend.
The gio.settings_schema_source.SettingsSchemaSource and gio.settings_schema.SettingsSchema APIs provide a 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.
This is an opaque structure type. You may not access it directly.
A gio.simple_action.SimpleAction is the obvious simple implementation of the gio.action.Action interface. This is the easiest way to create an action for purposes of adding it to a gio.simple_action_group.SimpleActionGroup.
gio.simple_action_group.SimpleActionGroup is a hash table filled with gio.action.Action objects, implementing the gio.action_group.ActionGroup and gio.action_map.ActionMap interfaces.
As of GLib 2.46, gio.simple_async_result.SimpleAsyncResult is deprecated in favor of gio.task.Task, which provides a simpler API.
gio.simple_iostream.SimpleIOStream creates a gio.iostream.IOStream from an arbitrary gio.input_stream.InputStream and gio.output_stream.OutputStream. This allows any pair of input and output streams to be used with gio.iostream.IOStream methods.
gio.simple_permission.SimplePermission is a trivial implementation of gio.permission.Permission that represents a permission that is either always or never allowed. The value is given at construction and doesn’t change.
gio.simple_proxy_resolver.SimpleProxyResolver is a simple gio.proxy_resolver.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.
A gio.socket.Socket is a low-level networking primitive. It is a more or less direct mapping of the BSD socket API in a portable GObject based API. It supports both the UNIX socket implementations and winsock2 on Windows.
gio.socket_address.SocketAddress is the equivalent of `struct sockaddr` and its subtypes in the BSD sockets API. This is an abstract class; use gio.inet_socket_address.InetSocketAddress for internet sockets, or gio.unix_socket_address.UnixSocketAddress for UNIX domain sockets.
gio.socket_address_enumerator.SocketAddressEnumerator is an enumerator type for gio.socket_address.SocketAddress instances. It is returned by enumeration functions such as gio.socket_connectable.SocketConnectable.enumerate, which returns a gio.socket_address_enumerator.SocketAddressEnumerator to list each gio.socket_address.SocketAddress which could be used to connect to that gio.socket_connectable.SocketConnectable.
Class structure for #GSocketAddressEnumerator.
gio.socket_client.SocketClient is a lightweight high-level utility class for connecting to a network host using a connection oriented socket type.
Objects that describe one or more potential socket endpoints implement gio.socket_connectable.SocketConnectable. Callers can then use gio.socket_connectable.SocketConnectable.enumerate to get a gio.socket_address_enumerator.SocketAddressEnumerator to try out each socket address in turn until one succeeds, as shown in the sample code below.
Provides an interface for returning a #GSocketAddressEnumerator and #GProxyAddressEnumerator
gio.socket_connection.SocketConnection is a gio.iostream.IOStream for a connected socket. They can be created either by gio.socket_client.SocketClient when connecting to a host, or by gio.socket_listener.SocketListener when accepting a new client.
A gio.socket_control_message.SocketControlMessage is a special-purpose utility message that can be sent to or received from a gio.socket.Socket. These types of messages are often called ‘ancillary data’.
Class structure for #GSocketControlMessage.
A gio.socket_listener.SocketListener 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.
Class structure for #GSocketListener.
A gio.socket_service.SocketService is an object that represents a service that is provided to the network or over local sockets. When a new connection is made to the service the gio.socket_service.SocketService.incoming signal is emitted.
Class structure for #GSocketService.
A single target host/port that a network service is running on.
#GStaticResource is an opaque data structure and can only be accessed using the following functions.
gio.subprocess.Subprocess allows the creation of and interaction with child 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.
A gio.task.Task represents and manages a cancellable ‘task’.
This is the subclass of gio.socket_connection.SocketConnection that is created for TCP/IP sockets.
A gio.tcp_wrapper_connection.TcpWrapperConnection can be used to wrap a gio.iostream.IOStream that is based on a gio.socket.Socket, but which is not actually a gio.socket_connection.SocketConnection. This is used by gio.socket_client.SocketClient so that it can always return a gio.socket_connection.SocketConnection, even when the connection it has actually created is not directly a gio.socket_connection.SocketConnection.
A helper class for testing code which uses D-Bus without touching the user’s session bus.
gio.themed_icon.ThemedIcon is an implementation of gio.icon.Icon that supports icon themes.
#GThreadedResolver is an implementation of #GResolver which calls the libc lookup functions in threads to allow them to run asynchronously.
A gio.threaded_socket_service.ThreadedSocketService is a simple subclass of gio.socket_service.SocketService that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting the gio.threaded_socket_service.ThreadedSocketService.run in the new thread.
TLS (Transport Layer Security, aka SSL) and DTLS backend. This is an internal type used to coordinate the different classes implemented by a TLS backend.
Provides an interface for describing TLS-related types.
A certificate used for TLS authentication and encryption. This can represent either a certificate only (eg, the certificate received by a client from a server), or the combination of a certificate and a private key (which is needed when acting as a gio.tls_server_connection.TlsServerConnection).
gio.tls_client_connection.TlsClientConnection is the client-side subclass of gio.tls_connection.TlsConnection, representing a client-side TLS connection.
vtable for a #GTlsClientConnection implementation.
gio.tls_connection.TlsConnection is the base TLS connection class type, which wraps a gio.iostream.IOStream and provides TLS encryption on top of it. Its subclasses, gio.tls_client_connection.TlsClientConnection and gio.tls_server_connection.TlsServerConnection, implement client-side and server-side TLS, respectively.
The class structure for the #GTlsConnection type.
gio.tls_database.TlsDatabase is used to look up certificates and other information from a certificate or key store. It is an abstract base class which TLS library specific subtypes override.
The class for #GTlsDatabase. Derived classes should implement the various virtual methods. _async and _finish methods have a default implementation that runs the corresponding sync method in a thread.
gio.tls_file_database.TlsFileDatabase is implemented by gio.tls_database.TlsDatabase objects which load their certificate information from a file. It is an interface which TLS library specific subtypes implement.
Provides an interface for #GTlsFileDatabase implementations.
gio.tls_interaction.TlsInteraction provides a mechanism for the TLS connection and database code to interact with the user. It can be used to ask the user for passwords.
The class for #GTlsInteraction. Derived classes implement the various virtual interaction methods to handle TLS interactions.
An abstract interface representing a password used in TLS. Often used in user interaction such as unlocking a key storage token.
Class structure for #GTlsPassword.
gio.tls_server_connection.TlsServerConnection is the server-side subclass of gio.tls_connection.TlsConnection, representing a server-side TLS connection.
vtable for a #GTlsServerConnection implementation.
This is the subclass of gio.socket_connection.SocketConnection that is created for UNIX domain sockets.
This gio.socket_control_message.SocketControlMessage contains a gio.credentials.Credentials instance. It may be sent using gio.socket.Socket.sendMessage and received using gio.socket.Socket.receiveMessage over UNIX sockets (ie: sockets in the gio.types.SocketFamily.Unix family).
Class structure for #GUnixCredentialsMessage.
A gio.unix_fdlist.UnixFDList contains a list of file descriptors. It owns the file descriptors that it contains, closing them when finalized.
This gio.socket_control_message.SocketControlMessage contains a gio.unix_fdlist.UnixFDList. It may be sent using gio.socket.Socket.sendMessage and received using gio.socket.Socket.receiveMessage over UNIX sockets (ie: sockets in the gio.types.SocketFamily.Unix family). The file descriptors are copied between processes by the kernel.
gio.unix_input_stream.UnixInputStream implements gio.input_stream.InputStream for reading from a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will use poll() to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.)
Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>). This corresponds roughly to a mtab entry.
Watches #GUnixMounts for changes.
Defines a Unix mount point (e.g. <filename>/dev</filename>). This corresponds roughly to a fstab entry.
gio.unix_output_stream.UnixOutputStream implements gio.output_stream.OutputStream for writing to a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will use poll() to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.)
Support for UNIX-domain (also known as local) sockets, corresponding to struct sockaddr_un.
Entry point for using GIO functionality.
The gio.volume.Volume interface represents user-visible objects that can be mounted. Note, when porting from GnomeVFS, gio.volume.Volume is the moral equivalent of GnomeVFSDrive.
Interface for implementing operations for mountable volumes.
gio.volume_monitor.VolumeMonitor is for listing the user interesting devices and volumes on the computer. In other words, what a file selector or file manager would show in a sidebar.
gio.zlib_compressor.ZlibCompressor is an implementation of gio.converter.Converter that compresses data using zlib.
gio.zlib_decompressor.ZlibDecompressor is an implementation of gio.converter.Converter that decompresses data compressed with zlib.