Merge lp:~attente/gobject-introspection/glib-gio-gir into lp:ubuntu/saucy/gobject-introspection

[William Hua]

Cherry pick commit 70cc4b9479943ec95d3b95b1786b79c9bfd2cce0 from upstream to get added GBytesIcon and GMenuModel icon support.

Cherry pick commit 70cc4b9479943ec95d3b95b1786b79c9bfd2cce0 from upstream to get added GBytesIcon and GMenuModel icon support.

[Martin Pitt (pitti)]

It seems you forgot to actually bzr add the new patch.

Also, can you please link this to an upstream bug/patch? I'd really like to fix this in upstream gobject-introspection and then sync it via Debian. I don't want the API in Ubuntu be different than upstream/Debian/other distros.

Thanks!

review: Needs Fixing

[Martin Pitt (pitti)]

Rejecting because of above reason. Please feel free to subscribe me to the upstream bug, I'll handle it in due course.

review: Disapprove

[Martin Pitt (pitti)]

Oh sorry, the preview diff here was truncated. How did you generate that patch? Just regenerating the annotations with misc/update-glib-annotations.py ? Or did you actually change annotations in glib for this?

[William Hua (attente)]

Hi, sorry for neglecting this for so long. I reverted the original annotations update which I had regenerated manually, and replaced it with a cherry pick of commit 70cc4b9479943ec95d3b95b1786b79c9bfd2cce0 from upstream.

[Martin Pitt (pitti)]

I just uploaded g-i 1.37.4, this patch should be included there.

Unmerged revisions

44. By William Hua on 2013-07-08

Cherry pick 70cc4b9479943ec95d3b95b1786b79c9bfd2cce0 from upstream.

43. By William Hua on 2013-07-08

Revert debian/patches/update-gir-for-gicon-support.patch.

42. By William Hua on 2013-06-18

* debian/patches/update-gir-for-gicon-support.patch:
  - Update glib-2.0.gir and gio-2.0.gir from source annotations.

=== added file '.pc/applied-patches'
--- .pc/applied-patches	1970-01-01 00:00:00 +0000
+++ .pc/applied-patches	2013-06-18 17:04:26 +0000
@@ -0,0 +1,1 @@
+update-gir-for-gicon-support.patch

