Package ch.bailu.gtk.gio
package ch.bailu.gtk.gio
Generated: Gio 2.0
API Reference Manual: https://docs.gtk.org/}
Functions class:
Constants class:
Generated from: Gio-2.0.gir
Shared library: libgio-2.0.so.0
Configured library: gio-2.0
API Reference Manual: https://docs.gtk.org/}
Functions class:
Gio
Constants class:
GioConstants
Generated from: Gio-2.0.gir
Shared library: libgio-2.0.so.0
Configured library: gio-2.0
-
ClassDescription#GAction represents a single named action.This struct defines a single action.#GActionGroup represents a group of actions.The virtual function table for #GActionGroup.The virtual function table for #GAction.The GActionMap interface is implemented by #GActionGroup
implementations that operate by containing a number of
named #GAction instances, such as #GSimpleActionGroup.The virtual function table for #GActionMap.#GAppInfo and #GAppLaunchContext are used for describing and launching
applications installed on the system.Application Information interface, for operating system portability.#GAppInfoMonitor is a very simple object used for monitoring the app
info database for changes (ie: newly installed or removed
applications).Integrating the launch with the launching application.A #GApplication is the foundation of an application.Virtual function table for #GApplication.#GApplicationCommandLine represents a command-line invocation of
an application.The #GApplicationCommandLineClass-struct
contains private data only.This is the asynchronous version of #GInitable; it behaves the same
in all ways except that initialization is asynchronous.Provides an interface for asynchronous initializing object such that
initialization may fail.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 #GFilterOutputStream and provides
for buffered writes.#GBytesIcon specifies an image held in memory in a common format (usually
png) to be used as icon.GCancellable is a thread-safe operation cancellation stack used
throughout GIO to allow for cancellation of synchronous and
asynchronous operations.#GCharsetConverter is an implementation of #GConverter based on
GIConv.#GConverter is implemented by objects that convert
binary data in various ways.Provides an interface for converting data from one type
to another type.Converter input stream implements #GInputStream and allows
conversion of data of various types during reading.Converter output stream implements #GOutputStream and allows
conversion of data of various types during reading.The #GCredentials type is a reference-counted wrapper for native
credentials.A #GDatagramBased is a networking interface for representing datagram-based
communications.Provides an interface for socket-like objects which have datagram semantics,
following the Berkeley sockets API.Data input stream implements #GInputStream and includes functions for
reading structured data directly from a binary input stream.Data output stream implements #GOutputStream and includes functions for
writing data directly to an output stream.#GDBusActionGroup is an implementation of the #GActionGroup
interface that can be used as a proxy for an action group
that is exported over D-Bus with g_dbus_connection_export_action_group().Information about an annotation.Information about an argument for a method or a signal.The #GDBusAuthObserver type provides a mechanism for participating
in how a #GDBusServer (or a #GDBusConnection) authenticates remote
peers.The #GDBusConnection type is used for D-Bus connections to remote
peers such as a message buses.Struct used in g_dbus_error_register_error_domain().The #GDBusInterface type is the base type for D-Bus interfaces both
on the service side (see #GDBusInterfaceSkeleton) and client side
(see #GDBusProxy).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.#GDBusMenuModel is an implementation of #GMenuModel that can be used
as a proxy for a menu model that is exported over D-Bus with
g_dbus_connection_export_menu_model().A type for representing D-Bus messages that can be sent or received
on a #GDBusConnection.Information about a method on an D-Bus interface.Instances of the #GDBusMethodInvocation class are used when
handling D-Bus method calls.Information about nodes in a remote object hierarchy.The #GDBusObject type is the base type for D-Bus objects on both
the service side (see #GDBusObjectSkeleton) and the client side
(see #GDBusObjectProxy).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.#GDBusObjectManagerClient is used to create, monitor and delete object
proxies for remote objects exported by a #GDBusObjectManagerServer (or any
code implementing the
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface).Class structure for #GDBusObjectManagerClient.Base type for D-Bus object managers.#GDBusObjectManagerServer is used to export #GDBusObject instances using
the standardized
[org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
interface.Class structure for #GDBusObjectManagerServer.A #GDBusObjectProxy is an object used to represent a remote object
with one or more D-Bus interfaces.Class structure for #GDBusObjectProxy.A #GDBusObjectSkeleton instance is essentially a group of D-Bus
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.Class structure for #GDBusProxy.#GDBusServer is a helper for listening to and accepting D-Bus
connections.Information about a signal on a D-Bus interface.Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().#GDebugController is an interface to expose control of debugging features and
debug output.#GDebugControllerDBus is an implementation of #GDebugController which exposes
debug settings as a D-Bus object.The virtual function table for #GDebugControllerDBus.The virtual function table for #GDebugController.#GDesktopAppInfo is an implementation of #GAppInfo 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.#GDrive - this represent a piece of hardware connected to the machine.Interface for creating #GDrive implementations.#GDtlsClientConnection is the client-side subclass of
#GDtlsConnection, representing a client-side DTLS connection.vtable for a #GDtlsClientConnection implementation.#GDtlsConnection is the base DTLS connection class type, which wraps
a #GDatagramBased and provides DTLS encryption on top of it.Virtual method table for a #GDtlsConnection implementation.#GDtlsServerConnection is the server-side subclass of #GDtlsConnection,
representing a server-side DTLS connection.vtable for a #GDtlsServerConnection implementation.#GEmblem is an implementation of #GIcon that supports
having an emblem, which is an icon with additional properties.#GEmblemedIcon is an implementation of #GIcon that supports
adding an emblem to an icon.#GFile is a high level abstraction for manipulating files on a
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.#GFileDescriptorBased is implemented by streams (implementations of
#GInputStream or #GOutputStream) that are based on file descriptors.An interface for file descriptor based io objects.#GFileEnumerator allows you to operate on a set of #GFiles,
returning a #GFileInfo structure for each file enumerated (e.g.#GFileIcon specifies an icon by pointing to an image file
to be used as icon.An interface for writing VFS file handles.Functionality for manipulating basic metadata for files.GFileInputStream provides input streams that take their
content from a file.GFileIOStream provides io streams that both read and write to the same
file handle.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.GFileOutputStream provides output streams that write their
content to a file.Base class for input stream implementations that perform some
kind of filtering operation on a base stream.Base class for output stream implementations that perform some
kind of filtering operation on a base stream.#GIcon is a very minimal interface for icons.GIconIface is used to implement GIcon types for various
different systems.#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.An IPv4 or IPv6 socket address; that is, the combination of a
#GInetAddress and a port number.#GInitable is implemented by objects that can fail during
initialization.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.#GInputStream has functions to read from a stream (g_input_stream_read()),
to close a stream (g_input_stream_close()) and to skip some content
(g_input_stream_skip()).Structure used for scatter/gather data input.Provides an interface and default functions for loading and unloading
modules.GIOStream represents an object that has both read and write streams.#GListModel is an interface that represents a mutable list of
#GObjects.The virtual function table for #GListModel.#GListStore is a simple implementation of #GListModel that stores all
items in memory.Extends the #GIcon interface and adds the ability to
load icons from streams.Interface for icons that can be loaded as a stream.#GMemoryInputStream is a class for using arbitrary
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.The virtual function table for #GMemoryMonitor.#GMemoryOutputStream is a class for using arbitrary
memory chunks as output for GIO streaming output operations.#GMenu is a simple implementation of #GMenuModel.#GMenuAttributeIter is an opaque structure type.#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.The #GMount interface represents user-visible mounts.Interface for implementing operations for mounts.#GMountOperation provides a mechanism for interacting with the user.A socket address of some unknown native type.#GNetworkAddress provides an easy way to resolve a hostname and
then attempt to connect to that host, handling the possibility of
multiple IP addresses and multiple address families.#GNetworkMonitor provides an easy-to-use cross-platform API
for monitoring network connectivity.The virtual function table for #GNetworkMonitor.Like #GNetworkAddress does with hostnames, #GNetworkService
provides an easy way to resolve a SRV record, and then attempt to
connect to one of the hosts that implements that service, handling
service priority/weighting, multiple IP addresses, and multiple
address families.#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.#GOutputStream has functions to write to a stream (g_output_stream_write()),
to close a stream (g_output_stream_close()) and to flush pending writes
(g_output_stream_flush()).Structure used for scatter/gather data output.A #GPermission represents the status of the caller's permission to
perform a certain action.#GPollableInputStream is implemented by #GInputStreams that
can be polled for readiness to read.The interface for pollable input streams.#GPollableOutputStream is implemented by #GOutputStreams that
can be polled for readiness to write.The interface for pollable output streams.#GPowerProfileMonitor makes it possible for applications as well as OS components
to monitor system power profiles and act upon them.The virtual function table for #GPowerProfileMonitor.A #GPropertyAction is a way to get a #GAction with a state value
reflecting and controlling the value of a #GObject property.A #GProxy handles connecting to a remote host via a given type of
proxy server.Support for proxied #GInetSocketAddress.Class structure for #GProxyAddress.#GProxyAddressEnumerator is a wrapper around #GSocketAddressEnumerator which
takes the #GSocketAddress instances returned by the #GSocketAddressEnumerator
and wraps them in #GProxyAddress instances, using the given
#GProxyAddressEnumerator:proxy-resolver.Class structure for #GProxyAddressEnumerator.Provides an interface for handling proxy connection and payload.#GProxyResolver provides synchronous and asynchronous network proxy
resolution.The virtual function table for #GProxyResolver.The GRemoteActionGroup interface is implemented by #GActionGroup
instances that either transmit action invocations to other processes
or receive action invocations in the local process from other
processes.The virtual function table for #GRemoteActionGroup.#GResolver provides cancellable synchronous and asynchronous DNS
resolution, for hostnames (g_resolver_lookup_by_address(),
g_resolver_lookup_by_name() and their async variants) and SRV
(service) records (g_resolver_lookup_service()).Applications and libraries often contain binary or textual data that is
really part of the application, rather than user data.#GSeekable is implemented by streams (implementations of
#GInputStream or #GOutputStream) that support seeking.Provides an interface for implementing seekable functionality on I/O Streams.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.Class structure for #GSettingsBackend.The #GSettingsSchemaSource and #GSettingsSchema APIs provide a
mechanism for advanced control over the loading of schemas and a
mechanism for introspecting their content.#GSettingsSchemaKey is an opaque data structure and can only be accessed
using the following functions.This is an opaque structure type.A #GSimpleAction is the obvious simple implementation of the #GAction
interface.#GSimpleActionGroup is a hash table filled with #GAction objects,
implementing the #GActionGroup and #GActionMap interfaces.As of GLib 2.46, #GSimpleAsyncResult is deprecated in favor of
#GTask, which provides a simpler API.GSimpleIOStream creates a #GIOStream from an arbitrary #GInputStream and
#GOutputStream.#GSimplePermission is a trivial implementation of #GPermission that
represents a permission that is either always or never allowed.#GSimpleProxyResolver is a simple #GProxyResolver implementation
that handles a single default proxy, multiple URI-scheme-specific
proxies, and a list of hosts that proxies should not be used for.A #GSocket is a low-level networking primitive.#GSocketAddress is the equivalent of struct sockaddr in the BSD
sockets API.#GSocketAddressEnumerator is an enumerator type for #GSocketAddress
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.Objects that describe one or more potential socket endpoints
implement #GSocketConnectable.Provides an interface for returning a #GSocketAddressEnumerator
and #GProxyAddressEnumerator#GSocketConnection is a #GIOStream for a connected socket.A #GSocketControlMessage is a special-purpose utility message that
can be sent to or received from a #GSocket.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.Class structure for #GSocketListener.A #GSocketService is an object that represents a service that
is provided to the network or over local sockets.Class structure for #GSocketService.SRV (service) records are used by some network protocols to provide
service-specific aliasing and load-balancing.#GStaticResource is an opaque data structure and can only be accessed
using the following functions.#GSubprocess 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 #GTask represents and manages a cancellable "task".This is the subclass of #GSocketConnection that is created
for TCP/IP sockets.A #GTcpWrapperConnection can be used to wrap a #GIOStream that is
based on a #GSocket, but which is not actually a
#GSocketConnection.A helper class for testing code which uses D-Bus without touching the user's
session bus.#GThemedIcon is an implementation of #GIcon that supports icon themes.A #GThreadedSocketService is a simple subclass of #GSocketService
that handles incoming connections by creating a worker thread and
dispatching the connection to it by emitting the
#GThreadedSocketService::run signal in the new thread.TLS (Transport Layer Security, aka SSL) and DTLS backend.Provides an interface for describing TLS-related types.A certificate used for TLS authentication and encryption.#GTlsClientConnection is the client-side subclass of
#GTlsConnection, representing a client-side TLS connection.vtable for a #GTlsClientConnection implementation.#GTlsConnection is the base TLS connection class type, which wraps
a #GIOStream and provides TLS encryption on top of it.The class structure for the #GTlsConnection type.#GTlsDatabase is used to look up certificates and other information
from a certificate or key store.The class for #GTlsDatabase.#GTlsFileDatabase is implemented by #GTlsDatabase objects which 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.The class for #GTlsInteraction.Holds a password used in TLS.Class structure for #GTlsPassword.#GTlsServerConnection is the server-side subclass of #GTlsConnection,
representing a server-side TLS connection.vtable for a #GTlsServerConnection implementation.This is the subclass of #GSocketConnection that is created
for UNIX domain sockets.This #GSocketControlMessage contains a #GCredentials instance.Class structure for #GUnixCredentialsMessage.A #GUnixFDList contains a list of file descriptors.This #GSocketControlMessage contains a #GUnixFDList.#GUnixInputStream implements #GInputStream for reading from a UNIX
file descriptor, including asynchronous operations.Defines a Unix mount entry (e.g.Watches #GUnixMounts for changes.Defines a Unix mount point (e.g.#GUnixOutputStream implements #GOutputStream for writing to a UNIX
file descriptor, including asynchronous operations.Support for UNIX-domain (also known as local) sockets.Entry point for using GIO functionality.The #GVolume interface represents user-visible objects that can be
mounted.Interface for implementing operations for mountable volumes.#GVolumeMonitor is for listing the user interesting devices and volumes
on the computer.#GZlibCompressor is an implementation of #GConverter that
compresses data using zlib.#GZlibDecompressor is an implementation of #GConverter that
decompresses data compressed with zlib.