Expand description
§Rust GIO bindings
Rust bindings and wrappers for GIO, part of gtk-rs-core.
GIO 2.56 is the lowest supported version for the underlying library.
§Minimum supported Rust version
Currently, the minimum supported Rust version is 1.70.0
.
§Documentation
§Using
We recommend using crates from crates.io, as demonstrated here.
If you want to track the bleeding edge, use the git dependency instead:
[dependencies]
gio = { git = "https://github.com/gtk-rs/gtk-rs-core.git", package = "gio" }
Avoid mixing versioned and git crates like this:
# This will not compile
[dependencies]
gio = "0.13"
gio = { git = "https://github.com/gtk-rs/gtk-rs-core.git", package = "gio" }
§See Also
§License
gio is available under the MIT License, please refer to it.
Re-exports§
pub use crate::resource::resources_register_include_impl;
pub use gio_sys as ffi;
pub use glib;
pub use crate::functions::*;
Modules§
- Traits and essential types intended for blanket imports.
Macros§
- Include gresources generated with
glib_build_tools::compile_resources
and register with glib.path
is relative toOUTDIR
.
Structs§
GAction
represents a single named action.- This struct defines a single action. It is for use with g_action_map_add_action_entries().
GActionGroup
represents a group of actions.GActionMap
is an interface for action containers.- Information about an installed application and methods to launch it (with file arguments).
- Flags used when creating a #GAppInfo.
GAppInfoMonitor
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.
GApplication
is the core class for application support.GApplicationCommandLine
represents a command-line invocation of an application.- 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.
GAsyncInitable
is an interface for asynchronously initializable objects.GAsyncResult
provides a base class for implementing asynchronous function results.- Buffered input stream implements #GFilterInputStream and provides for buffered reads.
- Buffered output stream implements
FilterOutputStream
and provides for buffered writes. - Flags used in g_bus_own_name().
- Flags used in g_bus_watch_name().
GBytesIcon
specifies an image held in memory in a common format (usually PNG) to be used as icon.GCancellable
allows operations to be cancelled.- A future which can be cancelled via
Cancellable
. - Indicator that the
CancellableFuture
was cancelled. GConverter
is an interface for streaming conversions.- Flags used when calling a g_converter_convert().
- Converter input stream implements
InputStream
and allows conversion of data of various types during reading. - Converter output stream implements
OutputStream
and allows conversion of data of various types during reading. - The
GCredentials
type is a reference-counted wrapper for native credentials. GDBusActionGroup
is an implementation of theActionGroup
interface.- Information about an argument for a method or a signal.
GDBusAuthObserver
provides a mechanism for participating in how aDBusServer
(or aDBusConnection
) authenticates remote peers.- Flags used in g_dbus_connection_call() and similar APIs.
- Capabilities negotiated with the remote peer.
- The
GDBusConnection
type is used for D-Bus connections to remote peers such as a message buses. - Flags used when creating a new #GDBusConnection.
- Base type for D-Bus interfaces.
- Information about a D-Bus interface.
- Abstract base class for D-Bus interfaces on the service side.
- Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
GDBusMenuModel
is an implementation ofMenuModel
that can be used as a proxy for a menu model that is exported over D-Bus withDBusConnection::export_menu_model()
.- A type for representing D-Bus messages that can be sent or received on a
DBusConnection
. - Message flags used in #GDBusMessage.
- Information about a method on a D-Bus interface.
- Instances of the
GDBusMethodInvocation
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
GDBusObject
type is the base type for D-Bus objects on both the service side (seeGio::DBusObjectSkeleton
) and the client side (seeGio::DBusObjectProxy
). It is essentially just a container of interfaces. - The
GDBusObjectManager
type is the base type for service- and client-side implementations of the standardizedorg.freedesktop.DBus.ObjectManager
interface. - Flags used when constructing a #GDBusObjectManagerClient.
- 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. AGDBusProxy
can be constructed for both well-known and unique names.- Flags used when constructing an instance of a #GDBusProxy derived class.
- Flags used when sending #GDBusMessages on a #GDBusConnection.
GDBusServer
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 theorg.freedesktop.DBus
interface.- Flags used when creating a #GDBusServer.
- Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
- Information about a signal on a D-Bus interface.
- Data input stream implements
InputStream
and includes functions for reading structured data directly from a binary input stream. - Data output stream implements
OutputStream
and includes functions for writing data directly to an output stream. - Interface for socket-like objects with datagram semantics.
- Debug
Controller v2_72
GDebugController
is an interface to expose control of debugging features and debug output. - Debug
ControllerD Bus v2_72
GDebugControllerDBus
is an implementation ofDebugController
which exposes debug settings as a D-Bus object. - Desktop
AppInfo Non-Windows and non-macOS GDesktopAppInfo
is an implementation ofAppInfo
based on desktop files. GDrive
represents a piece of hardware connected to the machine. It’s generally only created for removable hardware or hardware with removable media.- Flags used when starting a drive.
GEmblem
is an implementation ofIcon
that supports having an emblem, which is an icon with additional properties. It can than be added to aEmblemedIcon
.GEmblemedIcon
is an implementation ofIcon
that supports adding an emblem to an icon. Adding multiple emblems to an icon is ensured viaEmblemedIconExt::add_emblem()
.GFile
is a high level abstraction for manipulating files on a virtual file system.GFile
s are lightweight, immutable objects that do no I/O upon creation. It is necessary to understand thatGFile
objects do not represent files, merely an identifier for a file. All file content I/O is implemented as streaming operations (seeInputStream
andOutputStream
).- Information about a specific attribute.
- Flags specifying the behaviour of an 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.
- Flags used when copying or moving files.
- Flags used when an operation may create a file.
GFileDescriptorBased
is an interface for file descriptor based IO.GFileEnumerator
allows you to operate on a set ofFile
objects, returning aFileInfo
structure for each file enumerated (e.g.FileExt::enumerate_children()
will return aGFileEnumerator
for each of the children within a directory).- A
Stream
used to enumerate files in directories. GFileIOStream
provides I/O streams that both read and write to the same file handle.GFileIcon
specifies an icon by pointing to an image file to be used as icon.- Stores information about a file system object referenced by a
File
. GFileInputStream
provides input streams that take their content from a file.- Flags that can be used with g_file_measure_disk_usage().
- Monitors a file or directory for changes.
- Flags used to set what a #GFileMonitor will watch for.
GFileOutputStream
provides output streams that write their content to a file.- Flags used when querying a #GFileInfo.
- 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.
- The implementation of an
IOExtensionPoint
. #GIOExtension is an opaque data structure and can only be accessed using the following functions. - An extension point provides a mechanism to extend the functionality of a library or application. Each extension point is identified by a name, and it may optionally require that any implementation must be of a certain type.
GIOExtensionPoint
provides a mechanism for modules to extend the functionality of the library or application that loaded it in an organized fashion. - Builder for extension points.
GIOStream
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.- GIOStreamSpliceFlags determine how streams should be spliced.
GIcon
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.GInetAddress
represents an IPv4 or IPv6 internet address. UseResolverExt::lookup_by_name()
orResolverExt::lookup_by_name_async()
to look up theGInetAddress
for a hostname. UseResolverExt::lookup_by_address()
orResolverExt::lookup_by_address_async()
to look up the hostname for aGInetAddress
.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. These are often given in string form. For example,10.0.0.0/8
, orfe80::/10
.- An IPv4 or IPv6 socket address. That is, the combination of a
InetAddress
and a port number. GInitable
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 viaInitableExt::init()
orAsyncInitableExt::init_async()
(the latter is only available if it also implementsAsyncInitable
).- 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.
GInputStream
is a base class for implementing streaming input.- A handle to a task running on the I/O thread pool.
GListModel
is an interface that represents a mutable list ofglib::Object
. 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.GListStore
is a simple implementation ofListModel
that stores all items in memory.GLoadableIcon
extends theIcon
interface and adds the ability to load icons from streams.LocalTask
provides idiomatic access to gio’sGTask
API, for instance by being generic over their value type, while not completely departing from the underlying C API.LocalTask
does not require its value to beSend
andSync
and thus is useful to to implement gio style asynchronous tasks that run in the glib main loop. If you need to run tasks in threads see theTask
type.GMemoryInputStream
is a class for using arbitrary memory chunks as input for GIO streaming input operations.- Memory
Monitor v2_64
GMemoryMonitor
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 (API documentation). GMemoryOutputStream
is a class for using arbitrary memory chunks as output for GIO streaming output operations.- #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.
GMenuModel
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
GMount
interface represents user-visible mounts. Note, when porting from GnomeVFS,GMount
is the moral equivalent ofGnomeVFSVolume
. - Flags used when mounting a mount.
GMountOperation
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.- Flags used when an unmounting a mount.
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.GNetworkMonitor
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.- Like
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. 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.- 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.
GOutputStream
is a base class for implementing streaming output.- GOutputStreamSpliceFlags determine how streams should be spliced.
- A
GPermission
represents the status of the caller’s permission to perform a certain action. GPollableInputStream
is implemented byInputStream
s 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.GPollableOutputStream
is implemented byOutputStream
s 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.- Power
Profile Monitor v2_70
GPowerProfileMonitor
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). - A
GPropertyAction
is a way to get aAction
with a state value reflecting and controlling the value of aglib::Object
property. - A
GProxy
handles connecting to a remote host via a given type of proxy server. It is implemented by thegio-proxy
extension point. The extensions are named after their proxy protocol name. As an example, a SOCKS5 proxy implementation can be retrieved with the namesocks5
using the functionIOExtensionPoint::extension_by_name()
. - A
InetSocketAddress
representing a connection via a proxy server. GProxyResolver
provides synchronous and asynchronous network proxy resolution.GProxyResolver
is used withinSocketClient
through the methodSocketConnectableExt::proxy_enumerate()
.- GLib type: GObject with reference counted clone semantics.
- The
GRemoteActionGroup
interface is implemented byActionGroup
instances that either transmit action invocations to other processes or receive action invocations in the local process from other processes. - The object that handles DNS resolution. Use
default()
to get the default resolver. - Flags to modify lookup behavior.
- Applications and libraries often contain binary or textual data that is really part of the application, rather than user data. For instance
GtkBuilder
.ui
files, splashscreen images,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. - GResourceLookupFlags determine how resource path lookups are handled.
GSeekable
is implemented by streams (implementations ofInputStream
orOutputStream
) that support seeking.- The
GSettings
class provides a convenient API for storing and retrieving application settings. - The
GSettingsBackend
interface defines a generic interface for non-strictly-typed data that is stored in a hierarchy. To implement an alternative storage backend forSettings
, you need to implement theGSettingsBackend
interface and then make it implement the extension pointG_SETTINGS_BACKEND_EXTENSION_POINT_NAME
. - Flags used when creating a binding. These flags determine in which direction the binding works. The default is to synchronize in both directions.
- The
SettingsSchemaSource
andGSettingsSchema
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
GSimpleAction
is the obvious simple implementation of theAction
interface. This is the easiest way to create an action for purposes of adding it to aSimpleActionGroup
. GSimpleActionGroup
is a hash table filled withAction
objects, implementing theActionGroup
andActionMap
interfaces.GSimpleIOStream
creates aIOStream
from an arbitraryInputStream
andOutputStream
. This allows any pair of input and output streams to be used withIOStream
methods.GSimplePermission
is a trivial implementation ofPermission
that represents a permission that is either always or never allowed. The value is given at construction and doesn’t change.GSimpleProxyResolver
is a simpleProxyResolver
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
GSocket
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. GSocketAddress
is the equivalent ofstruct sockaddr
and its subtypes in the BSD sockets API. This is an abstract class; useInetSocketAddress
for internet sockets, orUnixSocketAddress
for UNIX domain sockets.GSocketAddressEnumerator
is an enumerator type forSocketAddress
instances. It is returned by enumeration functions such asSocketConnectableExt::enumerate()
, which returns aGSocketAddressEnumerator
to list eachSocketAddress
which could be used to connect to thatSocketConnectable
.GSocketClient
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
GSocketConnectable
. Callers can then useSocketConnectableExt::enumerate()
to get aSocketAddressEnumerator
to try out each socket address in turn until one succeeds, as shown in the sample code below. GSocketConnection
is aIOStream
for a connected socket. They can be created either bySocketClient
when connecting to a host, or bySocketListener
when accepting a new client.- A
GSocketControlMessage
is a special-purpose utility message that can be sent to or received from aSocket
. These types of messages are often called ‘ancillary data’. - 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. - A
GSocketService
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 theincoming
signal is emitted. - A single target host/port that a network service is running on.
GSubprocess
allows the creation of and interaction with child processes.- Flags to define the behaviour of a #GSubprocess.
- 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.
Task
provides idiomatic access to gio’sGTask
API, for instance by being generic over their value type, while not completely departing from the underlying C API.Task
isSend
andSync
and requires its value to also beSend
andSync
, thus is useful to to implement gio style asynchronous tasks that run in threads. If you need to only run tasks in glib main loop see theLocalTask
type.- This is the subclass of
SocketConnection
that is created for TCP/IP sockets. GThemedIcon
is an implementation ofIcon
that supports icon themes.- A
GThreadedSocketService
is a simple subclass ofSocketService
that handles incoming connections by creating a worker thread and dispatching the connection to it by emitting therun
signal] 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.
- 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
TlsServerConnection
). - 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).
GTlsClientConnection
is the client-side subclass ofTlsConnection
, representing a client-side TLS connection.GTlsConnection
is the base TLS connection class type, which wraps aIOStream
and provides TLS encryption on top of it. Its subclasses,TlsClientConnection
andTlsServerConnection
, implement client-side and server-side TLS, respectively.GTlsDatabase
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.- Flags for g_tls_database_verify_chain().
GTlsFileDatabase
is implemented byTlsDatabase
objects which load their certificate information from a file. It is an interface which TLS library specific subtypes implement.GTlsInteraction
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.- An abstract interface representing a password used in TLS. Often used in user interaction such as unlocking a key storage token.
- Various flags for the password.
GTlsServerConnection
is the server-side subclass ofTlsConnection
, representing a server-side TLS connection.- This
SocketControlMessage
contains aCredentials
instance. It may be sent usingSocketExtManual::send_message()
and received usingSocketExtManual::receive_message()
over UNIX sockets (ie: sockets in theG_SOCKET_FAMILY_UNIX
family). - UnixFD
List Unix AGUnixFDList
contains a list of file descriptors. It owns the file descriptors that it contains, closing them when finalized. - UnixFD
Message Unix ThisSocketControlMessage
contains aUnixFDList
. It may be sent usingSocketExtManual::send_message()
and received usingSocketExtManual::receive_message()
over UNIX sockets (ie: sockets in theG_SOCKET_FAMILY_UNIX
family). The file descriptors are copied between processes by the kernel. - Unix
Input Stream Unix GUnixInputStream
implementsInputStream
for reading from a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will usepoll()
to do asynchronous I/O. If it refers to a regular file, it will fall back to doing asynchronous I/O in another thread.) - Unix
Mount Entry Unix Defines a Unix mount entry (e.g./media/cdrom ). This corresponds roughly to a mtab entry. - Unix
Mount Point Unix Defines a Unix mount point (e.g./dev ). This corresponds roughly to a fstab entry. - Unix
Output Stream Unix GUnixOutputStream
implementsOutputStream
for writing to a UNIX file descriptor, including asynchronous operations. (If the file descriptor refers to a socket or pipe, this will usepoll()
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
GVolume
interface represents user-visible objects that can be mounted. Note, when porting from GnomeVFS,GVolume
is the moral equivalent ofGnomeVFSDrive
. GVolumeMonitor
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.- GLib type: GObject with reference counted clone semantics.
GZlibCompressor
is an implementation ofConverter
that compresses data using zlib.GZlibDecompressor
is an implementation ofConverter
that decompresses data compressed with zlib.
Enums§
- An enumeration for well-known message buses.
- Results returned from g_converter_convert().
- Enumeration describing different kinds of native credential types.
- Enumeration used to describe the byte order of a D-Bus message.
- Header fields used in #GDBusMessage.
- Message types used in #GDBusMessage.
- #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.
- Enumeration describing how a drive can be started/stopped.
- GEmblemOrigin is used to add information about the origin of the emblem to #GEmblem.
- Used by g_file_set_attributes_from_info() when setting file attributes.
- The data types for file attributes.
- Specifies what type of event a monitor event is.
- Indicates the file’s on-disk type.
- Error codes returned by GIO functions.
- Memory availability warning levels.
- #GMountOperationResult is returned as a result when a request for information is send by the mounting operation.
- The host’s network connectivity state, as reported by #GNetworkMonitor.
- Priority levels for #GNotifications.
- #GPasswordSave is used to indicate the lifespan of a saved password.
- Pollable
Return v2_60
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. - The type of record that g_resolver_lookup_records() or g_resolver_lookup_records_async() 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. - 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
andAF_UNIX
, if available.) - Describes an event occurring on a #GSocketListener. See the #GSocketListener::event signal for more details.
- 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.
- The client authentication mode for a #GTlsServerConnection.
- Flags for g_tls_interaction_request_certificate(), g_tls_interaction_request_certificate_async(), and g_tls_interaction_invoke_request_certificate().
- 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 g_tls_database_lookup_certificate_for_handle(), g_tls_database_lookup_certificate_issuer(), and g_tls_database_lookup_certificates_issued_by().
- 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.
- TlsProtocol
Version v2_70
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 beUnknown
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. - TlsRehandshake
Mode Deprecated When to allow rehandshaking. See g_tls_connection_set_rehandshake_mode(). - Used to select the type of data format to use for #GZlibDecompressor and #GZlibCompressor.
Statics§
- Extension point for debug control functionality. See [Extending GIO][extending-gio].
- The string used to obtain a Unix device path with g_drive_get_identifier().
- A key in the “access” namespace for checking deletion privileges.
- A key in the “access” namespace for getting execution privileges.
- A key in the “access” namespace for getting read privileges.
- A key in the “access” namespace for checking renaming privileges.
- A key in the “access” namespace for checking trashing privileges.
- A key in the “access” namespace for getting write privileges.
- A key in the “dos” namespace for checking if the file’s archive flag is set.
- A key in the “dos” namespace for checking if the file is a NTFS mount point (a volume mount or a junction point).
- A key in the “dos” namespace for checking if the file’s backup flag is set.
- A key in the “dos” namespace for getting the file NTFS reparse tag.
- A key in the “etag” namespace for getting the value of the file’s entity tag.
- A key in the “filesystem” namespace for getting the number of bytes of free space left on the file system.
- A key in the “filesystem” namespace for checking if the file system is read only.
- A key in the “filesystem” namespace for checking if the file system is remote.
- A key in the “filesystem” namespace for getting the total size (in bytes) of the file system, used in g_file_query_filesystem_info().
- A key in the “filesystem” namespace for getting the file system’s type.
- A key in the “filesystem” namespace for getting the number of bytes used by data on the file system.
- A key in the “filesystem” namespace for hinting a file manager application whether it should preview (e.g. thumbnail) files on the file system.
- A key in the “gvfs” namespace that gets the name of the current GVFS backend in use.
- A key in the “id” namespace for getting a file identifier.
- A key in the “id” namespace for getting the file system identifier.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be ejected.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is mountable.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be polled.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be started.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be started degraded.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) can be stopped.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is unmountable.
- A key in the “mountable” namespace for getting the HAL UDI for the mountable file.
- A key in the “mountable” namespace for checking if a file (of type G_FILE_TYPE_MOUNTABLE) is automatically polled for media.
- A key in the “mountable” namespace for getting the #GDriveStartStopType.
- A key in the “mountable” namespace for getting the unix device.
- A key in the “mountable” namespace for getting the unix device file.
- A key in the “owner” namespace for getting the file owner’s group.
- A key in the “owner” namespace for getting the user name of the file’s owner.
- A key in the “owner” namespace for getting the real name of the user that owns the file.
- A key in the “preview” namespace for getting a #GIcon that can be used to get preview of the file.
- A key in the “recent” namespace for getting time, when the metadata for the file in
recent:///
was last changed. - A key in the “selinux” namespace for getting the file’s SELinux context.
- A key in the “standard” namespace for getting the amount of disk space that is consumed by the file (in bytes).
- A key in the “standard” namespace for getting the content type of the file.
- A key in the “standard” namespace for getting the copy name of the file.
- A key in the “standard” namespace for getting the description of the file.
- A key in the “standard” namespace for getting the display name of the file.
- A key in the “standard” namespace for edit name of the file.
- A key in the “standard” namespace for getting the fast content type.
- A key in the “standard” namespace for getting the icon for the file.
- A key in the “standard” namespace for checking if a file is a backup file.
- A key in the “standard” namespace for checking if a file is hidden.
- A key in the “standard” namespace for checking if the file is a symlink. Typically the actual type is something else, if we followed the symlink to get the type.
- A key in the “standard” namespace for checking if a file is virtual.
- A key in the “standard” namespace for checking if a file is volatile. This is meant for opaque, non-POSIX-like backends to indicate that the URI is not persistent. Applications should look at
FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET
for the persistent URI. - A key in the “standard” namespace for getting the name of the file.
- A key in the “standard” namespace for getting the file’s size (in bytes).
- A key in the “standard” namespace for setting the sort order of a file.
- A key in the “standard” namespace for getting the symbolic icon for the file.
- A key in the “standard” namespace for getting the symlink target, if the file is a symlink.
- A key in the “standard” namespace for getting the target URI for the file, in the case of
FileType::Shortcut
orFileType::Mountable
files. - A key in the “standard” namespace for storing file types.
- A key in the “thumbnail” namespace for checking if thumbnailing failed.
- A key in the “thumbnail” namespace for checking if thumbnailing failed for the large image.
- A key in the “thumbnail” namespace for checking if thumbnailing failed for the normal image.
- A key in the “thumbnail” namespace for checking if thumbnailing failed for the x-large image.
- A key in the “thumbnail” namespace for checking if thumbnailing failed for the xx-large image.
- A key in the “thumbnail” namespace for checking whether the thumbnail is outdated.
- A key in the “thumbnail” namespace for checking whether the large thumbnail is outdated.
- A key in the “thumbnail” namespace for checking whether the normal thumbnail is outdated.
- A key in the “thumbnail” namespace for checking whether the x-large thumbnail is outdated.
- A key in the “thumbnail” namespace for checking whether the xx-large thumbnail is outdated.
- A key in the “thumbnail” namespace for getting the path to the thumbnail image with the biggest size available.
- A key in the “thumbnail” namespace for getting the path to the large thumbnail image.
- A key in the “thumbnail” namespace for getting the path to the normal thumbnail image.
- A key in the “thumbnail” namespace for getting the path to the x-large thumbnail image.
- A key in the “thumbnail” namespace for getting the path to the xx-large thumbnail image.
- A key in the “time” namespace for getting the time the file was last accessed.
- A key in the “time” namespace for getting the nanoseconds of the time the file was last accessed. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_ACCESS. Corresponding #GFileAttributeType is
FileAttributeType::Uint32
. - A key in the “time” namespace for getting the microseconds of the time the file was last accessed.
- A key in the “time” namespace for getting the time the file was last changed.
- A key in the “time” namespace for getting the nanoseconds of the time the file was last changed. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_CHANGED. Corresponding #GFileAttributeType is
FileAttributeType::Uint32
. - A key in the “time” namespace for getting the microseconds of the time the file was last changed.
- A key in the “time” namespace for getting the time the file was created.
- A key in the “time” namespace for getting the nanoseconds of the time the file was created. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_CREATED. Corresponding #GFileAttributeType is
FileAttributeType::Uint32
. - A key in the “time” namespace for getting the microseconds of the time the file was created.
- A key in the “time” namespace for getting the time the file was last modified.
- A key in the “time” namespace for getting the nanoseconds of the time the file was last modified. This should be used in conjunction with #G_FILE_ATTRIBUTE_TIME_MODIFIED. Corresponding #GFileAttributeType is
FileAttributeType::Uint32
. - A key in the “time” namespace for getting the microseconds of the time the file was last modified.
- A key in the “trash” namespace for getting the deletion date and time of a file inside the
trash:///
folder. - A key in the “trash” namespace for getting the number of (toplevel) items that are present in the
trash:///
folder. - A key in the “trash” namespace for getting the original path of a file inside the
trash:///
folder before it was trashed. - A key in the “unix” namespace for getting the number of blocks allocated for the file.
- A key in the “unix” namespace for getting the block size for the file system.
- A key in the “unix” namespace for getting the device id of the device the file is located on (see stat() documentation).
- A key in the “unix” namespace for getting the group ID for the file.
- A key in the “unix” namespace for getting the inode of the file.
- A key in the “unix” namespace for checking if the file represents a UNIX mount point.
- A key in the “unix” namespace for getting the mode of the file (e.g. whether the file is a regular file, symlink, etc).
- A key in the “unix” namespace for getting the number of hard links for a file.
- A key in the “unix” namespace for getting the device ID for the file (if it is a special file).
- A key in the “unix” namespace for getting the user ID for the file.
- Extension point for memory usage monitoring functionality. See [Extending GIO][extending-gio].
- The menu item attribute which holds the action name of the item. Action names are namespaced with an identifier for the action group in which the action resides. For example, “win.” for window-specific actions and “app.” for application-wide actions.
- The menu item attribute that holds the namespace for all action names in menus that are linked from this item.
- The menu item attribute which holds the icon of the item.
- The menu item attribute which holds the label of the item.
- The menu item attribute which holds the target with which the item’s action will be activated.
- The name of the link that associates a menu item with a section. The linked menu will usually be shown in place of the menu item, using the item’s label as a header.
- The name of the link that associates a menu item with a submenu.
- Extension point for network status monitoring functionality. See [Extending GIO][extending-gio].
- Extension point for power profile usage monitoring functionality. See [Extending GIO][extending-gio].
- Extension point for proxy functionality. See [Extending GIO][extending-gio].
- Extension point for proxy resolving functionality. See [Extending GIO][extending-gio].
- Extension point for #GSettingsBackend functionality.
- Extension point for TLS functionality via #GTlsBackend. See [Extending GIO][extending-gio].
- The purpose used to verify the client certificate in a TLS connection. Used by TLS servers.
- The purpose used to verify the server certificate in a TLS connection. This is the most common purpose in use. Used by TLS clients.
- Extension point for #GVfs functionality. See [Extending GIO][extending-gio].
- The string used to obtain the volume class with g_volume_get_identifier().
- VOLUM
E_ IDENTIFIE R_ KIND_ HAL_ UDI Deprecated The string used to obtain a Hal UDI with g_volume_get_identifier(). - The string used to obtain a filesystem label with g_volume_get_identifier().
- The string used to obtain a NFS mount with g_volume_get_identifier().
- The string used to obtain a Unix device path with g_volume_get_identifier().
- The string used to obtain a UUID with g_volume_get_identifier().
- Extension point for volume monitor functionality. See [Extending GIO][extending-gio].
Functions§
- Starts acquiring @name on the bus specified by @bus_type and calls @name_acquired_handler and @name_lost_handler when the name is acquired respectively lost. Callbacks will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this function from.
- Like g_bus_own_name() but takes a #GDBusConnection instead of a #GBusType.
- Starts watching @name on the bus specified by @bus_type and calls @name_appeared_handler and @name_vanished_handler when the name is known to have an owner respectively known to lose its owner. Callbacks will be invoked in the [thread-default main context][g-main-context-push-thread-default] of the thread you are calling this function from.
- Like g_bus_watch_name() but takes a #GDBusConnection instead of a #GBusType.
- Runs a blocking I/O task on the I/O thread pool.