=== removed file '.pc/applied-patches'
=== added directory '.pc/update-gir-for-gicon-support.patch'
=== added directory '.pc/update-gir-for-gicon-support.patch/gir'
=== added file '.pc/update-gir-for-gicon-support.patch/gir/gio-2.0.c'
--- .pc/update-gir-for-gicon-support.patch/gir/gio-2.0.c	1970-01-01 00:00:00 +0000
+++ .pc/update-gir-for-gicon-support.patch/gir/gio-2.0.c	2013-06-18 17:04:26 +0000
@@ -0,0 +1,33538 @@
+/************************************************************/
+/* THIS FILE IS GENERATED DO NOT EDIT */
+/************************************************************/
+
+/**
+ * GAction:enabled:
+ *
+ * If @action is currently enabled.
+ *
+ * If the action is disabled then calls to g_action_activate() and
+ * g_action_change_state() have no effect.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GAction:name:
+ *
+ * The name of the action.  This is mostly meaningful for identifying
+ * the action once it has been added to a #GActionGroup.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GAction:parameter-type:
+ *
+ * The type of the parameter that must be given when activating the
+ * action.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GAction:state:
+ *
+ * The state of the action, or %NULL if the action is stateless.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GAction:state-type:
+ *
+ * The #GVariantType of the state that the action has, or %NULL if the
+ * action is stateless.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GActionEntry:
+ * @name: the name of the action
+ * @activate: the callback to connect to the "activate" signal of the action
+ * @parameter_type: the type of the parameter that must be passed to the activate function for this action, given as a single GVariant type string (or %NULL for no parameter)
+ * @state: the initial state for this action, given in GVariant text format.  The state is parsed with no extra type information, so type tags must be added to the string if they are necessary.
+ * @change_state: the callback to connect to the "change-state" signal of the action
+ *
+ * This struct defines a single action.  It is for use with
+ * g_action_map_add_action_entries().
+ *
+ * The order of the items in the structure are intended to reflect
+ * frequency of use.  It is permissible to use an incomplete initialiser
+ * in order to leave some of the later values as %NULL.  All values
+ * after @name are optional.  Additional optional fields may be added in
+ * the future.
+ *
+ * See g_action_map_add_action_entries() for an example.
+ */
+
+
+/**
+ * GActionGroup::action-added:
+ * @action_group: the #GActionGroup that changed
+ * @action_name: the name of the action in @action_group
+ *
+ * Signals that a new action was just added to the group.
+ * This signal is emitted after the action has been added
+ * and is now visible.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GActionGroup::action-enabled-changed:
+ * @action_group: the #GActionGroup that changed
+ * @action_name: the name of the action in @action_group
+ * @enabled: whether the action is enabled or not
+ *
+ * Signals that the enabled status of the named action has changed.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GActionGroup::action-removed:
+ * @action_group: the #GActionGroup that changed
+ * @action_name: the name of the action in @action_group
+ *
+ * Signals that an action is just about to be removed from the group.
+ * This signal is emitted before the action is removed, so the action
+ * is still visible and can be queried from the signal handler.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GActionGroup::action-state-changed:
+ * @action_group: the #GActionGroup that changed
+ * @action_name: the name of the action in @action_group
+ * @value: the new value of the state
+ *
+ * Signals that the state of the named action has changed.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GActionGroupInterface:
+ * @has_action: the virtual function pointer for g_action_group_has_action()
+ * @list_actions: the virtual function pointer for g_action_group_list_actions()
+ * @get_action_parameter_type: the virtual function pointer for g_action_group_get_action_parameter_type()
+ * @get_action_state_type: the virtual function pointer for g_action_group_get_action_state_type()
+ * @get_action_state_hint: the virtual function pointer for g_action_group_get_action_state_hint()
+ * @get_action_enabled: the virtual function pointer for g_action_group_get_action_enabled()
+ * @get_action_state: the virtual function pointer for g_action_group_get_action_state()
+ * @change_action_state: the virtual function pointer for g_action_group_change_action_state()
+ * @query_action: the virtual function pointer for g_action_group_query_action()
+ * @activate_action: the virtual function pointer for g_action_group_activate_action()
+ * @action_added: the class closure for the #GActionGroup::action-added signal
+ * @action_removed: the class closure for the #GActionGroup::action-removed signal
+ * @action_enabled_changed: the class closure for the #GActionGroup::action-enabled-changed signal
+ * @action_state_changed: the class closure for the #GActionGroup::action-enabled-changed signal
+ *
+ * The virtual function table for #GActionGroup.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GActionInterface:
+ * @get_name: the virtual function pointer for g_action_get_name()
+ * @get_parameter_type: the virtual function pointer for g_action_get_parameter_type()
+ * @get_state_type: the virtual function pointer for g_action_get_state_type()
+ * @get_state_hint: the virtual function pointer for g_action_get_state_hint()
+ * @get_enabled: the virtual function pointer for g_action_get_enabled()
+ * @get_state: the virtual function pointer for g_action_get_state()
+ * @change_state: the virtual function pointer for g_action_change_state()
+ * @activate: the virtual function pointer for g_action_activate().  Note that #GAction does not have an 'activate' signal but that implementations of it may have one.
+ *
+ * The virtual function table for #GAction.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GActionMapInterface:
+ * @lookup_action: the virtual function pointer for g_action_map_lookup_action()
+ * @add_action: the virtual function pointer for g_action_map_add_action()
+ * @remove_action: the virtual function pointer for g_action_map_remove_action()
+ *
+ * The virtual function table for #GActionMap.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GApplication::activate:
+ * @application: the application
+ *
+ * The ::activate signal is emitted on the primary instance when an
+ * activation occurs. See g_application_activate().
+ */
+
+
+/**
+ * GApplication::command-line:
+ * @application: the application
+ * @command_line: a #GApplicationCommandLine representing the passed commandline
+ *
+ * The ::command-line signal is emitted on the primary instance when
+ * a commandline is not handled locally. See g_application_run() and
+ * the #GApplicationCommandLine documentation for more information.
+ *
+ * Returns: An integer that is set as the exit status for the calling process. See g_application_command_line_set_exit_status().
+ */
+
+
+/**
+ * GApplication::open:
+ * @application: the application
+ * @files: (array length=n_files) (element-type GFile): an array of #GFiles
+ * @n_files: the length of @files
+ * @hint: a hint provided by the calling instance
+ *
+ * The ::open signal is emitted on the primary instance when there are
+ * files to open. See g_application_open() for more information.
+ */
+
+
+/**
+ * GApplication::shutdown:
+ * @application: the application
+ *
+ * The ::shutdown signal is emitted only on the registered primary instance
+ * immediately after the main loop terminates.
+ */
+
+
+/**
+ * GApplication::startup:
+ * @application: the application
+ *
+ * The ::startup signal is emitted on the primary instance immediately
+ * after registration. See g_application_register().
+ */
+
+
+/**
+ * GApplicationClass:
+ * @startup: invoked on the primary instance immediately after registration
+ * @shutdown: invoked only on the registered primary instance immediately after the main loop terminates
+ * @activate: invoked on the primary instance when an activation occurs
+ * @open: invoked on the primary instance when there are files to open
+ * @command_line: invoked on the primary instance when a command-line is not handled locally
+ * @local_command_line: invoked (locally) when the process has been invoked via commandline execution (as opposed to, say, D-Bus activation - which is not currently supported by GApplication). The virtual function has the chance to inspect (and possibly replace) the list of command line arguments. See g_application_run() for more information.
+ * @before_emit: invoked on the primary instance before 'activate', 'open', 'command-line' or any action invocation, gets the 'platform data' from the calling instance
+ * @after_emit: invoked on the primary instance after 'activate', 'open', 'command-line' or any action invocation, gets the 'platform data' from the calling instance
+ * @add_platform_data: invoked (locally) to add 'platform data' to be sent to the primary instance when activating, opening or invoking actions
+ * @quit_mainloop: Used to be invoked on the primary instance when the use count of the application drops to zero (and after any inactivity timeout, if requested). Not used anymore since 2.32
+ * @run_mainloop: Used to be invoked on the primary instance from g_application_run() if the use-count is non-zero. Since 2.32, GApplication is iterating the main context directly and is not using @run_mainloop anymore
+ * @dbus_register: invoked locally during registration, if the application is using its D-Bus backend. You can use this to export extra objects on the bus, that need to exist before the application tries to own the bus name. The function is passed the #GDBusConnection to to session bus, and the object path that #GApplication will use to export is D-Bus API. If this function returns %TRUE, registration will proceed; otherwise registration will abort. Since: 2.34
+ * @dbus_unregister: invoked locally during unregistration, if the application is using its D-Bus backend. Use this to undo anything done by the @dbus_register vfunc. Since: 2.34
+ *
+ * Virtual function table for #GApplication.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GApplicationCommandLineClass:
+ *
+ * The <structname>GApplicationCommandLineClass</structname> structure
+ * contains private data only
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GCancellable::cancelled:
+ * @cancellable: a #GCancellable.
+ *
+ * Emitted when the operation has been cancelled.
+ *
+ * Can be used by implementations of cancellable operations. If the
+ * operation is cancelled from another thread, the signal will be
+ * emitted in the thread that cancelled the operation, not the
+ * thread that is running the operation.
+ *
+ * Note that disconnecting from this signal (or any signal) in a
+ * multi-threaded program is prone to race conditions. For instance
+ * it is possible that a signal handler may be invoked even
+ * <emphasis>after</emphasis> a call to
+ * g_signal_handler_disconnect() for that handler has already
+ * returned.
+ *
+ * There is also a problem when cancellation happen
+ * right before connecting to the signal. If this happens the
+ * signal will unexpectedly not be emitted, and checking before
+ * connecting to the signal leaves a race condition where this is
+ * still happening.
+ *
+ * In order to make it safe and easy to connect handlers there
+ * are two helper functions: g_cancellable_connect() and
+ * g_cancellable_disconnect() which protect against problems
+ * like this.
+ *
+ * An example of how to us this:
+ * |[
+ *     /<!-- -->* Make sure we don't do any unnecessary work if already cancelled *<!-- -->/
+ *     if (g_cancellable_set_error_if_cancelled (cancellable))
+ *       return;
+ *
+ *     /<!-- -->* Set up all the data needed to be able to
+ *      * handle cancellation of the operation *<!-- -->/
+ *     my_data = my_data_new (...);
+ *
+ *     id = 0;
+ *     if (cancellable)
+ *       id = g_cancellable_connect (cancellable,
+ *     			      G_CALLBACK (cancelled_handler)
+ *     			      data, NULL);
+ *
+ *     /<!-- -->* cancellable operation here... *<!-- -->/
+ *
+ *     g_cancellable_disconnect (cancellable, id);
+ *
+ *     /<!-- -->* cancelled_handler is never called after this, it
+ *      * is now safe to free the data *<!-- -->/
+ *     my_data_free (my_data);
+ * ]|
+ *
+ * Note that the cancelled signal is emitted in the thread that
+ * the user cancelled from, which may be the main thread. So, the
+ * cancellable signal should not do something that can block.
+ */
+
+
+/**
+ * GCharsetConverter:
+ *
+ * Conversions between character sets.
+ */
+
+
+/**
+ * GCredentials:
+ *
+ * The #GCredentials structure contains only private data and
+ * should only be accessed using the provided API.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GCredentialsClass:
+ *
+ * Class structure for #GCredentials.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusAuthMechanism:credentials:
+ *
+ * If authenticating as a server, this property contains the
+ * received credentials, if any.
+ *
+ * If authenticating as a client, the property contains the
+ * credentials that were sent, if any.
+ */
+
+
+/**
+ * GDBusAuthObserver:
+ *
+ * The #GDBusAuthObserver structure contains only private data and
+ * should only be accessed using the provided API.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusAuthObserver::allow-mechanism:
+ * @observer: The #GDBusAuthObserver emitting the signal.
+ * @mechanism: The name of the mechanism, e.g. <literal>DBUS_COOKIE_SHA1</literal>.
+ *
+ * Emitted to check if @mechanism is allowed to be used.
+ *
+ * Returns: %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not.
+ * Since: 2.34
+ */
+
+
+/**
+ * GDBusAuthObserver::authorize-authenticated-peer:
+ * @observer: The #GDBusAuthObserver emitting the signal.
+ * @stream: A #GIOStream for the #GDBusConnection.
+ * @credentials: (allow-none): Credentials received from the peer or %NULL.
+ *
+ * Emitted to check if a peer that is successfully authenticated
+ * is authorized.
+ *
+ * Returns: %TRUE if the peer is authorized, %FALSE if not.
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusAuthObserverClass:
+ * @authorize_authenticated_peer: Signal class handler for the #GDBusAuthObserver::authorize-authenticated-peer signal.
+ *
+ * Class structure for #GDBusAuthObserverClass.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:
+ *
+ * The #GDBusConnection structure contains only private data and
+ * should only be accessed using the provided API.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection::closed:
+ * @connection: The #GDBusConnection emitting the signal.
+ * @remote_peer_vanished: %TRUE if @connection is closed because the remote peer closed its end of the connection.
+ * @error: (allow-none): A #GError with more details about the event or %NULL.
+ *
+ * Emitted when the connection is closed.
+ *
+ * The cause of this event can be
+ * <itemizedlist>
+ * <listitem><para>
+ *    If g_dbus_connection_close() is called. In this case
+ *    @remote_peer_vanished is set to %FALSE and @error is %NULL.
+ * </para></listitem>
+ * <listitem><para>
+ *    If the remote peer closes the connection. In this case
+ *    @remote_peer_vanished is set to %TRUE and @error is set.
+ * </para></listitem>
+ * <listitem><para>
+ *    If the remote peer sends invalid or malformed data. In this
+ *    case @remote_peer_vanished is set to %FALSE and @error
+ *    is set.
+ * </para></listitem>
+ * </itemizedlist>
+ *
+ * Upon receiving this signal, you should give up your reference to
+ * @connection. You are guaranteed that this signal is emitted only
+ * once.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:address:
+ *
+ * A D-Bus address specifying potential endpoints that can be used
+ * when establishing the connection.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:authentication-observer:
+ *
+ * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:capabilities:
+ *
+ * Flags from the #GDBusCapabilityFlags enumeration
+ * representing connection features negotiated with the other peer.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:closed:
+ *
+ * A boolean specifying whether the connection has been closed.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:exit-on-close:
+ *
+ * A boolean specifying whether the process will be terminated (by
+ * calling <literal>raise(SIGTERM)</literal>) if the connection
+ * is closed by the remote peer.
+ *
+ * Note that #GDBusConnection objects returned by g_bus_get_finish() and
+ * g_bus_get_sync() will (usually) have this property set to %TRUE.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:flags:
+ *
+ * Flags from the #GDBusConnectionFlags enumeration.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:guid:
+ *
+ * The GUID of the peer performing the role of server when
+ * authenticating.
+ *
+ * If you are constructing a #GDBusConnection and pass
+ * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the
+ * #GDBusConnection:flags property then you MUST also set this
+ * property to a valid guid.
+ *
+ * If you are constructing a #GDBusConnection and pass
+ * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the
+ * #GDBusConnection:flags property you will be able to read the GUID
+ * of the other peer here after the connection has been successfully
+ * initialized.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:locked:
+ *
+ * A boolean specifying whether the message is locked.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:stream:
+ *
+ * The underlying #GIOStream used for I/O.
+ *
+ * If this is passed on construction and is a #GSocketConnection,
+ * then the corresponding #GSocket will be put into non-blocking mode.
+ *
+ * While the #GDBusConnection is active, it will interact with this
+ * stream from a worker thread, so it is not safe to interact with
+ * the stream directly.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnection:unique-name:
+ *
+ * The unique name as assigned by the message bus or %NULL if the
+ * connection is not open or not a message bus connection.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusConnectionClass:
+ * @closed: Signal class handler for the #GDBusConnection::closed signal.
+ *
+ * Class structure for #GDBusConnection.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusInterfaceSkeleton::g-authorize-method:
+ * @interface: The #GDBusInterfaceSkeleton emitting the signal.
+ * @invocation: A #GDBusMethodInvocation.
+ *
+ * Emitted when a method is invoked by a remote caller and used to
+ * determine if the method call is authorized.
+ *
+ * Note that this signal is emitted in a thread dedicated to
+ * handling the method call so handlers are allowed to perform
+ * blocking IO. This means that it is appropriate to call
+ * e.g. <ulink
+ * url="http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#polkit-authority-check-authorization-sync">polkit_authority_check_authorization_sync()</ulink>
+ * with the <ulink
+ * url="http://hal.freedesktop.org/docs/polkit/PolkitAuthority.html#POLKIT-CHECK-AUTHORIZATION-FLAGS-ALLOW-USER-INTERACTION:CAPS">POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION</ulink> flag set.
+ *
+ * If %FALSE is returned then no further handlers are run and the
+ * signal handler must take a reference to @invocation and finish
+ * handling the call (e.g. return an error via
+ * g_dbus_method_invocation_return_error()).
+ *
+ * Otherwise, if %TRUE is returned, signal emission continues. If no
+ * handlers return %FALSE, then the method is dispatched. If
+ * @interface has an enclosing #GDBusObjectSkeleton, then the
+ * #GDBusObjectSkeleton::authorize-method signal handlers run before
+ * the handlers for this signal.
+ *
+ * The default class handler just returns %TRUE.
+ *
+ * Please note that the common case is optimized: if no signals
+ * handlers are connected and the default class handler isn't
+ * overridden (for both @interface and the enclosing
+ * #GDBusObjectSkeleton, if any) and #GDBusInterfaceSkeleton:g-flags does
+ * not have the
+ * %G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD
+ * flags set, no dedicated thread is ever used and the call will be
+ * handled in the same thread as the object that @interface belongs
+ * to was exported in.
+ *
+ * Returns: %TRUE if the call is authorized, %FALSE otherwise.
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusInterfaceSkeleton:g-flags:
+ *
+ * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusMessage:
+ *
+ * The #GDBusMessage structure contains only private data and should
+ * only be accessed using the provided API.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusMessageClass:
+ *
+ * Class structure for #GDBusMessage.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusMethodInvocation:
+ *
+ * The #GDBusMethodInvocation structure contains only private data and
+ * should only be accessed using the provided API.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusMethodInvocationClass:
+ *
+ * Class structure for #GDBusMethodInvocation.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusObject::interface-added:
+ * @object: The #GDBusObject emitting the signal.
+ * @interface: The #GDBusInterface that was added.
+ *
+ * Emitted when @interface is added to @object.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObject::interface-removed:
+ * @object: The #GDBusObject emitting the signal.
+ * @interface: The #GDBusInterface that was removed.
+ *
+ * Emitted when @interface is removed from @object.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManager::interface-added:
+ * @manager: The #GDBusObjectManager emitting the signal.
+ * @object: The #GDBusObject on which an interface was added.
+ * @interface: The #GDBusInterface that was added.
+ *
+ * Emitted when @interface is added to @object.
+ *
+ * This signal exists purely as a convenience to avoid having to
+ * connect signals to all objects managed by @manager.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManager::interface-removed:
+ * @manager: The #GDBusObjectManager emitting the signal.
+ * @object: The #GDBusObject on which an interface was removed.
+ * @interface: The #GDBusInterface that was removed.
+ *
+ * Emitted when @interface has been removed from @object.
+ *
+ * This signal exists purely as a convenience to avoid having to
+ * connect signals to all objects managed by @manager.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManager::object-added:
+ * @manager: The #GDBusObjectManager emitting the signal.
+ * @object: The #GDBusObject that was added.
+ *
+ * Emitted when @object is added to @manager.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManager::object-removed:
+ * @manager: The #GDBusObjectManager emitting the signal.
+ * @object: The #GDBusObject that was removed.
+ *
+ * Emitted when @object is removed from @manager.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient::interface-proxy-properties-changed:
+ * @manager: The #GDBusObjectManagerClient emitting the signal.
+ * @object_proxy: The #GDBusObjectProxy on which an interface has properties that are changing.
+ * @interface_proxy: The #GDBusProxy that has properties that are changing.
+ * @changed_properties: A #GVariant containing the properties that changed.
+ * @invalidated_properties: A %NULL terminated array of properties that was invalidated.
+ *
+ * Emitted when one or more D-Bus properties on proxy changes. The
+ * local cache has already been updated when this signal fires. Note
+ * that both @changed_properties and @invalidated_properties are
+ * guaranteed to never be %NULL (either may be empty though).
+ *
+ * This signal exists purely as a convenience to avoid having to
+ * connect signals to all interface proxies managed by @manager.
+ *
+ * This signal is emitted in the
+ * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
+ * that @manager was constructed in.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient::interface-proxy-signal:
+ * @manager: The #GDBusObjectManagerClient emitting the signal.
+ * @object_proxy: The #GDBusObjectProxy on which an interface is emitting a D-Bus signal.
+ * @interface_proxy: The #GDBusProxy that is emitting a D-Bus signal.
+ * @sender_name: The sender of the signal or NULL if the connection is not a bus connection.
+ * @signal_name: The signal name.
+ * @parameters: A #GVariant tuple with parameters for the signal.
+ *
+ * Emitted when a D-Bus signal is received on @interface_proxy.
+ *
+ * This signal exists purely as a convenience to avoid having to
+ * connect signals to all interface proxies managed by @manager.
+ *
+ * This signal is emitted in the
+ * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
+ * that @manager was constructed in.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:bus-type:
+ *
+ * If this property is not %G_BUS_TYPE_NONE, then
+ * #GDBusObjectManagerClient:connection must be %NULL and will be set to the
+ * #GDBusConnection obtained by calling g_bus_get() with the value
+ * of this property.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:connection:
+ *
+ * The #GDBusConnection to use.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:flags:
+ *
+ * Flags from the #GDBusObjectManagerClientFlags enumeration.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:get-proxy-type-destroy-notify:
+ *
+ * A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:get-proxy-type-func:
+ *
+ * The #GDBusProxyTypeFunc to use when determining what #GType to
+ * use for interface proxies or %NULL.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:get-proxy-type-user-data:
+ *
+ * The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:name:
+ *
+ * The well-known name or unique name that the manager is for.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:name-owner:
+ *
+ * The unique name that owns #GDBusObjectManagerClient:name or %NULL if
+ * no-one is currently owning the name. Connect to the
+ * #GObject::notify signal to track changes to this property.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerClient:object-path:
+ *
+ * The object path the manager is for.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerServer:connection:
+ *
+ * The #GDBusConnection to export objects on.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectManagerServer:object-path:
+ *
+ * The object path to register the manager object at.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectProxy:g-connection:
+ *
+ * The connection of the proxy.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectProxy:g-object-path:
+ *
+ * The object path of the proxy.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectSkeleton::authorize-method:
+ * @object: The #GDBusObjectSkeleton emitting the signal.
+ * @interface: The #GDBusInterfaceSkeleton that @invocation is for.
+ * @invocation: A #GDBusMethodInvocation.
+ *
+ * Emitted when a method is invoked by a remote caller and used to
+ * determine if the method call is authorized.
+ *
+ * This signal is like #GDBusInterfaceSkeleton<!-- -->'s
+ * #GDBusInterfaceSkeleton::g-authorize-method signal, except that it is
+ * for the enclosing object.
+ *
+ * The default class handler just returns %TRUE.
+ *
+ * Returns: %TRUE if the call is authorized, %FALSE otherwise.
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusObjectSkeleton:g-object-path:
+ *
+ * The object path where the object is exported.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GDBusProxy::g-properties-changed:
+ * @proxy: The #GDBusProxy emitting the signal.
+ * @changed_properties: A #GVariant containing the properties that changed
+ * @invalidated_properties: A %NULL terminated array of properties that was invalidated
+ *
+ * Emitted when one or more D-Bus properties on @proxy changes. The
+ * local cache has already been updated when this signal fires. Note
+ * that both @changed_properties and @invalidated_properties are
+ * guaranteed to never be %NULL (either may be empty though).
+ *
+ * If the proxy has the flag
+ * %G_DBUS_PROXY_FLAGS_GET_INVALIDATED_PROPERTIES set, then
+ * @invalidated_properties will always be empty.
+ *
+ * This signal corresponds to the
+ * <literal>PropertiesChanged</literal> D-Bus signal on the
+ * <literal>org.freedesktop.DBus.Properties</literal> interface.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy::g-signal:
+ * @proxy: The #GDBusProxy emitting the signal.
+ * @sender_name: (allow-none): The sender of the signal or %NULL if the connection is not a bus connection.
+ * @signal_name: The name of the signal.
+ * @parameters: A #GVariant tuple with parameters for the signal.
+ *
+ * Emitted when a signal from the remote object and interface that @proxy is for, has been received.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-bus-type:
+ *
+ * If this property is not %G_BUS_TYPE_NONE, then
+ * #GDBusProxy:g-connection must be %NULL and will be set to the
+ * #GDBusConnection obtained by calling g_bus_get() with the value
+ * of this property.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-connection:
+ *
+ * The #GDBusConnection the proxy is for.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-default-timeout:
+ *
+ * The timeout to use if -1 (specifying default timeout) is passed
+ * as @timeout_msec in the g_dbus_proxy_call() and
+ * g_dbus_proxy_call_sync() functions.
+ *
+ * This allows applications to set a proxy-wide timeout for all
+ * remote method invocations on the proxy. If this property is -1,
+ * the default timeout (typically 25 seconds) is used. If set to
+ * %G_MAXINT, then no timeout is used.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-flags:
+ *
+ * Flags from the #GDBusProxyFlags enumeration.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-interface-info:
+ *
+ * Ensure that interactions with this proxy conform to the given
+ * interface. This is mainly to ensure that malformed data received
+ * from the other peer is ignored. The given #GDBusInterfaceInfo is
+ * said to be the <emphasis>expected interface</emphasis>.
+ *
+ * The checks performed are:
+ * <itemizedlist>
+ *   <listitem><para>
+ *     When completing a method call, if the type signature of
+ *     the reply message isn't what's expected, the reply is
+ *     discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.
+ *   </para></listitem>
+ *   <listitem><para>
+ *     Received signals that have a type signature mismatch are dropped and
+ *     a warning is logged via g_warning().
+ *   </para></listitem>
+ *   <listitem><para>
+ *     Properties received via the initial <literal>GetAll()</literal> call
+ *     or via the <literal>::PropertiesChanged</literal> signal (on the
+ *     <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties">org.freedesktop.DBus.Properties</ulink> interface) or
+ *     set using g_dbus_proxy_set_cached_property() with a type signature
+ *     mismatch are ignored and a warning is logged via g_warning().
+ *   </para></listitem>
+ * </itemizedlist>
+ * Note that these checks are never done on methods, signals and
+ * properties that are not referenced in the given
+ * #GDBusInterfaceInfo, since extending a D-Bus interface on the
+ * service-side is not considered an ABI break.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-interface-name:
+ *
+ * The D-Bus interface name the proxy is for.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-name:
+ *
+ * The well-known or unique name that the proxy is for.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-name-owner:
+ *
+ * The unique name that owns #GDBusProxy:g-name or %NULL if no-one
+ * currently owns that name. You may connect to #GObject::notify signal to
+ * track changes to this property.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusProxy:g-object-path:
+ *
+ * The object path the proxy is for.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer:
+ *
+ * The #GDBusServer structure contains only private data and
+ * should only be accessed using the provided API.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer::new-connection:
+ * @server: The #GDBusServer emitting the signal.
+ * @connection: A #GDBusConnection for the new connection.
+ *
+ * Emitted when a new authenticated connection has been made. Use
+ * g_dbus_connection_get_peer_credentials() to figure out what
+ * identity (if any), was authenticated.
+ *
+ * If you want to accept the connection, take a reference to the
+ * @connection object and return %TRUE. When you are done with the
+ * connection call g_dbus_connection_close() and give up your
+ * reference. Note that the other peer may disconnect at any time -
+ * a typical thing to do when accepting a connection is to listen to
+ * the #GDBusConnection::closed signal.
+ *
+ * If #GDBusServer:flags contains %G_DBUS_SERVER_FLAGS_RUN_IN_THREAD
+ * then the signal is emitted in a new thread dedicated to the
+ * connection. Otherwise the signal is emitted in the <link
+ * linkend="g-main-context-push-thread-default">thread-default main
+ * loop</link> of the thread that @server was constructed in.
+ *
+ * You are guaranteed that signal handlers for this signal runs
+ * before incoming messages on @connection are processed. This means
+ * that it's suitable to call g_dbus_connection_register_object() or
+ * similar from the signal handler.
+ *
+ * Returns: %TRUE to claim @connection, %FALSE to let other handlers run.
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer:active:
+ *
+ * Whether the server is currently active.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer:address:
+ *
+ * The D-Bus address to listen on.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer:authentication-observer:
+ *
+ * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer:client-address:
+ *
+ * The D-Bus address that clients can use.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer:flags:
+ *
+ * Flags from the #GDBusServerFlags enumeration.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServer:guid:
+ *
+ * The guid of the server.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDBusServerClass:
+ * @new_connection: Signal class handler for the #GDBusServer::new-connection signal.
+ *
+ * Class structure for #GDBusServer.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GDataOutputStream:byte-order:
+ *
+ * Determines the byte ordering that is used when writing
+ * multi-byte entities (such as integers) to the stream.
+ */
+
+
+/**
+ * GDataStream:byte-order:
+ *
+ * The ::byte-order property determines the byte ordering that
+ * is used when reading multi-byte entities (such as integers)
+ * from the stream.
+ */
+
+
+/**
+ * GDataStream:newline-type:
+ *
+ * The :newline-type property determines what is considered
+ * as a line ending when reading complete lines from the stream.
+ */
+
+
+/**
+ * GDesktopAppInfo:
+ *
+ * Information about an installed application from a desktop file.
+ */
+
+
+/**
+ * GDesktopAppInfo:filename:
+ *
+ * The origin filename of this #GDesktopAppInfo
+ */
+
+
+/**
+ * GDrive::changed:
+ * @drive: a #GDrive.
+ *
+ * Emitted when the drive's state has changed.
+ */
+
+
+/**
+ * GDrive::disconnected:
+ * @drive: a #GDrive.
+ *
+ * This signal is emitted when the #GDrive have been
+ * disconnected. If the recipient is holding references to the
+ * object they should release them so the object can be
+ * finalized.
+ */
+
+
+/**
+ * GDrive::eject-button:
+ * @drive: a #GDrive.
+ *
+ * Emitted when the physical eject button (if any) of a drive has
+ * been pressed.
+ */
+
+
+/**
+ * GDrive::stop-button:
+ * @drive: a #GDrive.
+ *
+ * Emitted when the physical stop button (if any) of a drive has
+ * been pressed.
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GFileIcon:file:
+ *
+ * The file containing the icon.
+ */
+
+
+/**
+ * GFileMonitor::changed:
+ * @monitor: a #GFileMonitor.
+ * @file: a #GFile.
+ * @other_file: (allow-none): a #GFile or #NULL.
+ * @event_type: a #GFileMonitorEvent.
+ *
+ * Emitted when @file has been changed.
+ *
+ * If using #G_FILE_MONITOR_SEND_MOVED flag and @event_type is
+ * #G_FILE_MONITOR_EVENT_MOVED, @file will be set to a #GFile containing the
+ * old path, and @other_file will be set to a #GFile containing the new path.
+ *
+ * In all the other cases, @other_file will be set to #NULL.
+ */
+
+
+/**
+ * GFilenameCompleter::got-completion-data:
+ *
+ * Emitted when the file name completion information comes available.
+ */
+
+
+/**
+ * GIOModuleScope:
+ *
+ * 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.
+ *
+ * The scope can be used with g_io_modules_load_all_in_directory_with_scope()
+ * or g_io_modules_scan_all_in_directory_with_scope().
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GInetAddress:
+ *
+ * An IPv4 or IPv6 internet address.
+ */
+
+
+/**
+ * GInetAddress:is-any:
+ *
+ * Whether this is the "any" address for its family.
+ * See g_inet_address_get_is_any().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-link-local:
+ *
+ * Whether this is a link-local address.
+ * See g_inet_address_get_is_link_local().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-loopback:
+ *
+ * Whether this is the loopback address for its family.
+ * See g_inet_address_get_is_loopback().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-mc-global:
+ *
+ * Whether this is a global multicast address.
+ * See g_inet_address_get_is_mc_global().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-mc-link-local:
+ *
+ * Whether this is a link-local multicast address.
+ * See g_inet_address_get_is_mc_link_local().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-mc-node-local:
+ *
+ * Whether this is a node-local multicast address.
+ * See g_inet_address_get_is_mc_node_local().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-mc-org-local:
+ *
+ * Whether this is an organization-local multicast address.
+ * See g_inet_address_get_is_mc_org_local().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-mc-site-local:
+ *
+ * Whether this is a site-local multicast address.
+ * See g_inet_address_get_is_mc_site_local().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-multicast:
+ *
+ * Whether this is a multicast address.
+ * See g_inet_address_get_is_multicast().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddress:is-site-local:
+ *
+ * Whether this is a site-local address.
+ * See g_inet_address_get_is_loopback().
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GInetAddressMask:
+ *
+ * A combination of an IPv4 or IPv6 base address and a length,
+ * representing a range of IP addresses.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GInetSocketAddress:
+ *
+ * An IPv4 or IPv6 socket address, corresponding to a <type>struct
+ * sockaddr_in</type> or <type>struct sockaddr_in6</type>.
+ */
+
+
+/**
+ * GInetSocketAddress:flowinfo:
+ *
+ * The <literal>sin6_flowinfo</literal> field, for IPv6 addresses.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GInetSocketAddress:scope_id:
+ *
+ * The <literal>sin6_scope_id</literal> field, for IPv6 addresses.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GMemoryOutputStream:data:
+ *
+ * Pointer to buffer where data will be written.
+ *
+ * Since: 2.24
+ */
+
+
+/**
+ * GMemoryOutputStream:data-size:
+ *
+ * Size of data written to the buffer.
+ *
+ * Since: 2.24
+ */
+
+
+/**
+ * GMemoryOutputStream:destroy-function: (skip)
+ *
+ * Function called with the buffer as argument when the stream is destroyed.
+ *
+ * Since: 2.24
+ */
+
+
+/**
+ * GMemoryOutputStream:realloc-function: (skip)
+ *
+ * Function with realloc semantics called to enlarge the buffer.
+ *
+ * Since: 2.24
+ */
+
+
+/**
+ * GMemoryOutputStream:size:
+ *
+ * Current size of the data buffer.
+ *
+ * Since: 2.24
+ */
+
+
+/**
+ * GMenu:
+ *
+ * #GMenu is an opaque structure type.  You must access it using the
+ * functions below.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GMenuAttributeIter:
+ *
+ * #GMenuAttributeIter is an opaque structure type.  You must access it
+ * using the functions below.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GMenuItem:
+ *
+ * #GMenuItem is an opaque structure type.  You must access it using the
+ * functions below.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GMenuLinkIter:
+ *
+ * #GMenuLinkIter is an opaque structure type.  You must access it using
+ * the functions below.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GMenuModel:
+ *
+ * #GMenuModel is an opaque structure type.  You must access it using the
+ * functions below.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GMenuModel::items-changed:
+ * @model: the #GMenuModel that is changing
+ * @position: the position of the change
+ * @removed: the number of items removed
+ * @added: the number of items added
+ *
+ * Emitted when a change has occured to the menu.
+ *
+ * The only changes that can occur to a menu is that items are removed
+ * or added.  Items may not change (except by being removed and added
+ * back in the same location).  This signal is capable of describing
+ * both of those changes (at the same time).
+ *
+ * The signal means that starting at the index @position, @removed
+ * items were removed and @added items were added in their place.  If
+ * @removed is zero then only items were added.  If @added is zero
+ * then only items were removed.
+ *
+ * As an example, if the menu contains items a, b, c, d (in that
+ * order) and the signal (2, 1, 3) occurs then the new composition of
+ * the menu will be a, b, _, _, _, d (with each _ representing some
+ * new item).
+ *
+ * Signal handlers may query the model (particularly the added items)
+ * and expect to see the results of the modification that is being
+ * reported.  The signal is emitted after the modification.
+ */
+
+
+/**
+ * GMount::changed:
+ * @mount: the object on which the signal is emitted
+ *
+ * Emitted when the mount has been changed.
+ */
+
+
+/**
+ * GMount::pre-unmount:
+ * @mount: the object on which the signal is emitted
+ *
+ * This signal is emitted when the #GMount is about to be
+ * unmounted.
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GMount::unmounted:
+ * @mount: the object on which the signal is emitted
+ *
+ * This signal is emitted when the #GMount have been
+ * unmounted. If the recipient is holding references to the
+ * object they should release them so the object can be
+ * finalized.
+ */
+
+
+/**
+ * GMountOperation::aborted:
+ *
+ * Emitted by the backend when e.g. a device becomes unavailable
+ * while a mount operation is in progress.
+ *
+ * Implementations of GMountOperation should handle this signal
+ * by dismissing open password dialogs.
+ *
+ * Since: 2.20
+ */
+
+
+/**
+ * GMountOperation::ask-password:
+ * @op: a #GMountOperation requesting a password.
+ * @message: string containing a message to display to the user.
+ * @default_user: string containing the default user name.
+ * @default_domain: string containing the default domain.
+ * @flags: a set of #GAskPasswordFlags.
+ *
+ * Emitted when a mount operation asks the user for a password.
+ *
+ * If the message contains a line break, the first line should be
+ * presented as a heading. For example, it may be used as the
+ * primary text in a #GtkMessageDialog.
+ */
+
+
+/**
+ * GMountOperation::ask-question:
+ * @op: a #GMountOperation asking a question.
+ * @message: string containing a message to display to the user.
+ * @choices: an array of strings for each possible choice.
+ *
+ * Emitted when asking the user a question and gives a list of
+ * choices for the user to choose from.
+ *
+ * If the message contains a line break, the first line should be
+ * presented as a heading. For example, it may be used as the
+ * primary text in a #GtkMessageDialog.
+ */
+
+
+/**
+ * GMountOperation::reply:
+ * @op: a #GMountOperation.
+ * @result: a #GMountOperationResult indicating how the request was handled
+ *
+ * Emitted when the user has replied to the mount operation.
+ */
+
+
+/**
+ * GMountOperation::show-processes:
+ * @op: a #GMountOperation.
+ * @message: string containing a message to display to the user.
+ * @processes: (element-type GPid): an array of #GPid for processes blocking the operation.
+ * @choices: an array of strings for each possible choice.
+ *
+ * Emitted when one or more processes are blocking an operation
+ * e.g. unmounting/ejecting a #GMount or stopping a #GDrive.
+ *
+ * Note that this signal may be emitted several times to update the
+ * list of blocking processes as processes close files. The
+ * application should only respond with g_mount_operation_reply() to
+ * the latest signal (setting #GMountOperation:choice to the choice
+ * the user made).
+ *
+ * If the message contains a line break, the first line should be
+ * presented as a heading. For example, it may be used as the
+ * primary text in a #GtkMessageDialog.
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GMountOperation::show-unmount-progress:
+ * @op: a #GMountOperation:
+ * @message: string containing a mesage to display to the user
+ * @time_left: the estimated time left before the operation completes, in microseconds, or -1
+ * @bytes_left: the amount of bytes to be written before the operation completes (or -1 if such amount is not known), or zero if the operation is completed
+ *
+ * Emitted when an unmount operation has been busy for more than some time
+ * (typically 1.5 seconds).
+ *
+ * When unmounting or ejecting a volume, the kernel might need to flush
+ * pending data in its buffers to the volume stable storage, and this operation
+ * can take a considerable amount of time. This signal may be emitted several
+ * times as long as the unmount operation is outstanding, and then one
+ * last time when the operation is completed, with @bytes_left set to zero.
+ *
+ * Implementations of GMountOperation should handle this signal by
+ * showing an UI notification, and then dismiss it, or show another notification
+ * of completion, when @bytes_left reaches zero.
+ *
+ * If the message contains a line break, the first line should be
+ * presented as a heading. For example, it may be used as the
+ * primary text in a #GtkMessageDialog.
+ *
+ * Since: 2.34
+ */
+
+
+/**
+ * GMountOperation:anonymous:
+ *
+ * Whether to use an anonymous user when authenticating.
+ */
+
+
+/**
+ * GMountOperation:choice:
+ *
+ * The index of the user's choice when a question is asked during the
+ * mount operation. See the #GMountOperation::ask-question signal.
+ */
+
+
+/**
+ * GMountOperation:domain:
+ *
+ * The domain to use for the mount operation.
+ */
+
+
+/**
+ * GMountOperation:password:
+ *
+ * The password that is used for authentication when carrying out
+ * the mount operation.
+ */
+
+
+/**
+ * GMountOperation:password-save:
+ *
+ * Determines if and how the password information should be saved.
+ */
+
+
+/**
+ * GMountOperation:username:
+ *
+ * The user name that is used for authentication when carrying out
+ * the mount operation.
+ */
+
+
+/**
+ * GNetworkAddress:
+ *
+ * A #GSocketConnectable for resolving a hostname and connecting to
+ * that host.
+ */
+
+
+/**
+ * GNetworkMonitor:
+ *
+ * #GNetworkMonitor monitors the status of network connections and
+ * indicates when a possibly-user-visible change has occurred.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GNetworkMonitor::network-changed:
+ * @monitor: a #GNetworkMonitor
+ * @available: the current value of #GNetworkMonitor:network-available
+ *
+ * Emitted when the network configuration changes. If @available is
+ * %TRUE, then some hosts may be reachable that were not reachable
+ * before, while others that were reachable before may no longer be
+ * reachable. If @available is %FALSE, then no remote hosts are
+ * reachable.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GNetworkMonitor:network-available:
+ *
+ * Whether the network is considered available. That is, whether the
+ * system has a default route for at least one of IPv4 or IPv6.
+ *
+ * Real-world networks are of course much more complicated than
+ * this; the machine may be connected to a wifi hotspot that
+ * requires payment before allowing traffic through, or may be
+ * connected to a functioning router that has lost its own upstream
+ * connectivity. Some hosts might only be accessible when a VPN is
+ * active. Other hosts might only be accessible when the VPN is
+ * <emphasis>not</emphasis> active. Thus, it is best to use
+ * g_network_monitor_can_reach() or
+ * g_network_monitor_can_reach_async() to test for reachability on a
+ * host-by-host basis. (On the other hand, when the property is
+ * %FALSE, the application can reasonably expect that no remote
+ * hosts at all are reachable, and should indicate this to the user
+ * in its UI.)
+ *
+ * See also #GNetworkMonitor::network-changed.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GNetworkService:
+ *
+ * A #GSocketConnectable for resolving a SRV record and connecting to
+ * that service.
+ */
+
+
+/**
+ * GPermission:
+ *
+ * #GPermission is an opaque data structure and can only be accessed
+ * using the following functions.
+ */
+
+
+/**
+ * GPermission:allowed:
+ *
+ * %TRUE if the caller currently has permission to perform the action that
+ * @permission represents the permission to perform.
+ */
+
+
+/**
+ * GPermission:can-acquire:
+ *
+ * %TRUE if it is generally possible to acquire the permission by calling
+ * g_permission_acquire().
+ */
+
+
+/**
+ * GPermission:can-release:
+ *
+ * %TRUE if it is generally possible to release the permission by calling
+ * g_permission_release().
+ */
+
+
+/**
+ * GProxyAddress:
+ *
+ * A #GInetSocketAddress representing a connection via a proxy server
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GProxyAddress:destination-protocol:
+ *
+ * The protocol being spoke to the destination host, or %NULL if
+ * the #GProxyAddress doesn't know.
+ *
+ * Since: 2.34
+ */
+
+
+/**
+ * GProxyAddress:uri:
+ *
+ * The URI string that the proxy was constructed from (or %NULL
+ * if the creator didn't specify this).
+ *
+ * Since: 2.34
+ */
+
+
+/**
+ * GProxyAddressEnumerator:proxy-resolver:
+ *
+ * The proxy resolver to use.
+ *
+ * Since: 2.36
+ */
+
+
+/**
+ * GRemoteActionGroupInterface:
+ * @activate_action_full: the virtual function pointer for g_remote_action_group_activate_action_full()
+ * @change_action_state_full: the virtual function pointer for g_remote_action_group_change_action_state_full()
+ *
+ * The virtual function table for #GRemoteActionGroup.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GResolver:
+ *
+ * The object that handles DNS resolution. Use g_resolver_get_default()
+ * to get the default resolver.
+ */
+
+
+/**
+ * GResolver::reload:
+ * @resolver: a #GResolver
+ *
+ * Emitted when the resolver notices that the system resolver
+ * configuration has changed.
+ */
+
+
+/**
+ * GSettings::change-event:
+ * @settings: the object on which the signal was emitted
+ * @keys: (array length=n_keys) (element-type GQuark) (allow-none): an array of #GQuark<!-- -->s for the changed keys, or %NULL
+ * @n_keys: the length of the @keys array, or 0
+ *
+ * The "change-event" signal is emitted once per change event that
+ * affects this settings object.  You should connect to this signal
+ * only if you are interested in viewing groups of changes before they
+ * are split out into multiple emissions of the "changed" signal.
+ * For most use cases it is more appropriate to use the "changed" signal.
+ *
+ * In the event that the change event applies to one or more specified
+ * keys, @keys will be an array of #GQuark of length @n_keys.  In the
+ * event that the change event applies to the #GSettings object as a
+ * whole (ie: potentially every key has been changed) then @keys will
+ * be %NULL and @n_keys will be 0.
+ *
+ * The default handler for this signal invokes the "changed" signal
+ * for each affected key.  If any other connected handler returns
+ * %TRUE then this default functionality will be suppressed.
+ *
+ * Returns: %TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
+ */
+
+
+/**
+ * GSettings::changed:
+ * @settings: the object on which the signal was emitted
+ * @key: the name of the key that changed
+ *
+ * The "changed" signal is emitted when a key has potentially changed.
+ * You should call one of the g_settings_get() calls to check the new
+ * value.
+ *
+ * This signal supports detailed connections.  You can connect to the
+ * detailed signal "changed::x" in order to only receive callbacks
+ * when key "x" changes.
+ */
+
+
+/**
+ * GSettings::writable-change-event:
+ * @settings: the object on which the signal was emitted
+ * @key: the quark of the key, or 0
+ *
+ * The "writable-change-event" signal is emitted once per writability
+ * change event that affects this settings object.  You should connect
+ * to this signal if you are interested in viewing groups of changes
+ * before they are split out into multiple emissions of the
+ * "writable-changed" signal.  For most use cases it is more
+ * appropriate to use the "writable-changed" signal.
+ *
+ * In the event that the writability change applies only to a single
+ * key, @key will be set to the #GQuark for that key.  In the event
+ * that the writability change affects the entire settings object,
+ * @key will be 0.
+ *
+ * The default handler for this signal invokes the "writable-changed"
+ * and "changed" signals for each affected key.  This is done because
+ * changes in writability might also imply changes in value (if for
+ * example, a new mandatory setting is introduced).  If any other
+ * connected handler returns %TRUE then this default functionality
+ * will be suppressed.
+ *
+ * Returns: %TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further.
+ */
+
+
+/**
+ * GSettings::writable-changed:
+ * @settings: the object on which the signal was emitted
+ * @key: the key
+ *
+ * The "writable-changed" signal is emitted when the writability of a
+ * key has potentially changed.  You should call
+ * g_settings_is_writable() in order to determine the new status.
+ *
+ * This signal supports detailed connections.  You can connect to the
+ * detailed signal "writable-changed::x" in order to only receive
+ * callbacks when the writability of "x" changes.
+ */
+
+
+/**
+ * GSettings:context:
+ *
+ * The name of the context that the settings are stored in.
+ */
+
+
+/**
+ * GSettings:delay-apply:
+ *
+ * Whether the #GSettings object is in 'delay-apply' mode. See
+ * g_settings_delay() for details.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GSettings:has-unapplied:
+ *
+ * If this property is %TRUE, the #GSettings object has outstanding
+ * changes that will be applied when g_settings_apply() is called.
+ */
+
+
+/**
+ * GSettings:path:
+ *
+ * The path within the backend where the settings are stored.
+ */
+
+
+/**
+ * GSettings:schema:
+ *
+ * The name of the schema that describes the types of keys
+ * for this #GSettings object.
+ *
+ * The type of this property is *not* #GSettingsSchema.
+ * #GSettingsSchema has only existed since version 2.32 and
+ * unfortunately this name was used in previous versions to refer to
+ * the schema ID rather than the schema itself.  Take care to use the
+ * 'settings-schema' property if you wish to pass in a
+ * #GSettingsSchema.
+ *
+ * Deprecated: 2.32:Use the 'schema-id' property instead.  In a future version, this property may instead refer to a #GSettingsSchema.
+ */
+
+
+/**
+ * GSettings:schema-id:
+ *
+ * The name of the schema that describes the types of keys
+ * for this #GSettings object.
+ */
+
+
+/**
+ * GSettings:settings-schema:
+ *
+ * The #GSettingsSchema describing the types of keys for this
+ * #GSettings object.
+ *
+ * Ideally, this property would be called 'schema'.  #GSettingsSchema
+ * has only existed since version 2.32, however, and before then the
+ * 'schema' property was used to refer to the ID of the schema rather
+ * than the schema itself.  Take care.
+ */
+
+
+/**
+ * GSettingsSchema:
+ *
+ * This is an opaque structure type.  You may not access it directly.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GSettingsSchemaSource:
+ *
+ * This is an opaque structure type.  You may not access it directly.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GSimpleAction::activate:
+ * @simple: the #GSimpleAction
+ * @parameter: (allow-none): the parameter to the activation
+ *
+ * Indicates that the action was just activated.
+ *
+ * @parameter will always be of the expected type.  In the event that
+ * an incorrect type was given, no signal will be emitted.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GSimpleAction::change-state:
+ * @simple: the #GSimpleAction
+ * @value: (allow-none): the requested value for the state
+ *
+ * Indicates that the action just received a request to change its
+ * state.
+ *
+ * @value will always be of the correct state type.  In the event that
+ * an incorrect type was given, no signal will be emitted.
+ *
+ * If no handler is connected to this signal then the default
+ * behaviour is to call g_simple_action_set_state() to set the state
+ * to the requested value.  If you connect a signal handler then no
+ * default action is taken.  If the state should change then you must
+ * call g_simple_action_set_state() from the handler.
+ *
+ * <example>
+ * <title>Example 'change-state' handler</title>
+ * <programlisting>
+ * static void
+ * change_volume_state (GSimpleAction *action,
+ *                      GVariant      *value,
+ *                      gpointer       user_data)
+ * {
+ *   gint requested;
+ *
+ *   requested = g_variant_get_int32 (value);
+ *
+ *   // Volume only goes from 0 to 10
+ *   if (0 <= requested && requested <= 10)
+ *     g_simple_action_set_state (action, value);
+ * }
+ * </programlisting>
+ * </example>
+ *
+ * The handler need not set the state to the requested value.  It
+ * could set it to any value at all, or take some other action.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GSimpleAction:enabled:
+ *
+ * If @action is currently enabled.
+ *
+ * If the action is disabled then calls to g_action_activate() and
+ * g_action_change_state() have no effect.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GSimpleAction:name:
+ *
+ * The name of the action.  This is mostly meaningful for identifying
+ * the action once it has been added to a #GSimpleActionGroup.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GSimpleAction:parameter-type:
+ *
+ * The type of the parameter that must be given when activating the
+ * action.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GSimpleAction:state:
+ *
+ * The state of the action, or %NULL if the action is stateless.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GSimpleAction:state-type:
+ *
+ * The #GVariantType of the state that the action has, or %NULL if the
+ * action is stateless.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GSimplePermission:
+ *
+ * #GSimplePermission is an opaque data structure.  There are no methods
+ * except for those defined by #GPermission.
+ */
+
+
+/**
+ * GSimpleProxyResolver:default-proxy:
+ *
+ * The default proxy URI that will be used for any URI that doesn't
+ * match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
+ * of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
+ *
+ * Note that as a special case, if this URI starts with
+ * "<literal>socks://</literal>", #GSimpleProxyResolver will treat
+ * it as referring to all three of the <literal>socks5</literal>,
+ * <literal>socks4a</literal>, and <literal>socks4</literal> proxy
+ * types.
+ */
+
+
+/**
+ * GSimpleProxyResolver:ignore-hosts:
+ *
+ * A list of hostnames and IP addresses that the resolver should
+ * allow direct connections to.
+ *
+ * Entries can be in one of 4 formats:
+ *
+ * <itemizedlist>
+ *   <listitem>
+ *     A hostname, such as "<literal>example.com</literal>",
+ *     "<literal>.example.com</literal>", or
+ *     "<literal>*.example.com</literal>", any of which match
+ *     "<literal>example.com</literal>" or any subdomain of it.
+ *   </listitem>
+ *   <listitem>
+ *     An IPv4 or IPv6 address, such as
+ *     "<literal>192.168.1.1</literal>", which matches only
+ *     that address.
+ *   </listitem>
+ *   <listitem>
+ *     A hostname or IP address followed by a port, such as
+ *     "<literal>example.com:80</literal>", which matches whatever
+ *     the hostname or IP address would match, but only for URLs
+ *     with the (explicitly) indicated port. In the case of an IPv6
+ *     address, the address part must appear in brackets:
+ *     "<literal>[::1]:443</literal>"
+ *   </listitem>
+ *   <listitem>
+ *     An IP address range, given by a base address and prefix length,
+ *     such as "<literal>fe80::/10</literal>", which matches any
+ *     address in that range.
+ *   </listitem>
+ * </itemizedlist>
+ *
+ * Note that when dealing with Unicode hostnames, the matching is
+ * done against the ASCII form of the name.
+ *
+ * Also note that hostname exclusions apply only to connections made
+ * to hosts identified by name, and IP address exclusions apply only
+ * to connections made to hosts identified by address. That is, if
+ * <literal>example.com</literal> has an address of
+ * <literal>192.168.1.1</literal>, and the :ignore-hosts list
+ * contains only "<literal>192.168.1.1</literal>", then a connection
+ * to "<literal>example.com</literal>" (eg, via a #GNetworkAddress)
+ * will use the proxy, and a connection to
+ * "<literal>192.168.1.1</literal>" (eg, via a #GInetSocketAddress)
+ * will not.
+ *
+ * These rules match the "ignore-hosts"/"noproxy" rules most
+ * commonly used by other applications.
+ */
+
+
+/**
+ * GSocket:broadcast:
+ *
+ * Whether the socket should allow sending to and receiving from broadcast addresses.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GSocket:multicast-loopback:
+ *
+ * Whether outgoing multicast packets loop back to the local host.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GSocket:multicast-ttl:
+ *
+ * Time-to-live out outgoing multicast packets
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GSocket:timeout:
+ *
+ * The timeout in seconds on socket I/O
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GSocket:ttl:
+ *
+ * Time-to-live for outgoing unicast packets
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GSocketAddress:
+ *
+ * A socket endpoint address, corresponding to <type>struct sockaddr</type>
+ * or one of its subtypes.
+ */
+
+
+/**
+ * GSocketClient::event:
+ * @client: the #GSocketClient
+ * @event: the event that is occurring
+ * @connectable: the #GSocketConnectable that @event is occurring on
+ * @connection: the current representation of the connection
+ *
+ * Emitted when @client's activity on @connectable changes state.
+ * Among other things, this can be used to provide progress
+ * information about a network connection in the UI. The meanings of
+ * the different @event values are as follows:
+ *
+ * <variablelist>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_RESOLVING:</term>
+ *     <listitem><para>
+ *       @client is about to look up @connectable in DNS.
+ *       @connection will be %NULL.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_RESOLVED:</term>
+ *     <listitem><para>
+ *       @client has successfully resolved @connectable in DNS.
+ *       @connection will be %NULL.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_CONNECTING:</term>
+ *     <listitem><para>
+ *       @client is about to make a connection to a remote host;
+ *       either a proxy server or the destination server itself.
+ *       @connection is the #GSocketConnection, which is not yet
+ *       connected.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_CONNECTED:</term>
+ *     <listitem><para>
+ *       @client has successfully connected to a remote host.
+ *       @connection is the connected #GSocketConnection.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_PROXY_NEGOTIATING:</term>
+ *     <listitem><para>
+ *       @client is about to negotiate with a proxy to get it to
+ *       connect to @connectable. @connection is the
+ *       #GSocketConnection to the proxy server.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_PROXY_NEGOTIATED:</term>
+ *     <listitem><para>
+ *       @client has negotiated a connection to @connectable through
+ *       a proxy server. @connection is the stream returned from
+ *       g_proxy_connect(), which may or may not be a
+ *       #GSocketConnection.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_TLS_HANDSHAKING:</term>
+ *     <listitem><para>
+ *       @client is about to begin a TLS handshake. @connection is a
+ *       #GTlsClientConnection.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_TLS_HANDSHAKED:</term>
+ *     <listitem><para>
+ *       @client has successfully completed the TLS handshake.
+ *       @connection is a #GTlsClientConnection.
+ *     </para></listitem>
+ *   </varlistentry>
+ *   <varlistentry>
+ *     <term>%G_SOCKET_CLIENT_COMPLETE:</term>
+ *     <listitem><para>
+ *       @client has either successfully connected to @connectable
+ *       (in which case @connection is the #GSocketConnection that
+ *       it will be returning to the caller) or has failed (in which
+ *       case @connection is %NULL and the client is about to return
+ *       an error).
+ *     </para></listitem>
+ *   </varlistentry>
+ * </variablelist>
+ *
+ * Each event except %G_SOCKET_CLIENT_COMPLETE may be emitted
+ * multiple times (or not at all) for a given connectable (in
+ * particular, if @client ends up attempting to connect to more than
+ * one address). However, if @client emits the #GSocketClient::event
+ * signal at all for a given connectable, that it will always emit
+ * it with %G_SOCKET_CLIENT_COMPLETE when it is done.
+ *
+ * Note that there may be additional #GSocketClientEvent values in
+ * the future; unrecognized @event values should be ignored.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * GSocketClient:proxy-resolver:
+ *
+ * The proxy resolver to use
+ *
+ * Since: 2.36
+ */
+
+
+/**
+ * GSocketService::incoming:
+ * @service: the #GSocketService
+ * @connection: a new #GSocketConnection object
+ * @source_object: (allow-none): the source_object passed to g_socket_listener_add_address()
+ *
+ * The ::incoming signal is emitted when a new incoming connection
+ * to @service needs to be handled. The handler must initiate the
+ * handling of @connection, but may not block; in essence,
+ * asynchronous operations must be used.
+ *
+ * @connection will be unreffed once the signal handler returns,
+ * so you need to ref it yourself if you are planning to use it.
+ *
+ * Returns: %TRUE to stop other handlers from being called
+ * Since: 2.22
+ */
+
+
+/**
+ * GSrvTarget:
+ *
+ * A single target host/port that a network service is running on.
+ */
+
+
+/**
+ * GTask:
+ *
+ * The opaque object representing a synchronous or asynchronous task
+ * and its result.
+ */
+
+
+/**
+ * GTaskThreadFunc:
+ * @task: the #GTask
+ * @source_object: (type GObject): @task's source object
+ * @task_data: @task's task data
+ * @cancellable: @task's #GCancellable, or %NULL
+ *
+ * The prototype for a task function to be run in a thread via
+ * g_task_run_in_thread() or g_task_run_in_thread_sync().
+ *
+ * If the return-on-cancel flag is set on @task, and @cancellable gets
+ * cancelled, then the #GTask will be completed immediately (as though
+ * g_task_return_error_if_cancelled() had been called), without
+ * waiting for the task function to complete. However, the task
+ * function will continue running in its thread in the background. The
+ * function therefore needs to be careful about how it uses
+ * externally-visible state in this case. See
+ * g_task_set_return_on_cancel() for more details.
+ *
+ * Other than in that case, @task will be completed when the
+ * #GTaskThreadFunc returns, <emphasis>not</emphasis> when it calls
+ * a <literal>g_task_return_</literal> function.
+ *
+ * Since: 2.36
+ */
+
+
+/**
+ * GTestDBus:
+ *
+ * The #GTestDBus structure contains only private data and
+ * should only be accessed using the provided API.
+ *
+ * Since: 2.34
+ */
+
+
+/**
+ * GTestDBus:flags:
+ *
+ * #GTestDBusFlags specifying the behaviour of the dbus session
+ *
+ * Since: 2.34
+ */
+
+
+/**
+ * GThemedIcon:name:
+ *
+ * The icon name.
+ */
+
+
+/**
+ * GThemedIcon:names:
+ *
+ * A %NULL-terminated array of icon names.
+ */
+
+
+/**
+ * GThemedIcon:use-default-fallbacks:
+ *
+ * Whether to use the default fallbacks found by shortening the icon name
+ * at '-' characters. If the "names" array has more than one element,
+ * ignores any past the first.
+ *
+ * For example, if the icon name was "gnome-dev-cdrom-audio", the array
+ * would become
+ * |[
+ * {
+ *   "gnome-dev-cdrom-audio",
+ *   "gnome-dev-cdrom",
+ *   "gnome-dev",
+ *   "gnome",
+ *   NULL
+ * };
+ * ]|
+ */
+
+
+/**
+ * GThreadedSocketService::run:
+ * @service: the #GThreadedSocketService.
+ * @connection: a new #GSocketConnection object.
+ * @source_object: the source_object passed to g_socket_listener_add_address().
+ *
+ * The ::run signal is emitted in a worker thread in response to an
+ * incoming connection. This thread is dedicated to handling
+ * @connection and may perform blocking IO. The signal handler need
+ * not return until the connection is closed.
+ *
+ * Returns: %TRUE to stop further signal handlers from being called
+ */
+
+
+/**
+ * GTlsBackend:
+ *
+ * TLS (Transport Layer Security, aka SSL) backend. This is an
+ * internal type used to coordinate the different classes implemented
+ * by a TLS backend.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsCertificate:
+ *
+ * Abstract base class for TLS certificate types.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsCertificate:certificate:
+ *
+ * The DER (binary) encoded representation of the certificate.
+ * This property and the #GTlsCertificate:certificate-pem property
+ * represent the same data, just in different forms.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsCertificate:certificate-pem:
+ *
+ * The PEM (ASCII) encoded representation of the certificate.
+ * This property and the #GTlsCertificate:certificate
+ * property represent the same data, just in different forms.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsCertificate:issuer:
+ *
+ * A #GTlsCertificate representing the entity that issued this
+ * certificate. If %NULL, this means that the certificate is either
+ * self-signed, or else the certificate of the issuer is not
+ * available.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsCertificate:private-key:
+ *
+ * The DER (binary) encoded representation of the certificate's
+ * private key, in either PKCS#1 format or unencrypted PKCS#8
+ * format. This property (or the #GTlsCertificate:private-key-pem
+ * property) can be set when constructing a key (eg, from a file),
+ * but cannot be read.
+ *
+ * PKCS#8 format is supported since 2.32; earlier releases only
+ * support PKCS#1. You can use the <literal>openssl rsa</literal>
+ * tool to convert PKCS#8 keys to PKCS#1.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsCertificate:private-key-pem:
+ *
+ * The PEM (ASCII) encoded representation of the certificate's
+ * private key in either PKCS#1 format ("<literal>BEGIN RSA PRIVATE
+ * KEY</literal>") or unencrypted PKCS#8 format ("<literal>BEGIN
+ * PRIVATE KEY</literal>"). This property (or the
+ * #GTlsCertificate:private-key property) can be set when
+ * constructing a key (eg, from a file), but cannot be read.
+ *
+ * PKCS#8 format is supported since 2.32; earlier releases only
+ * support PKCS#1. You can use the <literal>openssl rsa</literal>
+ * tool to convert PKCS#8 keys to PKCS#1.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsClientConnection:
+ *
+ * Abstract base class for the backend-specific client connection
+ * type.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsClientConnection:accepted-cas:
+ *
+ * A list of the distinguished names of the Certificate Authorities
+ * that the server will accept client certificates signed by. If the
+ * server requests a client certificate during the handshake, then
+ * this property will be set after the handshake completes.
+ *
+ * Each item in the list is a #GByteArray which contains the complete
+ * subject DN of the certificate authority.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsClientConnection:server-identity:
+ *
+ * A #GSocketConnectable describing the identity of the server that
+ * is expected on the other end of the connection.
+ *
+ * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
+ * #GTlsClientConnection:validation-flags, this object will be used
+ * to determine the expected identify of the remote end of the
+ * connection; if #GTlsClientConnection:server-identity is not set,
+ * or does not match the identity presented by the server, then the
+ * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
+ *
+ * In addition to its use in verifying the server certificate,
+ * this is also used to give a hint to the server about what
+ * certificate we expect, which is useful for servers that serve
+ * virtual hosts.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsClientConnection:use-ssl3:
+ *
+ * If %TRUE, tells the connection to use SSL 3.0 rather than trying
+ * to negotiate the best version of TLS or SSL to use. This can be
+ * used when talking to servers that don't implement version
+ * negotiation correctly and therefore refuse to handshake at all with
+ * a "modern" TLS handshake.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsClientConnection:validation-flags:
+ *
+ * What steps to perform when validating a certificate received from
+ * a server. Server certificates that fail to validate in all of the
+ * ways indicated here will be rejected unless the application
+ * overrides the default via #GTlsConnection::accept-certificate.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:
+ *
+ * Abstract base class for the backend-specific #GTlsClientConnection
+ * and #GTlsServerConnection types.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection::accept-certificate:
+ * @conn: a #GTlsConnection
+ * @peer_cert: the peer's #GTlsCertificate
+ * @errors: the problems with @peer_cert.
+ *
+ * Emitted during the TLS handshake after the peer certificate has
+ * been received. You can examine @peer_cert's certification path by
+ * calling g_tls_certificate_get_issuer() on it.
+ *
+ * For a client-side connection, @peer_cert is the server's
+ * certificate, and the signal will only be emitted if the
+ * certificate was not acceptable according to @conn's
+ * #GTlsClientConnection:validation_flags. If you would like the
+ * certificate to be accepted despite @errors, return %TRUE from the
+ * signal handler. Otherwise, if no handler accepts the certificate,
+ * the handshake will fail with %G_TLS_ERROR_BAD_CERTIFICATE.
+ *
+ * For a server-side connection, @peer_cert is the certificate
+ * presented by the client, if this was requested via the server's
+ * #GTlsServerConnection:authentication_mode. On the server side,
+ * the signal is always emitted when the client presents a
+ * certificate, and the certificate will only be accepted if a
+ * handler returns %TRUE.
+ *
+ * Note that if this signal is emitted as part of asynchronous I/O
+ * in the main thread, then you should not attempt to interact with
+ * the user before returning from the signal handler. If you want to
+ * let the user decide whether or not to accept the certificate, you
+ * would have to return %FALSE from the signal handler on the first
+ * attempt, and then after the connection attempt returns a
+ * %G_TLS_ERROR_HANDSHAKE, you can interact with the user, and if
+ * the user decides to accept the certificate, remember that fact,
+ * create a new connection, and return %TRUE from the signal handler
+ * the next time.
+ *
+ * If you are doing I/O in another thread, you do not
+ * need to worry about this, and can simply block in the signal
+ * handler until the UI thread returns an answer.
+ *
+ * Returns: %TRUE to accept @peer_cert (which will also immediately end the signal emission). %FALSE to allow the signal emission to continue, which will cause the handshake to fail if no one else overrides it.
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:base-io-stream:
+ *
+ * The #GIOStream that the connection wraps
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:certificate:
+ *
+ * The connection's certificate; see
+ * g_tls_connection_set_certificate().
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:database:
+ *
+ * The certificate database to use when verifying this TLS connection.
+ * If no cerificate database is set, then the default database will be
+ * used. See g_tls_backend_get_default_database().
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsConnection:interaction:
+ *
+ * A #GTlsInteraction object to be used when the connection or certificate
+ * database need to interact with the user. This will be used to prompt the
+ * user for passwords where necessary.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsConnection:peer-certificate:
+ *
+ * The connection's peer's certificate, after the TLS handshake has
+ * completed and the certificate has been accepted. Note in
+ * particular that this is not yet set during the emission of
+ * #GTlsConnection::accept-certificate.
+ *
+ * (You can watch for a #GObject::notify signal on this property to
+ * detect when a handshake has occurred.)
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:peer-certificate-errors:
+ *
+ * The errors noticed-and-ignored while verifying
+ * #GTlsConnection:peer-certificate. Normally this should be 0, but
+ * it may not be if #GTlsClientConnection:validation-flags is not
+ * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if
+ * #GTlsConnection::accept-certificate overrode the default
+ * behavior.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:rehandshake-mode:
+ *
+ * The rehandshaking mode. See
+ * g_tls_connection_set_rehandshake_mode().
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:require-close-notify:
+ *
+ * Whether or not proper TLS close notification is required.
+ * See g_tls_connection_set_require_close_notify().
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GTlsConnection:use-system-certdb:
+ *
+ * Whether or not the system certificate database will be used to
+ * verify peer certificates. See
+ * g_tls_connection_set_use_system_certdb().
+ *
+ * Deprecated: 2.30: Use GTlsConnection:database instead
+ */
+
+
+/**
+ * GTlsDatabase:
+ *
+ * Abstract base class for the backend-specific database types.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsFileDatabase:
+ *
+ * Implemented by a #GTlsDatabase which allows you to load certificates
+ * from a file.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsFileDatabase:anchors:
+ *
+ * The path to a file containing PEM encoded certificate authority
+ * root anchors. The certificates in this file will be treated as
+ * root authorities for the purpose of verifying other certificates
+ * via the g_tls_database_verify_chain() operation.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsInteraction:
+ *
+ * An object representing interaction that the TLS connection and database
+ * might have with the user.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsInteractionClass:
+ * @ask_password: ask for a password synchronously. If the implementation returns %G_TLS_INTERACTION_HANDLED, then the password argument should have been filled in by using g_tls_password_set_value() or a similar function.
+ * @ask_password_async: ask for a password asynchronously.
+ * @ask_password_finish: complete operation to ask for a password asynchronously. If the implementation returns %G_TLS_INTERACTION_HANDLED, then the password argument of the async method should have been filled in by using g_tls_password_set_value() or a similar function.
+ *
+ * The class for #GTlsInteraction. Derived classes implement the various
+ * virtual interaction methods to handle TLS interactions.
+ *
+ * Derived classes can choose to implement whichever interactions methods they'd
+ * like to support by overriding those virtual methods in their class
+ * initialization function. If a derived class implements an async method,
+ * it must also implement the corresponding finish method.
+ *
+ * The synchronous interaction methods should implement to display modal dialogs,
+ * and the asynchronous methods to display modeless dialogs.
+ *
+ * If the user cancels an interaction, then the result should be
+ * %G_TLS_INTERACTION_FAILED and the error should be set with a domain of
+ * %G_IO_ERROR and code of %G_IO_ERROR_CANCELLED.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsPassword:
+ *
+ * An abstract interface representing a password used in TLS. Often used in
+ * user interaction such as unlocking a key storage token.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * GTlsServerConnection:authentication-mode:
+ *
+ * The #GTlsAuthenticationMode for the server. This can be changed
+ * before calling g_tls_connection_handshake() if you want to
+ * rehandshake with a different mode from the initial handshake.
+ *
+ * Since: 2.28
+ */
+
+
+/**
+ * GUnixCredentialsMessage:credentials:
+ *
+ * The credentials stored in the message.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GUnixInputStream:close-fd:
+ *
+ * Whether to close the file descriptor when the stream is closed.
+ *
+ * Since: 2.20
+ */
+
+
+/**
+ * GUnixInputStream:fd:
+ *
+ * The file descriptor that the stream reads from.
+ *
+ * Since: 2.20
+ */
+
+
+/**
+ * GUnixMountMonitor::mountpoints-changed:
+ * @monitor: the object on which the signal is emitted
+ *
+ * Emitted when the unix mount points have changed.
+ */
+
+
+/**
+ * GUnixMountMonitor::mounts-changed:
+ * @monitor: the object on which the signal is emitted
+ *
+ * Emitted when the unix mounts have changed.
+ */
+
+
+/**
+ * GUnixOutputStream:close-fd:
+ *
+ * Whether to close the file descriptor when the stream is closed.
+ *
+ * Since: 2.20
+ */
+
+
+/**
+ * GUnixOutputStream:fd:
+ *
+ * The file descriptor that the stream writes to.
+ *
+ * Since: 2.20
+ */
+
+
+/**
+ * GUnixSocketAddress:
+ *
+ * A UNIX-domain (local) socket address, corresponding to a
+ * <type>struct sockaddr_un</type>.
+ */
+
+
+/**
+ * GUnixSocketAddress:abstract:
+ *
+ * Whether or not this is an abstract address
+ *
+ * Deprecated: Use #GUnixSocketAddress:address-type, which distinguishes between zero-padded and non-zero-padded abstract addresses.
+ */
+
+
+/**
+ * GVolume::changed:
+ *
+ * Emitted when the volume has been changed.
+ */
+
+
+/**
+ * GVolume::removed:
+ *
+ * This signal is emitted when the #GVolume have been removed. If
+ * the recipient is holding references to the object they should
+ * release them so the object can be finalized.
+ */
+
+
+/**
+ * GVolumeMonitor::drive-changed:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @drive: the drive that changed
+ *
+ * Emitted when a drive changes.
+ */
+
+
+/**
+ * GVolumeMonitor::drive-connected:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @drive: a #GDrive that was connected.
+ *
+ * Emitted when a drive is connected to the system.
+ */
+
+
+/**
+ * GVolumeMonitor::drive-disconnected:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @drive: a #GDrive that was disconnected.
+ *
+ * Emitted when a drive is disconnected from the system.
+ */
+
+
+/**
+ * GVolumeMonitor::drive-eject-button:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @drive: the drive where the eject button was pressed
+ *
+ * Emitted when the eject button is pressed on @drive.
+ *
+ * Since: 2.18
+ */
+
+
+/**
+ * GVolumeMonitor::drive-stop-button:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @drive: the drive where the stop button was pressed
+ *
+ * Emitted when the stop button is pressed on @drive.
+ *
+ * Since: 2.22
+ */
+
+
+/**
+ * GVolumeMonitor::mount-added:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @mount: a #GMount that was added.
+ *
+ * Emitted when a mount is added.
+ */
+
+
+/**
+ * GVolumeMonitor::mount-changed:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @mount: a #GMount that changed.
+ *
+ * Emitted when a mount changes.
+ */
+
+
+/**
+ * GVolumeMonitor::mount-pre-unmount:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @mount: a #GMount that is being unmounted.
+ *
+ * Emitted when a mount is about to be removed.
+ */
+
+
+/**
+ * GVolumeMonitor::mount-removed:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @mount: a #GMount that was removed.
+ *
+ * Emitted when a mount is removed.
+ */
+
+
+/**
+ * GVolumeMonitor::volume-added:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @volume: a #GVolume that was added.
+ *
+ * Emitted when a mountable volume is added to the system.
+ */
+
+
+/**
+ * GVolumeMonitor::volume-changed:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @volume: a #GVolume that changed.
+ *
+ * Emitted when mountable volume is changed.
+ */
+
+
+/**
+ * GVolumeMonitor::volume-removed:
+ * @volume_monitor: The volume monitor emitting the signal.
+ * @volume: a #GVolume that was removed.
+ *
+ * Emitted when a mountable volume is removed from the system.
+ */
+
+
+/**
+ * GWin32InputStream:close-handle:
+ *
+ * Whether to close the file handle when the stream is closed.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GWin32InputStream:handle:
+ *
+ * The handle that the stream reads from.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GWin32OutputStream:close-handle:
+ *
+ * Whether to close the file handle when the stream is closed.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GWin32OutputStream:handle:
+ *
+ * The file handle that the stream writes to.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GZlibCompressor:
+ *
+ * Zlib decompression
+ */
+
+
+/**
+ * GZlibCompressor:file-info:
+ *
+ * If set to a non-%NULL #GFileInfo object, and #GZlibCompressor:format is
+ * %G_ZLIB_COMPRESSOR_FORMAT_GZIP, the compressor will write the file name
+ * and modification time from the file info to the GZIP header.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * GZlibDecompressor:
+ *
+ * Zlib decompression
+ */
+
+
+/**
+ * GZlibDecompressor:file-info:
+ *
+ * A #GFileInfo containing the information found in the GZIP header
+ * of the data stream processed, or %NULL if the header was not yet
+ * fully processed, is not present at all, or the compressor's
+ * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP.
+ *
+ * Since: 2.26
+ */
+
+
+/**
+ * G_TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT:
+ *
+ * The purpose used to verify the client certificate in a TLS connection.
+ * Used by TLS servers.
+ */
+
+
+/**
+ * G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER:
+ *
+ * The purpose used to verify the server certificate in a TLS connection. This
+ * is the most common purpose in use. Used by TLS clients.
+ */
+
+
+/**
+ * G_TYPE_SETTINGS_SCHEMA:
+ *
+ * A boxed #GType corresponding to #GSettingsSchema.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * G_TYPE_SETTINGS_SCHEMA_SOURCE:
+ *
+ * A boxed #GType corresponding to #GSettingsSchemaSource.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * SECTION:extensionpoints
+ * @short_description: Extension Points
+ * @include: gio.h
+ * @see_also: <link linkend="extending-gio">Extending GIO</link>
+ *
+ * #GIOExtensionPoint provides a mechanism for modules to extend the
+ * functionality of the library or application that loaded it in an
+ * organized fashion.
+ *
+ * An extension point is identified by a name, and it may optionally
+ * require that any implementation must by of a certain type (or derived
+ * thereof). Use g_io_extension_point_register() to register an
+ * extension point, and g_io_extension_point_set_required_type() to
+ * set a required type.
+ *
+ * A module can implement an extension point by specifying the #GType
+ * that implements the functionality. Additionally, each implementation
+ * of an extension point has a name, and a priority. Use
+ * g_io_extension_point_implement() to implement an extension point.
+ *
+ *  |[
+ *  GIOExtensionPoint *ep;
+ *
+ *  /&ast; Register an extension point &ast;/
+ *  ep = g_io_extension_point_register ("my-extension-point");
+ *  g_io_extension_point_set_required_type (ep, MY_TYPE_EXAMPLE);
+ *  ]|
+ *
+ *  |[
+ *  /&ast; Implement an extension point &ast;/
+ *  G_DEFINE_TYPE (MyExampleImpl, my_example_impl, MY_TYPE_EXAMPLE);
+ *  g_io_extension_point_implement ("my-extension-point",
+ *                                  my_example_impl_get_type (),
+ *                                  "my-example",
+ *                                  10);
+ *  ]|
+ *
+ *  It is up to the code that registered the extension point how
+ *  it uses the implementations that have been associated with it.
+ *  Depending on the use case, it may use all implementations, or
+ *  only the one with the highest priority, or pick a specific
+ *  one by name.
+ *
+ *  To avoid opening all modules just to find out what extension
+ *  points they implement, GIO makes use of a caching mechanism,
+ *  see <link linkend="gio-querymodules">gio-querymodules</link>.
+ *  You are expected to run this command after installing a
+ *  GIO module.
+ *
+ *  The <envar>GIO_EXTRA_MODULES</envar> environment variable can be
+ *  used to specify additional directories to automatically load modules
+ *  from. This environment variable has the same syntax as the
+ *  <envar>PATH</envar>. If two modules have the same base name in different
+ *  directories, then the latter one will be ignored. If additional
+ *  directories are specified GIO will load modules from the built-in
+ *  directory last.
+ */
+
+
+/**
+ * SECTION:gaction
+ * @title: GAction
+ * @short_description: An action interface
+ *
+ * #GAction represents a single named action.
+ *
+ * The main interface to an action is that it can be activated with
+ * g_action_activate().  This results in the 'activate' signal being
+ * emitted.  An activation has a #GVariant parameter (which may be
+ * %NULL).  The correct type for the parameter is determined by a static
+ * parameter type (which is given at construction time).
+ *
+ * An action may optionally have a state, in which case the state may be
+ * set with g_action_change_state().  This call takes a #GVariant.  The
+ * correct type for the state is determined by a static state type
+ * (which is given at construction time).
+ *
+ * The state may have a hint associated with it, specifying its valid
+ * range.
+ *
+ * #GAction is merely the interface to the concept of an action, as
+ * described above.  Various implementations of actions exist, including
+ * #GSimpleAction and #GtkAction.
+ *
+ * In all cases, the implementing class is responsible for storing the
+ * name of the action, the parameter type, the enabled state, the
+ * optional state type and the state and emitting the appropriate
+ * signals when these change.  The implementor responsible for filtering
+ * calls to g_action_activate() and g_action_change_state() for type
+ * safety and for the state being enabled.
+ *
+ * Probably the only useful thing to do with a #GAction is to put it
+ * inside of a #GSimpleActionGroup.
+ */
+
+
+/**
+ * SECTION:gactiongroup
+ * @title: GActionGroup
+ * @short_description: A group of actions
+ * @see_also: #GAction
+ *
+ * #GActionGroup represents a group of actions. Actions can be used to
+ * expose functionality in a structured way, either from one part of a
+ * program to another, or to the outside world. Action groups are often
+ * used together with a #GMenuModel that provides additional
+ * representation data for displaying the actions to the user, e.g. in
+ * a menu.
+ *
+ * The main way to interact with the actions in a GActionGroup is to
+ * activate them with g_action_group_activate_action(). Activating an
+ * action may require a #GVariant parameter. The required type of the
+ * parameter can be inquired with g_action_group_get_action_parameter_type().
+ * Actions may be disabled, see g_action_group_get_action_enabled().
+ * Activating a disabled action has no effect.
+ *
+ * Actions may optionally have a state in the form of a #GVariant. The
+ * current state of an action can be inquired with
+ * g_action_group_get_action_state(). Activating a stateful action may
+ * change its state, but it is also possible to set the state by calling
+ * g_action_group_change_action_state().
+ *
+ * As typical example, consider a text editing application which has an
+ * option to change the current font to 'bold'. A good way to represent
+ * this would be a stateful action, with a boolean state. Activating the
+ * action would toggle the state.
+ *
+ * Each action in the group has a unique name (which is a string).  All
+ * method calls, except g_action_group_list_actions() take the name of
+ * an action as an argument.
+ *
+ * The #GActionGroup API is meant to be the 'public' API to the action
+ * group.  The calls here are exactly the interaction that 'external
+ * forces' (eg: UI, incoming D-Bus messages, etc.) are supposed to have
+ * with actions.  'Internal' APIs (ie: ones meant only to be accessed by
+ * the action group implementation) are found on subclasses.  This is
+ * why you will find - for example - g_action_group_get_action_enabled()
+ * but not an equivalent <function>set()</function> call.
+ *
+ * Signals are emitted on the action group in response to state changes
+ * on individual actions.
+ *
+ * Implementations of #GActionGroup should provide implementations for
+ * the virtual functions g_action_group_list_actions() and
+ * g_action_group_query_action().  The other virtual functions should
+ * not be implemented - their "wrappers" are actually implemented with
+ * calls to g_action_group_query_action().
+ */
+
+
+/**
+ * SECTION:gactiongroupexporter
+ * @title: GActionGroup exporter
+ * @short_description: Export GActionGroups on D-Bus
+ * @see_also: #GActionGroup, #GDBusActionGroup
+ *
+ * These functions support exporting a #GActionGroup on D-Bus.
+ * The D-Bus interface that is used is a private implementation
+ * detail.
+ *
+ * To access an exported #GActionGroup remotely, use
+ * g_dbus_action_group_get() to obtain a #GDBusActionGroup.
+ */
+
+
+/**
+ * SECTION:gactionmap
+ * @title: GActionMap
+ * @short_description: Interface for action containers
+ *
+ * The GActionMap interface is implemented by #GActionGroup
+ * implementations that operate by containing a number of
+ * named #GAction instances, such as #GSimpleActionGroup.
+ *
+ * One useful application of this interface is to map the
+ * names of actions from various action groups to unique,
+ * prefixed names (e.g. by prepending "app." or "win.").
+ * This is the motivation for the 'Map' part of the interface
+ * name.
+ *
+ * Since: 2.32
+ */
+
+
+/**
+ * SECTION:gappinfo
+ * @short_description: Application information and launch contexts
+ * @include: gio/gio.h
+ *
+ * #GAppInfo and #GAppLaunchContext are used for describing and launching
+ * applications installed on the system.
+ *
+ * As of GLib 2.20, URIs will always be converted to POSIX paths
+ * (using g_file_get_path()) when using g_app_info_launch() even if
+ * the application requested an URI and not a POSIX path. For example
+ * for an desktop-file based application with Exec key <literal>totem
+ * &percnt;U</literal> and a single URI,
+ * <literal>sftp://foo/file.avi</literal>, then
+ * <literal>/home/user/.gvfs/sftp on foo/file.avi</literal> will be
+ * passed. This will only work if a set of suitable GIO extensions
+ * (such as gvfs 2.26 compiled with FUSE support), is available and
+ * operational; if this is not the case, the URI will be passed
+ * unmodified to the application. Some URIs, such as
+ * <literal>mailto:</literal>, of course cannot be mapped to a POSIX
+ * path (in gvfs there's no FUSE mount for it); such URIs will be
+ * passed unmodified to the application.
+ *
+ * Specifically for gvfs 2.26 and later, the POSIX URI will be mapped
+ * back to the GIO URI in the #GFile constructors (since gvfs
+ * implements the #GVfs extension point). As such, if the application
+ * needs to examine the URI, it needs to use g_file_get_uri() or
+ * similar on #GFile. In other words, an application cannot assume
+ * that the URI passed to e.g. g_file_new_for_commandline_arg() is
+ * equal to the result of g_file_get_uri(). The following snippet
+ * illustrates this:
+ *
+ * <programlisting>
+ * GFile *f;
+ * char *uri;
+ *
+ * file = g_file_new_for_commandline_arg (uri_from_commandline);
+ *
+ * uri = g_file_get_uri (file);
+ * strcmp (uri, uri_from_commandline) == 0; // FALSE
+ * g_free (uri);
+ *
+ * if (g_file_has_uri_scheme (file, "cdda"))
+ *   {
+ *     // do something special with uri
+ *   }
+ * g_object_unref (file);
+ * </programlisting>
+ *
+ * This code will work when both <literal>cdda://sr0/Track
+ * 1.wav</literal> and <literal>/home/user/.gvfs/cdda on sr0/Track
+ * 1.wav</literal> is passed to the application. It should be noted
+ * that it's generally not safe for applications to rely on the format
+ * of a particular URIs. Different launcher applications (e.g. file
+ * managers) may have different ideas of what a given URI means.
+ */
+
+
+/**
+ * SECTION:gapplication
+ * @title: GApplication
+ * @short_description: Core application class
+ *
+ * A #GApplication is the foundation of an application.  It wraps some
+ * low-level platform-specific services and is intended to act as the
+ * foundation for higher-level application classes such as
+ * #GtkApplication or #MxApplication.  In general, you should not use
+ * this class outside of a higher level framework.
+ *
+ * GApplication provides convenient life cycle management by maintaining
+ * a <firstterm>use count</firstterm> for the primary application instance.
+ * The use count can be changed using g_application_hold() and
+ * g_application_release(). If it drops to zero, the application exits.
+ * Higher-level classes such as #GtkApplication employ the use count to
+ * ensure that the application stays alive as long as it has any opened
+ * windows.
+ *
+ * Another feature that GApplication (optionally) provides is process
+ * uniqueness.  Applications can make use of this functionality by
+ * providing a unique application ID.  If given, only one application
+ * with this ID can be running at a time per session.  The session
+ * concept is platform-dependent, but corresponds roughly to a graphical
+ * desktop login.  When your application is launched again, its
+ * arguments are passed through platform communication to the already
+ * running program.  The already running instance of the program is
+ * called the <firstterm>primary instance</firstterm>; for non-unique
+ * applications this is the always the current instance.
+ * On Linux, the D-Bus session bus is used for communication.
+ *
+ * The use of #GApplication differs from some other commonly-used
+ * uniqueness libraries (such as libunique) in important ways.  The
+ * application is not expected to manually register itself and check if
+ * it is the primary instance.  Instead, the <code>main()</code>
+ * function of a #GApplication should do very little more than
+ * instantiating the application instance, possibly connecting signal
+ * handlers, then calling g_application_run().  All checks for
+ * uniqueness are done internally.  If the application is the primary
+ * instance then the startup signal is emitted and the mainloop runs.
+ * If the application is not the primary instance then a signal is sent
+ * to the primary instance and g_application_run() promptly returns.
+ * See the code examples below.
+ *
+ * If used, the expected form of an application identifier is very close
+ * to that of of a
+ * <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-interface">DBus bus name</ulink>.
+ * Examples include: "com.example.MyApp", "org.example.internal-apps.Calculator".
+ * For details on valid application identifiers, see g_application_id_is_valid().
+ *
+ * On Linux, the application identifier is claimed as a well-known bus name
+ * on the user's session bus.  This means that the uniqueness of your
+ * application is scoped to the current session.  It also means that your
+ * application may provide additional services (through registration of other
+ * object paths) at that bus name.  The registration of these object paths
+ * should be done with the shared GDBus session bus.  Note that due to the
+ * internal architecture of GDBus, method calls can be dispatched at any time
+ * (even if a main loop is not running).  For this reason, you must ensure that
+ * any object paths that you wish to register are registered before #GApplication
+ * attempts to acquire the bus name of your application (which happens in
+ * g_application_register()).  Unfortunately, this means that you cannot use
+ * g_application_get_is_remote() to decide if you want to register object paths.
+ *
+ * GApplication also implements the #GActionGroup and #GActionMap
+ * interfaces and lets you easily export actions by adding them with
+ * g_action_map_add_action(). When invoking an action by calling
+ * g_action_group_activate_action() on the application, it is always
+ * invoked in the primary instance. The actions are also exported on
+ * the session bus, and GIO provides the #GDBusActionGroup wrapper to
+ * conveniently access them remotely. GIO provides a #GDBusMenuModel wrapper
+ * for remote access to exported #GMenuModels.
+ *
+ * There is a number of different entry points into a GApplication:
+ * <itemizedlist>
+ * <listitem>via 'Activate' (i.e. just starting the application)</listitem>
+ * <listitem>via 'Open' (i.e. opening some files)</listitem>
+ * <listitem>by handling a command-line</listitem>
+ * <listitem>via activating an action</listitem>
+ * </itemizedlist>
+ * The #GApplication::startup signal lets you handle the application
+ * initialization for all of these in a single place.
+ *
+ * Regardless of which of these entry points is used to start the application,
+ * GApplication passes some <firstterm id="platform-data">platform
+ * data</firstterm> from the launching instance to the primary instance,
+ * in the form of a #GVariant dictionary mapping strings to variants.
+ * To use platform data, override the @before_emit or @after_emit virtual
+ * functions in your #GApplication subclass. When dealing with
+ * #GApplicationCommandLine objects, the platform data is directly
+ * available via g_application_command_line_get_cwd(),
+ * g_application_command_line_get_environ() and
+ * g_application_command_line_get_platform_data().
+ *
+ * As the name indicates, the platform data may vary depending on the
+ * operating system, but it always includes the current directory (key
+ * "cwd"), and optionally the environment (ie the set of environment
+ * variables and their values) of the calling process (key "environ").
+ * The environment is only added to the platform data if the
+ * %G_APPLICATION_SEND_ENVIRONMENT flag is set. #GApplication subclasses
+ * can add their own platform data by overriding the @add_platform_data
+ * virtual function. For instance, #GtkApplication adds startup notification
+ * data in this way.
+ *
+ * To parse commandline arguments you may handle the
+ * #GApplication::command-line signal or override the local_command_line()
+ * vfunc, to parse them in either the primary instance or the local instance,
+ * respectively.
+ *
+ * <example id="gapplication-example-open"><title>Opening files with a GApplication</title>
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-open.c">
+ *   <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
+ * </xi:include>
+ * </programlisting>
+ * </example>
+ *
+ * <example id="gapplication-example-actions"><title>A GApplication with actions</title>
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-actions.c">
+ *   <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
+ * </xi:include>
+ * </programlisting>
+ * </example>
+ *
+ * <example id="gapplication-example-menu"><title>A GApplication with menus</title>
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-menu.c">
+ *   <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
+ * </xi:include>
+ * </programlisting>
+ * </example>
+ *
+ * <example id="gapplication-example-dbushooks"><title>Using extra D-Bus hooks with a GApplication</title>
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-dbushooks.c">
+ *   <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
+ * </xi:include>
+ * </programlisting>
+ * </example>
+ */
+
+
+/**
+ * SECTION:gapplicationcommandline
+ * @title: GApplicationCommandLine
+ * @short_description: A command-line invocation of an application
+ * @see_also: #GApplication
+ *
+ * #GApplicationCommandLine represents a command-line invocation of
+ * an application.  It is created by #GApplication and emitted
+ * in the #GApplication::command-line signal and virtual function.
+ *
+ * The class contains the list of arguments that the program was invoked
+ * with.  It is also possible to query if the commandline invocation was
+ * local (ie: the current process is running in direct response to the
+ * invocation) or remote (ie: some other process forwarded the
+ * commandline to this process).
+ *
+ * The GApplicationCommandLine object can provide the @argc and @argv
+ * parameters for use with the #GOptionContext command-line parsing API,
+ * with the g_application_command_line_get_arguments() function. See
+ * <xref linkend="gapplication-example-cmdline3"/> for an example.
+ *
+ * The exit status of the originally-invoked process may be set and
+ * messages can be printed to stdout or stderr of that process.  The
+ * lifecycle of the originally-invoked process is tied to the lifecycle
+ * of this object (ie: the process exits when the last reference is
+ * dropped).
+ *
+ * The main use for #GApplicationCommandLine (and the
+ * #GApplication::command-line signal) is 'Emacs server' like use cases:
+ * You can set the <envar>EDITOR</envar> environment variable to have
+ * e.g. git use your favourite editor to edit commit messages, and if you
+ * already have an instance of the editor running, the editing will happen
+ * in the running instance, instead of opening a new one. An important
+ * aspect of this use case is that the process that gets started by git
+ * does not return until the editing is done.
+ *
+ * <example id="gapplication-example-cmdline"><title>Handling commandline arguments with GApplication</title>
+ * <para>
+ * A simple example where the commandline is completely handled
+ * in the #GApplication::command-line handler. The launching instance exits
+ * once the signal handler in the primary instance has returned, and the
+ * return value of the signal handler becomes the exit status of the launching
+ * instance.
+ * </para>
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-cmdline.c">
+ *   <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
+ * </xi:include>
+ * </programlisting>
+ * </example>
+ *
+ * <example id="gapplication-example-cmdline2"><title>Split commandline handling</title>
+ * <para>
+ * An example of split commandline handling. Options that start with
+ * <literal>--local-</literal> are handled locally, all other options are
+ * passed to the #GApplication::command-line handler which runs in the primary
+ * instance.
+ * </para>
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-cmdline2.c">
+ *   <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
+ * </xi:include>
+ * </programlisting>
+ * </example>
+ *
+ * <example id="gapplication-example-cmdline3"><title>Deferred commandline handling</title>
+ * <para>
+ * An example of deferred commandline handling. Here, the commandline is
+ * not completely handled before the #GApplication::command-line handler
+ * returns. Instead, we keep a reference to the GApplicationCommandLine
+ * object and handle it later(in this example, in an idle). Note that it
+ * is necessary to hold the application until you are done with the
+ * commandline.
+ * </para>
+ * <para>
+ * This example also shows how to use #GOptionContext for parsing the
+ * commandline arguments. Note that it is necessary to disable the
+ * built-in help-handling of #GOptionContext, since it calls exit()
+ * after printing help, which is not what you want to happen in
+ * the primary instance.
+ * </para>
+ * <programlisting>
+ * <xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gapplication-example-cmdline3.c">
+ *   <xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback>
+ * </xi:include>
+ * </programlisting>
+ * </example>
+ */
+
+
+/**
+ * SECTION:gasyncinitable
+ * @short_description: Asynchronously failable object initialization interface
+ * @include: gio/gio.h
+ * @see_also: #GInitable
+ *
+ * This is the asynchronous version of #GInitable; it behaves the same
+ * in all ways except that initialization is asynchronous. For more details
+ * see the descriptions on #GInitable.
+ *
+ * A class may implement both the #GInitable and #GAsyncInitable interfaces.
+ *
+ * Users of objects implementing this are not intended to use the interface
+ * method directly; instead it will be used automatically in various ways.
+ * For C applications you generally just call g_async_initable_new_async()
+ * directly, or indirectly via a foo_thing_new_async() wrapper. This will call
+ * g_async_initable_init_async() under the cover, calling back with %NULL and
+ * a set %GError on failure.
+ *
+ * A typical implementation might look something like this:
+ *
+ * |[
+ * enum {
+ *    NOT_INITIALIZED,
+ *    INITIALIZING,
+ *    INITIALIZED
+ * };
+ *
+ * static void
+ * _foo_ready_cb (Foo *self)
+ * {
+ *   GList *l;
+ *
+ *   self->priv->state = INITIALIZED;
+ *
+ *   for (l = self->priv->init_results; l != NULL; l = l->next)
+ *     {
+ *       GTask *task = l->data;
+ *
+ *       if (self->priv->success)
+ *         g_task_return_boolean (task, TRUE);
+ *       else
+ *         g_task_return_new_error (task, ...);
+ *       g_object_unref (task);
+ *     }
+ *
+ *   g_list_free (self->priv->init_results);
+ *   self->priv->init_results = NULL;
+ * }
+ *
+ * static void
+ * foo_init_async (GAsyncInitable       *initable,
+ *                 int                   io_priority,
+ *                 GCancellable         *cancellable,
+ *                 GAsyncReadyCallback   callback,
+ *                 gpointer              user_data)
+ * {
+ *   Foo *self = FOO (initable);
+ *   GTask *task;
+ *
+ *   task = g_task_new (initable, cancellable, callback, user_data);
+ *
+ *   switch (self->priv->state)
+ *     {
+ *       case NOT_INITIALIZED:
+ *         _foo_get_ready (self);
+ *         self->priv->init_results = g_list_append (self->priv->init_results,
+ *                                                   task);
+ *         self->priv->state = INITIALIZING;
+ *         break;
+ *       case INITIALIZING:
+ *         self->priv->init_results = g_list_append (self->priv->init_results,
+ *                                                   task);
+ *         break;
+ *       case INITIALIZED:
+ *         if (!self->priv->success)
+ *           g_task_return_new_error (task, ...);
+ *         else
+ *           g_task_return_boolean (task, TRUE);
+ *         g_object_unref (task);
+ *         break;
+ *     }
+ * }
+ *
+ * static gboolean
+ * foo_init_finish (GAsyncInitable       *initable,
+ *                  GAsyncResult         *result,
+ *                  GError              **error)
+ * {
+ *   g_return_val_if_fail (g_task_is_valid (result, initable), FALSE);
+ *
+ *   return g_task_propagate_boolean (G_TASK (result), error);
+ * }
+ *
+ * static void
+ * foo_async_initable_iface_init (gpointer g_iface,
+ *                                gpointer data)
+ * {
+ *   GAsyncInitableIface *iface = g_iface;
+ *
+ *   iface->init_async = foo_init_async;
+ *   iface->init_finish = foo_init_finish;
+ * }
+ * ]|
+ */
+
+
+/**
+ * SECTION:gasyncresult
+ * @short_description: Asynchronous Function Results
+ * @include: gio/gio.h
+ * @see_also: #GTask
+ *
+ * Provides a base class for implementing asynchronous function results.
+ *
+ * Asynchronous operations are broken up into two separate operations
+ * which are chained together by a #GAsyncReadyCallback. To begin
+ * an asynchronous operation, provide a #GAsyncReadyCallback to the
+ * asynchronous function. This callback will be triggered when the
+ * operation has completed, and will be passed a #GAsyncResult instance
+ * filled with the details of the operation's success or failure, the
+ * object the asynchronous function was started for and any error codes
+ * returned. The asynchronous callback function is then expected to call
+ * the corresponding "_finish()" function, passing the object the
+ * function was called for, the #GAsyncResult instance, and (optionally)
+ * an @error to grab any error conditions that may have occurred.
+ *
+ * The "_finish()" function for an operation takes the generic result
+ * (of type #GAsyncResult) and returns the specific result that the
+ * operation in question yields (e.g. a #GFileEnumerator for a
+ * "enumerate children" operation). If the result or error status of the
+ * operation is not needed, there is no need to call the "_finish()"
+ * function; GIO will take care of cleaning up the result and error
+ * information after the #GAsyncReadyCallback returns. You can pass
+ * %NULL for the #GAsyncReadyCallback if you don't need to take any
+ * action at all after the operation completes. Applications may also
+ * take a reference to the #GAsyncResult and call "_finish()" later;
+ * however, the "_finish()" function may be called at most once.
+ *
+ * Example of a typical asynchronous operation flow:
+ * |[
+ * void _theoretical_frobnitz_async (Theoretical         *t,
+ *                                   GCancellable        *c,
+ *                                   GAsyncReadyCallback *cb,
+ *                                   gpointer             u);
+ *
+ * gboolean _theoretical_frobnitz_finish (Theoretical   *t,
+ *                                        GAsyncResult  *res,
+ *                                        GError       **e);
+ *
+ * static void
+ * frobnitz_result_func (GObject      *source_object,
+ * 		 GAsyncResult *res,
+ * 		 gpointer      user_data)
+ * {
+ *   gboolean success = FALSE;
+ *
+ *   success = _theoretical_frobnitz_finish (source_object, res, NULL);
+ *
+ *   if (success)
+ *     g_printf ("Hurray!\n");
+ *   else
+ *     g_printf ("Uh oh!\n");
+ *
+ *   /<!-- -->* ... *<!-- -->/
+ *
+ * }
+ *
+ * int main (int argc, void *argv[])
+ * {
+ *    /<!-- -->* ... *<!-- -->/
+ *
+ *    _theoretical_frobnitz_async (theoretical_data,
+ *                                 NULL,
+ *                                 frobnitz_result_func,
+ *                                 NULL);
+ *
+ *    /<!-- -->* ... *<!-- -->/
+ * }
+ * ]|
+ *
+ * The callback for an asynchronous operation is called only once, and is
+ * always called, even in the case of a cancelled operation. On cancellation
+ * the result is a %G_IO_ERROR_CANCELLED error.
+ *
+ * <para id="io-priority"><indexterm><primary>I/O
+ * priority</primary></indexterm> Many I/O-related asynchronous
+ * operations have a priority parameter, which is used in certain
+ * cases to determine the order in which operations are executed. They
+ * are <emphasis>not</emphasis> used to determine system-wide I/O
+ * scheduling. Priorities are integers, with lower numbers indicating
+ * higher priority. It is recommended to choose priorities between
+ * %G_PRIORITY_LOW and %G_PRIORITY_HIGH, with %G_PRIORITY_DEFAULT as a
+ * default. </para>
+ */
+
+
+/**
+ * SECTION:gbufferedinputstream
+ * @short_description: Buffered Input Stream
+ * @include: gio/gio.h
+ * @see_also: #GFilterInputStream, #GInputStream
+ *
+ * Buffered input stream implements #GFilterInputStream and provides
+ * for buffered reads.
+ *
+ * By default, #GBufferedInputStream's buffer size is set at 4 kilobytes.
+ *
+ * To create a buffered input stream, use g_buffered_input_stream_new(),
+ * or g_buffered_input_stream_new_sized() to specify the buffer's size at
+ * construction.
+ *
+ * To get the size of a buffer within a buffered input stream, use
+ * g_buffered_input_stream_get_buffer_size(). To change the size of a
+ * buffered input stream's buffer, use
+ * g_buffered_input_stream_set_buffer_size(). Note that the buffer's size
+ * cannot be reduced below the size of the data within the buffer.
+ */
+
+
+/**
+ * SECTION:gbufferedoutputstream
+ * @short_description: Buffered Output Stream
+ * @include: gio/gio.h
+ * @see_also: #GFilterOutputStream, #GOutputStream
+ *
+ * Buffered output stream implements #GFilterOutputStream and provides
+ * for buffered writes.
+ *
+ * By default, #GBufferedOutputStream's buffer size is set at 4 kilobytes.
+ *
+ * To create a buffered output stream, use g_buffered_output_stream_new(),
+ * or g_buffered_output_stream_new_sized() to specify the buffer's size
+ * at construction.
+ *
+ * To get the size of a buffer within a buffered input stream, use
+ * g_buffered_output_stream_get_buffer_size(). To change the size of a
+ * buffered output stream's buffer, use
+ * g_buffered_output_stream_set_buffer_size(). Note that the buffer's
+ * size cannot be reduced below the size of the data within the buffer.
+ */
+
+
+/**
+ * SECTION:gcancellable
+ * @short_description: Thread-safe Operation Cancellation Stack
+ * @include: gio/gio.h
+ *
+ * GCancellable is a thread-safe operation cancellation stack used
+ * throughout GIO to allow for cancellation of synchronous and
+ * asynchronous operations.
+ */
+
+
+/**
+ * SECTION:gcharsetconverter
+ * @short_description: Convert between charsets
+ * @include: gio/gio.h
+ *
+ * #GCharsetConverter is an implementation of #GConverter based on
+ * GIConv.
+ */
+
+
+/**
+ * SECTION:gcontenttype
+ * @short_description: Platform-specific content typing
+ * @include: gio/gio.h
+ *
+ * A content type is a platform specific string that defines the type
+ * of a file. On UNIX it is a <ulink url="http://www.wikipedia.org/wiki/Internet_media_type">mime type</ulink> like "text/plain" or "image/png".
+ * On Win32 it is an extension string like ".doc", ".txt" or a perceived
+ * string like "audio". Such strings can be looked up in the registry at
+ * HKEY_CLASSES_ROOT.
+ */
+
+
+/**
+ * SECTION:gconverter
+ * @short_description: Data conversion interface
+ * @include: gio/gio.h
+ * @see_also: #GInputStream, #GOutputStream
+ *
+ * #GConverter is implemented by objects that convert
+ * binary data in various ways. The conversion can be
+ * stateful and may fail at any place.
+ *
+ * Some example conversions are: character set conversion,
+ * compression, decompression and regular expression
+ * replace.
+ *
+ * Since: 2.24
+ */
+
+
+/**
+ * SECTION:gconverterinputstream
+ * @short_description: Converter Input Stream
+ * @include: gio/gio.h
+ * @see_also: #GInputStream, #GConverter
+ *
+ * Converter input stream implements #GInputStream and allows
+ * conversion of data of various types during reading.
+ *
+ * As of GLib 2.34, #GConverterInputStream implements
+ * #GPollableInputStream.
+ */
+
+
+/**
+ * SECTION:gconverteroutputstream
+ * @short_description: Converter Output Stream
+ * @include: gio/gio.h
+ * @see_also: #GOutputStream, #GConverter
+ *
+ * Converter output stream implements #GOutputStream and allows
+ * conversion of data of various types during reading.
+ *
+ * As of GLib 2.34, #GConverterOutputStream implements
+ * #GPollableOutputStream.
+ */
+
+
+/**
+ * SECTION:gcredentials
+ * @short_description: An object containing credentials
+ * @include: gio/gio.h
+ *
+ * The #GCredentials type is a reference-counted wrapper for native
+ * credentials. This information is typically used for identifying,
+ * authenticating and authorizing other processes.
+ *
+ * Some operating systems supports looking up the credentials of the
+ * remote peer of a communication endpoint - see e.g.
+ * g_socket_get_credentials().
+ *
+ * Some operating systems supports securely sending and receiving
+ * credentials over a Unix Domain Socket, see
+ * #GUnixCredentialsMessage, g_unix_connection_send_credentials() and
+ * g_unix_connection_receive_credentials() for details.
+ *
+ * On Linux, the native credential type is a <type>struct ucred</type>
+ * - see the
+ * <citerefentry><refentrytitle>unix</refentrytitle><manvolnum>7</manvolnum></citerefentry>
+ * man page for details. This corresponds to
+ * %G_CREDENTIALS_TYPE_LINUX_UCRED.
+ *
+ * On FreeBSD, the native credential type is a <type>struct cmsgcred</type>.
+ * This corresponds to %G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED.
+ *
+ * On OpenBSD, the native credential type is a <type>struct sockpeercred</type>.
+ * This corresponds to %G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED.
+ */
+
+
+/**
+ * SECTION:gdatainputstream
+ * @short_description: Data Input Stream
+ * @include: gio/gio.h
+ * @see_also: #GInputStream
+ *
+ * Data input stream implements #GInputStream and includes functions for
+ * reading structured data directly from a binary input stream.
+ */
+
+
+/**
+ * SECTION:gdataoutputstream
+ * @short_description: Data Output Stream
+ * @include: gio/gio.h
+ * @see_also: #GOutputStream
+ *
+ * Data output stream implements #GOutputStream and includes functions for
+ * writing data directly to an output stream.
+ */
+
+
+/**
+ * SECTION:gdbusactiongroup
+ * @title: GDBusActionGroup
+ * @short_description: A D-Bus GActionGroup implementation
+ * @see_also: <link linkend="gio-GActionGroup-exporter">GActionGroup exporter</link>
+ *
+ * #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().
+ */
+
+
+/**
+ * SECTION:gdbusaddress
+ * @title: D-Bus Addresses
+ * @short_description: D-Bus connection endpoints
+ * @include: gio/gio.h
+ *
+ * Routines for working with D-Bus addresses. A D-Bus address is a string
+ * like "unix:tmpdir=/tmp/my-app-name". The exact format of addresses
+ * is explained in detail in the <link linkend="http://dbus.freedesktop.org/doc/dbus-specification.html&num;addresses">D-Bus specification</link>.
+ */
+
+
+/**
+ * SECTION:gdbusauthobserver
+ * @short_description: Object used for authenticating connections
+ * @include: gio/gio.h
+ *
+ * The #GDBusAuthObserver type provides a mechanism for participating
+ * in how a #GDBusServer (or a #GDBusConnection) authenticates remote
+ * peers. Simply instantiate a #GDBusAuthObserver and connect to the
+ * signals you are interested in. Note that new signals may be added
+ * in the future
+ *
+ * For example, if you only want to allow D-Bus connections from
+ * processes owned by the same uid as the server, you would use a
+ * signal handler like the following:
+ * <example id="auth-observer"><title>Controlling Authentication</title><programlisting>
+ * static gboolean
+ * on_authorize_authenticated_peer (GDBusAuthObserver *observer,
+ *                                  GIOStream         *stream,
+ *                                  GCredentials      *credentials,
+ *                                  gpointer           user_data)
+ * {
+ *   gboolean authorized;
+ *
+ *   authorized = FALSE;
+ *   if (credentials != NULL)
+ *     {
+ *       GCredentials *own_credentials;
+ *       own_credentials = g_credentials_new ();
+ *       if (g_credentials_is_same_user (credentials, own_credentials, NULL))
+ *         authorized = TRUE;
+ *       g_object_unref (own_credentials);
+ *     }
+ *
+ *   return authorized;
+ * }
+ * </programlisting></example>
+ */
+
+
+/**
+ * SECTION:gdbusconnection
+ * @short_description: D-Bus Connections
+ * @include: gio/gio.h
+ *
+ * The #GDBusConnection type is used for D-Bus connections to remote
+ * peers such as a message buses. It is a low-level API that offers a
+ * lot of flexibility. For instance, it lets you establish a connection
+ * over any transport that can by represented as an #GIOStream.
+ *
+ * This class is rarely used directly in D-Bus clients. If you are writing
+ * an D-Bus client, it is often easier to use the g_bus_own_name(),
+ * g_bus_watch_name() or g_dbus_proxy_new_for_bus() APIs.
+ *
+ * As an exception to the usual GLib rule that a particular object must not be
+ * used by two threads at the same time, #GDBusConnection's methods may be
+ * called from any thread<footnote>
+ * <para>
+ *   This is so that g_bus_get() and g_bus_get_sync() can safely return the
+ *   same #GDBusConnection when called from any thread.
+ * </para>
+ * </footnote>.
+ *
+ * Most of the ways to obtain a #GDBusConnection automatically initialize it
+ * (i.e. connect to D-Bus): for instance, g_dbus_connection_new() and
+ * g_bus_get(), and the synchronous versions of those methods, give you an
+ * initialized connection. Language bindings for GIO should use
+ * g_initable_new() or g_async_initable_new_async(), which also initialize the
+ * connection.
+ *
+ * If you construct an uninitialized #GDBusConnection, such as via
+ * g_object_new(), you must initialize it via g_initable_init() or
+ * g_async_initable_init_async() before using its methods or properties.
+ * Calling methods or accessing properties on a #GDBusConnection that has not
+ * completed initialization successfully is considered to be invalid, and leads
+ * to undefined behaviour. In particular, if initialization fails with a
+ * #GError, the only valid thing you can do with that #GDBusConnection is to
+ * free it with g_object_unref().
+ *
+ * <example id="gdbus-server"><title>D-Bus server example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-server.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ *
+ * <example id="gdbus-subtree-server"><title>D-Bus subtree example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-subtree.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ *
+ * <example id="gdbus-unix-fd-client"><title>D-Bus UNIX File Descriptor example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-unix-fd-client.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ *
+ * <example id="gdbus-export"><title>Exporting a GObject</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-export.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ */
+
+
+/**
+ * SECTION:gdbuserror
+ * @title: GDBusError
+ * @short_description: Mapping D-Bus errors to and from GError
+ * @include: gio/gio.h
+ *
+ * All facilities that return errors from remote methods (such as
+ * g_dbus_connection_call_sync()) use #GError to represent both D-Bus
+ * errors (e.g. errors returned from the other peer) and locally
+ * in-process generated errors.
+ *
+ * To check if a returned #GError is an error from a remote peer, use
+ * g_dbus_error_is_remote_error(). To get the actual D-Bus error name,
+ * use g_dbus_error_get_remote_error(). Before presenting an error,
+ * always use g_dbus_error_strip_remote_error().
+ *
+ * In addition, facilities used to return errors to a remote peer also
+ * use #GError. See g_dbus_method_invocation_return_error() for
+ * discussion about how the D-Bus error name is set.
+ *
+ * Applications can associate a #GError error domain with a set of D-Bus errors in order to
+ * automatically map from D-Bus errors to #GError and back. This
+ * is typically done in the function returning the #GQuark for the
+ * error domain:
+ * <example id="error-registration"><title>Error Registration</title><programlisting>
+ * /<!-- -->* foo-bar-error.h: *<!-- -->/
+ *
+ * #define FOO_BAR_ERROR (foo_bar_error_quark ())
+ * GQuark foo_bar_error_quark (void);
+ *
+ * typedef enum
+ * {
+ *   FOO_BAR_ERROR_FAILED,
+ *   FOO_BAR_ERROR_ANOTHER_ERROR,
+ *   FOO_BAR_ERROR_SOME_THIRD_ERROR,
+ *   FOO_BAR_N_ERRORS /<!-- -->*< skip >*<!-- -->/
+ * } FooBarError;
+ *
+ * /<!-- -->* foo-bar-error.c: *<!-- -->/
+ *
+ * static const GDBusErrorEntry foo_bar_error_entries[] =
+ * {
+ *   {FOO_BAR_ERROR_FAILED,           "org.project.Foo.Bar.Error.Failed"},
+ *   {FOO_BAR_ERROR_ANOTHER_ERROR,    "org.project.Foo.Bar.Error.AnotherError"},
+ *   {FOO_BAR_ERROR_SOME_THIRD_ERROR, "org.project.Foo.Bar.Error.SomeThirdError"},
+ * };
+ *
+ * /<!-- -->* Ensure that every error code has an associated D-Bus error name *<!-- -->/
+ * G_STATIC_ASSERT (G_N_ELEMENTS (foo_bar_error_entries) == FOO_BAR_N_ERRORS);
+ *
+ * GQuark
+ * foo_bar_error_quark (void)
+ * {
+ *   static volatile gsize quark_volatile = 0;
+ *   g_dbus_error_register_error_domain ("foo-bar-error-quark",
+ *                                       &quark_volatile,
+ *                                       foo_bar_error_entries,
+ *                                       G_N_ELEMENTS (foo_bar_error_entries));
+ *   return (GQuark) quark_volatile;
+ * }
+ * </programlisting></example>
+ * With this setup, a D-Bus peer can transparently pass e.g. %FOO_BAR_ERROR_ANOTHER_ERROR and
+ * other peers will see the D-Bus error name <literal>org.project.Foo.Bar.Error.AnotherError</literal>.
+ *
+ * If the other peer is using GDBus, and has registered the association with
+ * g_dbus_error_register_error_domain() in advance (e.g. by invoking the %FOO_BAR_ERROR quark
+ * generation itself in the previous example) the peer will see also %FOO_BAR_ERROR_ANOTHER_ERROR instead
+ * of %G_IO_ERROR_DBUS_ERROR. Note that GDBus clients can still recover
+ * <literal>org.project.Foo.Bar.Error.AnotherError</literal> using g_dbus_error_get_remote_error().
+ *
+ * Note that errors in the %G_DBUS_ERROR error domain is intended only
+ * for returning errors from a remote message bus process. Errors
+ * generated locally in-process by e.g. #GDBusConnection is from the
+ * %G_IO_ERROR domain.
+ */
+
+
+/**
+ * SECTION:gdbusinterface
+ * @short_description: Base type for D-Bus interfaces
+ * @include: gio/gio.h
+ *
+ * The #GDBusInterface type is the base type for D-Bus interfaces both
+ * on the service side (see #GDBusInterfaceSkeleton) and client side
+ * (see #GDBusProxy).
+ */
+
+
+/**
+ * SECTION:gdbusinterfaceskeleton
+ * @short_description: Service-side D-Bus interface
+ * @include: gio/gio.h
+ *
+ * Abstract base class for D-Bus interfaces on the service side.
+ */
+
+
+/**
+ * SECTION:gdbusintrospection
+ * @title: D-Bus Introspection Data
+ * @short_description: Node and interface description data structures
+ * @include: gio/gio.h
+ *
+ * Various data structures and convenience routines to parse and
+ * generate D-Bus introspection XML. Introspection information is
+ * used when registering objects with g_dbus_connection_register_object().
+ *
+ * The format of D-Bus introspection XML is specified in the
+ * <ulink url="http://dbus.freedesktop.org/doc/dbus-specification.html#introspection-format">D-Bus specification</ulink>.
+ */
+
+
+/**
+ * SECTION:gdbusmenumodel
+ * @title: GDBusMenuModel
+ * @short_description: A D-Bus GMenuModel implementation
+ * @see_also: <link linkend="gio-GMenuModel-exporter">GMenuModel Exporter</link>
+ *
+ * #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().
+ */
+
+
+/**
+ * SECTION:gdbusmessage
+ * @short_description: D-Bus Message
+ * @include: gio/gio.h
+ *
+ * A type for representing D-Bus messages that can be sent or received
+ * on a #GDBusConnection.
+ */
+
+
+/**
+ * SECTION:gdbusmethodinvocation
+ * @short_description: Object for handling remote calls
+ * @include: gio/gio.h
+ *
+ * Instances of the #GDBusMethodInvocation class are used when
+ * handling D-Bus method calls. It provides a way to asynchronously
+ * return results and errors.
+ *
+ * The normal way to obtain a #GDBusMethodInvocation object is to receive
+ * it as an argument to the handle_method_call() function in a
+ * #GDBusInterfaceVTable that was passed to g_dbus_connection_register_object().
+ */
+
+
+/**
+ * SECTION:gdbusnameowning
+ * @title: Owning Bus Names
+ * @short_description: Simple API for owning bus names
+ * @include: gio/gio.h
+ *
+ * Convenience API for owning bus names.
+ *
+ * <example id="gdbus-owning-names"><title>Simple application owning a name</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-own-name.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ */
+
+
+/**
+ * SECTION:gdbusnamewatching
+ * @title: Watching Bus Names
+ * @short_description: Simple API for watching bus names
+ * @include: gio/gio.h
+ *
+ * Convenience API for watching bus names.
+ *
+ * <example id="gdbus-watching-names"><title>Simple application watching a name</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-watch-name.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ */
+
+
+/**
+ * SECTION:gdbusobject
+ * @short_description: Base type for D-Bus objects
+ * @include: gio/gio.h
+ *
+ * The #GDBusObject type is the base type for D-Bus objects on both
+ * the service side (see #GDBusObjectSkeleton) and the client side
+ * (see #GDBusObjectProxy). It is essentially just a container of
+ * interfaces.
+ */
+
+
+/**
+ * SECTION:gdbusobjectmanager
+ * @short_description: Base type for D-Bus object managers
+ * @include: gio/gio.h
+ *
+ * The #GDBusObjectManager type is the base type for service- and
+ * client-side implementations of the standardized <ulink
+ * url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager">org.freedesktop.DBus.ObjectManager</ulink>
+ * interface.
+ *
+ * See #GDBusObjectManagerClient for the client-side implementation
+ * and #GDBusObjectManagerServer for the service-side implementation.
+ */
+
+
+/**
+ * SECTION:gdbusobjectmanagerclient
+ * @short_description: Client-side object manager
+ * @include: gio/gio.h
+ *
+ * #GDBusObjectManagerClient is used to create, monitor and delete object
+ * proxies for remote objects exported by a #GDBusObjectManagerServer (or any
+ * code implementing the <ulink
+ * url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager">org.freedesktop.DBus.ObjectManager</ulink>
+ * interface).
+ *
+ * Once an instance of this type has been created, you can connect to
+ * the #GDBusObjectManager::object-added and
+ * #GDBusObjectManager::object-removed signals and inspect the
+ * #GDBusObjectProxy objects returned by
+ * g_dbus_object_manager_get_objects().
+ *
+ * If the name for a #GDBusObjectManagerClient is not owned by anyone at
+ * object construction time, the default behavior is to request the
+ * message bus to launch an owner for the name. This behavior can be
+ * disabled using the %G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START
+ * flag. It's also worth noting that this only works if the name of
+ * interest is activatable in the first place. E.g. in some cases it
+ * is not possible to launch an owner for the requested name. In this
+ * case, #GDBusObjectManagerClient object construction still succeeds but
+ * there will be no object proxies
+ * (e.g. g_dbus_object_manager_get_objects() returns the empty list) and
+ * the #GDBusObjectManagerClient:name-owner property is %NULL.
+ *
+ * The owner of the requested name can come and go (for example
+ * consider a system service being restarted) – #GDBusObjectManagerClient
+ * handles this case too; simply connect to the #GObject::notify
+ * signal to watch for changes on the #GDBusObjectManagerClient:name-owner
+ * property. When the name owner vanishes, the behavior is that
+ * #GDBusObjectManagerClient:name-owner is set to %NULL (this includes
+ * emission of the #GObject::notify signal) and then
+ * #GDBusObjectManager::object-removed signals are synthesized
+ * for all currently existing object proxies. Since
+ * #GDBusObjectManagerClient:name-owner is %NULL when this happens, you can
+ * use this information to disambiguate a synthesized signal from a
+ * genuine signal caused by object removal on the remote
+ * #GDBusObjectManager. Similarly, when a new name owner appears,
+ * #GDBusObjectManager::object-added signals are synthesized
+ * while #GDBusObjectManagerClient:name-owner is still %NULL. Only when all
+ * object proxies have been added, the #GDBusObjectManagerClient:name-owner
+ * is set to the new name owner (this includes emission of the
+ * #GObject::notify signal).  Furthermore, you are guaranteed that
+ * #GDBusObjectManagerClient:name-owner will alternate between a name owner
+ * (e.g. <literal>:1.42</literal>) and %NULL even in the case where
+ * the name of interest is atomically replaced
+ *
+ * Ultimately, #GDBusObjectManagerClient is used to obtain #GDBusProxy
+ * instances. All signals (including the
+ * <literal>org.freedesktop.DBus.Properties::PropertiesChanged</literal>
+ * signal) delivered to #GDBusProxy instances are guaranteed to
+ * originate from the name owner. This guarantee along with the
+ * behavior described above, means that certain race conditions
+ * including the <emphasis><quote>half the proxy is from the old owner
+ * and the other half is from the new owner</quote></emphasis> problem
+ * cannot happen.
+ *
+ * To avoid having the application connect to signals on the returned
+ * #GDBusObjectProxy and #GDBusProxy objects, the
+ * #GDBusObject::interface-added,
+ * #GDBusObject::interface-removed,
+ * #GDBusProxy::g-properties-changed and
+ * #GDBusProxy::g-signal signals
+ * are also emitted on the #GDBusObjectManagerClient instance managing these
+ * objects. The signals emitted are
+ * #GDBusObjectManager::interface-added,
+ * #GDBusObjectManager::interface-removed,
+ * #GDBusObjectManagerClient::interface-proxy-properties-changed and
+ * #GDBusObjectManagerClient::interface-proxy-signal.
+ *
+ * Note that all callbacks and signals are emitted in the
+ * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
+ * that the #GDBusObjectManagerClient object was constructed
+ * in. Additionally, the #GDBusObjectProxy and #GDBusProxy objects
+ * originating from the #GDBusObjectManagerClient object will be created in
+ * the same context and, consequently, will deliver signals in the
+ * same main loop.
+ */
+
+
+/**
+ * SECTION:gdbusobjectmanagerserver
+ * @short_description: Service-side object manager
+ * @include: gio/gio.h
+ *
+ * #GDBusObjectManagerServer is used to export #GDBusObject instances using
+ * the standardized <ulink
+ * url="http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager">org.freedesktop.DBus.ObjectManager</ulink>
+ * 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.
+ *
+ * See #GDBusObjectManagerClient for the client-side code that is
+ * intended to be used with #GDBusObjectManagerServer or any D-Bus
+ * object implementing the org.freedesktop.DBus.ObjectManager
+ * interface.
+ */
+
+
+/**
+ * SECTION:gdbusobjectproxy
+ * @short_description: Client-side D-Bus object
+ * @include: gio/gio.h
+ *
+ * A #GDBusObjectProxy is an object used to represent a remote object
+ * with one or more D-Bus interfaces. Normally, you don't instantiate
+ * a #GDBusObjectProxy yourself - typically #GDBusObjectManagerClient
+ * is used to obtain it.
+ *
+ * Since: 2.30
+ */
+
+
+/**
+ * SECTION:gdbusobjectskeleton
+ * @short_description: Service-side D-Bus object
+ * @include: gio/gio.h
+ *
+ * A #GDBusObjectSkeleton instance is essentially a group of D-Bus
+ * interfaces. The set of exported interfaces on the object may be
+ * dynamic and change at runtime.
+ *
+ * This type is intended to be used with #GDBusObjectManager.
+ */
+
+
+/**
+ * SECTION:gdbusproxy
+ * @short_description: Client-side D-Bus interface proxy
+ * @include: gio/gio.h
+ *
+ * #GDBusProxy is a base class used for proxies to access a D-Bus
+ * interface on a remote object. A #GDBusProxy can be constructed for
+ * both well-known and unique names.
+ *
+ * By default, #GDBusProxy will cache all properties (and listen to
+ * changes) of the remote object, and proxy all signals that gets
+ * emitted. This behaviour can be changed by passing suitable
+ * #GDBusProxyFlags when the proxy is created. If the proxy is for a
+ * well-known name, the property cache is flushed when the name owner
+ * vanishes and reloaded when a name owner appears.
+ *
+ * If a #GDBusProxy is used for a well-known name, the owner of the
+ * name is tracked and can be read from
+ * #GDBusProxy:g-name-owner. Connect to the #GObject::notify signal to
+ * get notified of changes. Additionally, only signals and property
+ * changes emitted from the current name owner are considered and
+ * calls are always sent to the current name owner. This avoids a
+ * number of race conditions when the name is lost by one owner and
+ * claimed by another. However, if no name owner currently exists,
+ * then calls will be sent to the well-known name which may result in
+ * the message bus launching an owner (unless
+ * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is set).
+ *
+ * The generic #GDBusProxy::g-properties-changed and
+ * #GDBusProxy::g-signal signals are not very convenient to work
+ * with. Therefore, the recommended way of working with proxies is to
+ * subclass #GDBusProxy, and have more natural properties and signals
+ * in your derived class. See <xref linkend="gdbus-example-gdbus-codegen"/>
+ * for how this can easily be done using the
+ * <command><link linkend="gdbus-codegen">gdbus-codegen</link></command>
+ * tool.
+ *
+ * A #GDBusProxy instance can be used from multiple threads but note
+ * that all signals (e.g. #GDBusProxy::g-signal, #GDBusProxy::g-properties-changed
+ * and #GObject::notify) are emitted in the
+ * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
+ * of the thread where the instance was constructed.
+ *
+ * <example id="gdbus-wellknown-proxy"><title>GDBusProxy for a well-known-name</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-watch-proxy.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ */
+
+
+/**
+ * SECTION:gdbusserver
+ * @short_description: Helper for accepting connections
+ * @include: gio/gio.h
+ *
+ * #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 the org.freedesktop.DBus interface.
+ *
+ * To just export an object on a well-known name on a message bus, such as the
+ * session or system bus, you should instead use g_bus_own_name().
+ *
+ * <example id="gdbus-peer-to-peer"><title>D-Bus peer-to-peer example</title><programlisting><xi:include xmlns:xi="http://www.w3.org/2001/XInclude" parse="text" href="../../../../gio/tests/gdbus-example-peer.c"><xi:fallback>FIXME: MISSING XINCLUDE CONTENT</xi:fallback></xi:include></programlisting></example>
+ */
+
+
+/**
+ * SECTION:gdbusutils
+ * @title: D-Bus Utilities
+ * @short_description: Various utilities related to D-Bus.
+ * @include: gio/gio.h
+ *
+ * Various utility routines related to D-Bus.
+ */
+
+
+/**
+ * SECTION:gdesktopappinfo
+ * @title: GDesktopAppInfo
+ * @short_description: Application information from desktop files
+ * @include: gio/gdesktopappinfo.h
+ *
+ * #GDesktopAppInfo is an implementation of #GAppInfo based on
+ * desktop files.
+ *
+ * Note that <filename>&lt;gio/gdesktopappinfo.h&gt;</filename> belongs to
+ * the UNIX-specific GIO interfaces, thus you have to use the
+ * <filename>gio-unix-2.0.pc</filename> pkg-config file when using it.
+ */
+
+
+/**
+ * SECTION:gdrive
+ * @short_description: Drive management
+ * @include: gio/gio.h
+ *
+ * #GDrive - this represent a piece of hardware connected to the machine.
+ * It's generally only created for removable hardware or hardware with
+ * removable media.
+ *
+ * #GDrive is a container class for #GVolume objects that stem from
+ * the same piece of media. As such, #GDrive abstracts a drive with
+ * (or without) removable media and provides operations for querying
+ * whether media is available, determining whether media change is
+ * automatically detected and ejecting the media.
+ *
+ * If the #GDrive reports that media isn't automatically detected, one
+ * can poll for media; typically one should not do this periodically
+ * as a poll for media operation is potententially expensive and may
+ * spin up the drive creating noise.
+ *
+ * #GDrive supports starting and stopping drives with authentication
+ * support for the former. This can be used to support a diverse set
+ * of use cases including connecting/disconnecting iSCSI devices,
+ * powering down external disk enclosures and starting/stopping
+ * multi-disk devices such as RAID devices. Note that the actual
+ * semantics and side-effects of starting/stopping a #GDrive may vary
+ * according to implementation. To choose the correct verbs in e.g. a
+ * file manager, use g_drive_get_start_stop_type().
+ *
+ * For porting from GnomeVFS note that there is no equivalent of
+ * #GDrive in that API.
+ */
+
+
+/**
+ * SECTION:gemblem
+ * @short_description: An object for emblems
+ * @include: gio/gio.h
+ * @see_also: #GIcon, #GEmblemedIcon, #GLoadableIcon, #GThemedIcon
+ *
+ * #GEmblem is an implementation of #GIcon that supports
+ * having an emblem, which is an icon with additional properties.
+ * It can than be added to a #GEmblemedIcon.
+ *
+ * Currently, only metainformation about the emblem's origin is
+ * supported. More may be added in the future.
+ */
+
+
+/**
+ * SECTION:gemblemedicon
+ * @short_description: Icon with emblems
+ * @include: gio/gio.h
+ * @see_also: #GIcon, #GLoadableIcon, #GThemedIcon, #GEmblem
+ *
+ * #GEmblemedIcon is an implementation of #GIcon that supports
+ * adding an emblem to an icon. Adding multiple emblems to an
+ * icon is ensured via g_emblemed_icon_add_emblem().
+ *
+ * Note that #GEmblemedIcon allows no control over the position
+ * of the emblems. See also #GEmblem for more information.
+ */
+
+
+/**
+ * SECTION:gfile
+ * @short_description: File and Directory Handling
+ * @include: gio/gio.h
+ * @see_also: #GFileInfo, #GFileEnumerator
+ *
+ * #GFile is a high level abstraction for manipulating files on a
+ * virtual file system. #GFiles are lightweight, immutable objects
+ * that do no I/O upon creation. It is necessary to understand that
+ * #GFile objects do not represent files, merely an identifier for a
+ * file. All file content I/O is implemented as streaming operations
+ * (see #GInputStream and #GOutputStream).
+ *
+ * To construct a #GFile, you can use:
+ * <simplelist>
+ * <member>g_file_new_for_path() if you have a path.</member>
+ * <member>g_file_new_for_uri() if you have a URI.</member>
+ * <member>g_file_new_for_commandline_arg() for a command line argument.</member>
+ * <member>g_file_new_tmp() to create a temporary file from a template.</member>
+ * <member>g_file_parse_name() from a UTF-8 string gotten from g_file_get_parse_name().</member>
+ * </simplelist>
+ *
+ * One way to think of a #GFile is as an abstraction of a pathname. For
+ * normal files the system pathname is what is stored internally, but as
+ * #GFiles are extensible it could also be something else that corresponds
+ * to a pathname in a userspace implementation of a filesystem.
+ *
+ * #GFiles make up hierarchies of directories and files that correspond to
+ * the files on a filesystem. You can move through the file system with
+ * #GFile using g_file_get_parent() to get an identifier for the parent
+ * directory, g_file_get_child() to get a child within a directory,
+ * g_file_resolve_relative_path() to resolve a relative path between two
+ * #GFiles. There can be multiple hierarchies, so you may not end up at
+ * the same root if you repeatedly call g_file_get_parent() on two different
+ * files.
+ *
+ * All #GFiles have a basename (get with g_file_get_basename()). These names
+ * are byte strings that are used to identify the file on the filesystem
+ * (relative to its parent directory) and there is no guarantees that they
+ * have any particular charset encoding or even make any sense at all. If
+ * you want to use filenames in a user interface you should use the display
+ * name that you can get by requesting the
+ * %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME attribute with g_file_query_info().
+ * This is guaranteed to be in UTF-8 and can be used in a user interface.
+ * But always store the real basename or the #GFile to use to actually
+ * access the file, because there is no way to go from a display name to
+ * the actual name.
+ *
+ * Using #GFile as an identifier has the same weaknesses as using a path
+ * in that there may be multiple aliases for the same file. For instance,
+ * hard or soft links may cause two different #GFiles to refer to the same
+ * file. Other possible causes for aliases are: case insensitive filesystems,
+ * short and long names on FAT/NTFS, or bind mounts in Linux. If you want to
+ * check if two #GFiles point to the same file you can query for the
+ * %G_FILE_ATTRIBUTE_ID_FILE attribute. Note that #GFile does some trivial
+ * canonicalization of pathnames passed in, so that trivial differences in
+ * the path string used at creation (duplicated slashes, slash at end of
+ * path, "." or ".." path segments, etc) does not create different #GFiles.
+ *
+ * Many #GFile operations have both synchronous and asynchronous versions
+ * to suit your application. Asynchronous versions of synchronous functions
+ * simply have _async() appended to their function names. The asynchronous
+ * I/O functions call a #GAsyncReadyCallback which is then used to finalize
+ * the operation, producing a GAsyncResult which is then passed to the
+ * function's matching _finish() operation.
+ *
+ * Some #GFile operations do not have synchronous analogs, as they may
+ * take a very long time to finish, and blocking may leave an application
+ * unusable. Notable cases include:
+ * <simplelist>
+ * <member>g_file_mount_mountable() to mount a mountable file.</member>
+ * <member>g_file_unmount_mountable_with_operation() to unmount a mountable file.</member>
+ * <member>g_file_eject_mountable_with_operation() to eject a mountable file.</member>
+ * </simplelist>
+ *
+ * <para id="gfile-etag"><indexterm><primary>entity tag</primary></indexterm>
+ * One notable feature of #GFiles are entity tags, or "etags" for
+ * short. Entity tags are somewhat like a more abstract version of the
+ * traditional mtime, and can be used to quickly determine if the file has
+ * been modified from the version on the file system. See the HTTP 1.1
+ * <ulink url="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html">specification</ulink>
+ * for HTTP Etag headers, which are a very similar concept.
+ * </para>
+ */
+
+
+/**
+ * SECTION:gfileattribute
+ * @short_description: Key-Value Paired File Attributes
+ * @include: gio/gio.h
+ * @see_also: #GFile, #GFileInfo
+ *
+ * File attributes in GIO consist of a list of key-value pairs.
+ *
+ * Keys are strings that contain a key namespace and a key name, separated
+ * by a colon, e.g. "namespace::keyname". Namespaces are included to sort
+ * key-value pairs by namespaces for relevance. Keys can be retrived
+ * using wildcards, e.g. "standard::*" will return all of the keys in the
+ * "standard" namespace.
+ *
+ * The list of possible attributes for a filesystem (pointed to by a #GFile) is
+ * available as a #GFileAttributeInfoList. This list is queryable by key names
+ * as indicated earlier.
+ *
+ * Information is stored within the list in #GFileAttributeInfo structures.
+ * The info structure can store different types, listed in the enum
+ * #GFileAttributeType. Upon creation of a #GFileAttributeInfo, the type will
+ * be set to %G_FILE_ATTRIBUTE_TYPE_INVALID.
+ *
+ * Classes that implement #GFileIface will create a #GFileAttributeInfoList and
+ * install default keys and values for their given file system, architecture,
+ * and other possible implementation details (e.g., on a UNIX system, a file
+ * attribute key will be registered for the user id for a given file).
+ *
+ * <para>
+ * <table>
+ * <title>GFileAttributes Default Namespaces</title>
+ * <tgroup cols='2' align='left'><thead>
+ * <row><entry>Namspace</entry><entry>Description</entry></row>
+ * </thead>
+ * <tbody>
+ * <row><entry>"standard"</entry><entry>The "Standard" namespace. General file
+ * information that any application may need should be put in this namespace.
+ * Examples include the file's name, type, and size.</entry></row>
+ * <row><entry>"etag"</entry><entry>The <link linkend="gfile-etag">"Entity Tag"</link>
+ * namespace. Currently, the only key in this namespace is "value", which contains
+ * the value of the current entity tag.</entry></row>
+ * <row><entry>"id"</entry><entry>The "Identification" namespace. This
+ * namespace is used by file managers and applications that list directories
+ * to check for loops and to uniquely identify files.</entry></row>
+ * <row><entry>"access"</entry><entry>The "Access" namespace. Used to check
+ * if a user has the proper privilidges to access files and perform
+ * file operations. Keys in this namespace are made to be generic
+ * and easily understood, e.g. the "can_read" key is %TRUE if
+ * the current user has permission to read the file. UNIX permissions and
+ * NTFS ACLs in Windows should be mapped to these values.</entry></row>
+ * <row><entry>"mountable"</entry><entry>The "Mountable" namespace. Includes
+ * simple boolean keys for checking if a file or path supports mount operations, e.g.
+ * mount, unmount, eject. These are used for files of type %G_FILE_TYPE_MOUNTABLE.</entry></row>
+ * <row><entry>"time"</entry><entry>The "Time" namespace. Includes file
+ * access, changed, created times. </entry></row>
+ * <row><entry>"unix"</entry><entry>The "Unix" namespace. Includes UNIX-specific
+ * information and may not be available for all files. Examples include
+ * the UNIX "UID", "GID", etc.</entry></row>
+ * <row><entry>"dos"</entry><entry>The "DOS" namespace. Includes DOS-specific
+ * information and may not be available for all files. Examples include
+ * "is_system" for checking if a file is marked as a system file, and "is_archive"
+ * for checking if a file is marked as an archive file.</entry></row>
+ * <row><entry>"owner"</entry><entry>The "Owner" namespace. Includes information
+ * about who owns a file. May not be available for all file systems. Examples include
+ * "user" for getting the user name of the file owner. This information is often mapped from
+ * some backend specific data such as a unix UID.</entry></row>
+ * <row><entry>"thumbnail"</entry><entry>The "Thumbnail" namespace. Includes
+ * information about file thumbnails and their location within the file system. Examples of
+ * keys in this namespace include "path" to get the location of a thumbnail, and "failed"
+ * to check if thumbnailing of the file failed.</entry></row>
+ * <row><entry>"filesystem"</entry><entry>The "Filesystem" namespace. Gets information
+ * about the file system where a file is located, such as its type, how much
+ * space is left available, and the overall size of the file system.</entry></row>
+ * <row><entry>"gvfs"</entry><entry>The "GVFS" namespace. Keys in this namespace
+ * contain information about the current GVFS backend in use. </entry></row>
+ * <row><entry>"xattr"</entry><entry>The "xattr" namespace. Gets information
+ * about extended user attributes. See attr(5). The "user." prefix of the
+ * extended user attribute name is stripped away when constructing keys in
+ * this namespace, e.g. "xattr::mime_type" for the extended attribute with
+ * the name "user.mime_type". Note that this information is only available
+ * if GLib has been built with extended attribute support.</entry></row>
+ * <row><entry>"xattr-sys"</entry><entry>The "xattr-sys" namespace.
+ * Gets information about extended attributes which are not user-specific.
+ * See attr(5). Note that this information is only available if GLib
+ * has been built with extended attribute support.</entry></row>
+ * <row><entry>"selinux"</entry><entry>The "SELinux" namespace. Includes
+ * information about the SELinux context of files. Note that this information
+ * is only available if GLib has been built with SELinux support.</entry></row>
+ * </tbody>
+ * </tgroup>
+ * </table>
+ * </para>
+ *
+ * Please note that these are not all of the possible namespaces.
+ * More namespaces can be added from GIO modules or by individual applications.
+ * For more information about writing GIO modules, see #GIOModule.
+ *
+ * <!-- TODO: Implementation note about using extended attributes on supported
+ * file systems -->
+ *
+ * <para><table>
+ * <title>GFileAttributes Built-in Keys and Value Types</title>
+ * <tgroup cols='3' align='left'><thead>
+ * <row><entry>Enum Value</entry><entry>Namespace::Key</entry><entry>Value Type</entry></row>
+ * </thead><tbody>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_TYPE</entry><entry>standard::type</entry><entry>uint32 (#GFileType)</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN</entry><entry>standard::is-hidden</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP</entry><entry>standard::is-backup</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK</entry><entry>standard::is-symlink</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL</entry><entry>standard::is-virtual</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_NAME</entry><entry>standard::name</entry><entry>byte string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME</entry><entry>standard::display-name</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME</entry><entry>standard::edit-name</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_ICON</entry><entry>standard::icon</entry><entry>object (#GIcon)</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE</entry><entry>standard::content-type</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE</entry><entry>standard::fast-content-type</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_SIZE</entry><entry>standard::size</entry><entry>uint64</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE</entry><entry>standard::allocated-size</entry><entry>uint64</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET</entry><entry>standard::symlink-target</entry><entry>byte string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_TARGET_URI</entry><entry>standard::target-uri</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER</entry><entry>standard::sort-order</entry><entry>int32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ETAG_VALUE</entry><entry>etag::value</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ID_FILE</entry><entry>id::file</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ID_FILESYSTEM</entry><entry>id::filesystem</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ACCESS_CAN_READ</entry><entry>access::can-read</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE</entry><entry>access::can-write</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE</entry><entry>access::can-execute</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE</entry><entry>access::can-delete</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH</entry><entry>access::can-trash</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME</entry><entry>access::can-rename</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT</entry><entry>mountable::can-mount</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT</entry><entry>mountable::can-unmount</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT</entry><entry>mountable::can-eject</entry><entry>boolean</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE</entry><entry>mountable::unix-device</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE</entry><entry>mountable::unix-device-file</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI</entry><entry>mountable::hal-udi</entry><entry>string</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_MODIFIED</entry><entry>time::modified</entry><entry>uint64</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC</entry><entry>time::modified-usec</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_ACCESS</entry><entry>time::access</entry><entry>uint64</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_ACCESS_USEC</entry><entry>time::access-usec</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_CHANGED</entry><entry>time::changed</entry><entry>uint64</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_CHANGED_USEC</entry><entry>time::changed-usec</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_CREATED</entry><entry>time::created</entry><entry>uint64</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_TIME_CREATED_USEC</entry><entry>time::created-usec</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_UNIX_DEVICE</entry><entry>unix::device</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_UNIX_INODE</entry><entry>unix::inode</entry><entry>uint64</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_UNIX_MODE</entry><entry>unix::mode</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_UNIX_NLINK</entry><entry>unix::nlink</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_UNIX_UID</entry><entry>unix::uid</entry><entry>uint32</entry></row>
+ * <row><entry>%G_FILE_ATTRIBUTE_UNIX_GID</entry><entry>unix::gid</entry><entry>uint32</entry></row>