Signals

No description available in the introspection data.

No description available in the introspection data.

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_ActionEntryActivateFieldCallback.

A convenience synonym for Nothing :: Maybe ActionEntryActivateFieldCallback.

A convenience synonym for Nothing :: Maybe ActionEntryActivateFieldCallback_WithClosures.

Wrap a ActionEntryActivateFieldCallback into a C_ActionEntryActivateFieldCallback.

No description available in the introspection data.

No description available in the introspection data.

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_ActionEntryChangeStateFieldCallback.

A convenience synonym for Nothing :: Maybe ActionEntryChangeStateFieldCallback.

A convenience synonym for Nothing :: Maybe ActionEntryChangeStateFieldCallback_WithClosures.

Wrap a ActionEntryChangeStateFieldCallback into a C_ActionEntryChangeStateFieldCallback.

Type definition for a function that will be called back when an asynchronous operation within GIO has been completed. AsyncReadyCallback callbacks from Task are guaranteed to be invoked in a later iteration of the thread-default main context (see mainContextPushThreadDefault) where the Task was created. All other users of AsyncReadyCallback must likewise call it asynchronously in a later iteration of the main context.

The asynchronous operation is guaranteed to have held a reference to sourceObject from the time when the *_async() function was called, until after this callback returns.

Type definition for a function that will be called back when an asynchronous operation within GIO has been completed. AsyncReadyCallback callbacks from Task are guaranteed to be invoked in a later iteration of the thread-default main context (see mainContextPushThreadDefault) where the Task was created. All other users of AsyncReadyCallback must likewise call it asynchronously in a later iteration of the main context.

The asynchronous operation is guaranteed to have held a reference to sourceObject from the time when the *_async() function was called, until after this callback returns.

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_AsyncReadyCallback.

A convenience synonym for Nothing :: Maybe AsyncReadyCallback.

A convenience synonym for Nothing :: Maybe AsyncReadyCallback_WithClosures.

Wrap a AsyncReadyCallback into a C_AsyncReadyCallback.

Invoked when a connection to a message bus has been obtained.

Since: 2.26

Invoked when a connection to a message bus has been obtained.

Since: 2.26

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_BusAcquiredCallback.

A convenience synonym for Nothing :: Maybe BusAcquiredCallback.

A convenience synonym for Nothing :: Maybe BusAcquiredCallback_WithClosures.

Wrap a BusAcquiredCallback into a C_BusAcquiredCallback.

Invoked when the name is acquired.

Since: 2.26

Invoked when the name is acquired.

Since: 2.26

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_BusNameAcquiredCallback.

A convenience synonym for Nothing :: Maybe BusNameAcquiredCallback.

A convenience synonym for Nothing :: Maybe BusNameAcquiredCallback_WithClosures.

Wrap a BusNameAcquiredCallback into a C_BusNameAcquiredCallback.

Invoked when the name being watched is known to have to have an owner.

Since: 2.26

Invoked when the name being watched is known to have to have an owner.

Since: 2.26

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_BusNameAppearedCallback.

A convenience synonym for Nothing :: Maybe BusNameAppearedCallback.

A convenience synonym for Nothing :: Maybe BusNameAppearedCallback_WithClosures.

Wrap a BusNameAppearedCallback into a C_BusNameAppearedCallback.

Invoked when the name is lost or connection has been closed.

Since: 2.26

Invoked when the name is lost or connection has been closed.

Since: 2.26

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_BusNameLostCallback.

A convenience synonym for Nothing :: Maybe BusNameLostCallback.

A convenience synonym for Nothing :: Maybe BusNameLostCallback_WithClosures.

Wrap a BusNameLostCallback into a C_BusNameLostCallback.

Invoked when the name being watched is known not to have to have an owner.

This is also invoked when the DBusConnection on which the watch was established has been closed. In that case, connection will be Nothing.

Since: 2.26

Invoked when the name being watched is known not to have to have an owner.

This is also invoked when the DBusConnection on which the watch was established has been closed. In that case, connection will be Nothing.

Since: 2.26

Type for the callback on the (unwrapped) C side.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_BusNameVanishedCallback.

A convenience synonym for Nothing :: Maybe BusNameVanishedCallback.

A convenience synonym for Nothing :: Maybe BusNameVanishedCallback_WithClosures.

Wrap a BusNameVanishedCallback into a C_BusNameVanishedCallback.

Type for the callback on the (unwrapped) C side.

This is the function type of the callback used for the Source returned by cancellableSourceNew.

Since: 2.28

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_CancellableSourceFunc.

A convenience synonym for Nothing :: Maybe CancellableSourceFunc.

Wrap a CancellableSourceFunc into a C_CancellableSourceFunc.

Type for the callback on the (unwrapped) C side.

The type of the getProperty function in DBusInterfaceVTable.

Since: 2.26

The type of the getProperty function in DBusInterfaceVTable.

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusInterfaceGetPropertyFunc.

A convenience synonym for Nothing :: Maybe DBusInterfaceGetPropertyFunc.

A convenience synonym for Nothing :: Maybe DBusInterfaceGetPropertyFunc_WithClosures.

Wrap a DBusInterfaceGetPropertyFunc into a C_DBusInterfaceGetPropertyFunc.

Type for the callback on the (unwrapped) C side.

The type of the methodCall function in DBusInterfaceVTable.

interfaceName may be NULL if not specified by the sender, although it’s encouraged for the sender to set it. If unset, and the object has only one method (across all interfaces) matching methodName, that method is invoked. Otherwise, behaviour is implementation defined. See the D-Bus specification. It is recommended to return [errorgio.DBusError.UNKNOWN_METHOD].

Since: 2.26

The type of the methodCall function in DBusInterfaceVTable.

interfaceName may be NULL if not specified by the sender, although it’s encouraged for the sender to set it. If unset, and the object has only one method (across all interfaces) matching methodName, that method is invoked. Otherwise, behaviour is implementation defined. See the D-Bus specification. It is recommended to return [errorgio.DBusError.UNKNOWN_METHOD].

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusInterfaceMethodCallFunc.

A convenience synonym for Nothing :: Maybe DBusInterfaceMethodCallFunc.

A convenience synonym for Nothing :: Maybe DBusInterfaceMethodCallFunc_WithClosures.

Wrap a DBusInterfaceMethodCallFunc into a C_DBusInterfaceMethodCallFunc.

Type for the callback on the (unwrapped) C side.

The type of the setProperty function in DBusInterfaceVTable.

Since: 2.26

The type of the setProperty function in DBusInterfaceVTable.

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusInterfaceSetPropertyFunc.

A convenience synonym for Nothing :: Maybe DBusInterfaceSetPropertyFunc.

A convenience synonym for Nothing :: Maybe DBusInterfaceSetPropertyFunc_WithClosures.

Wrap a DBusInterfaceSetPropertyFunc into a C_DBusInterfaceSetPropertyFunc.

Type for the callback on the (unwrapped) C side.

Signature for function used in dBusConnectionAddFilter.

A filter function is passed a DBusMessage and expected to return a DBusMessage too. Passive filter functions that don't modify the message can simply return the message object:

static GDBusMessage *
passive_filter (GDBusConnection *connection
                GDBusMessage    *message,
                gboolean         incoming,
                gpointer         user_data)
{
  // inspect @message
  return message;
}

Filter functions that wants to drop a message can simply return Nothing:

static GDBusMessage *
drop_filter (GDBusConnection *connection
             GDBusMessage    *message,
             gboolean         incoming,
             gpointer         user_data)
{
  if (should_drop_message)
    {
      g_object_unref (message);
      message = NULL;
    }
  return message;
}

Finally, a filter function may modify a message by copying it:

static GDBusMessage *
modifying_filter (GDBusConnection *connection
                  GDBusMessage    *message,
                  gboolean         incoming,
                  gpointer         user_data)
{
  GDBusMessage *copy;
  GError *error;

  error = NULL;
  copy = g_dbus_message_copy (message, &error);
  // handle @error being set
  g_object_unref (message);

  // modify @copy

  return copy;
}

If the returned DBusMessage is different from message and cannot be sent on connection (it could use features, such as file descriptors, not compatible with connection), then a warning is logged to standard error. Applications can check this ahead of time using dBusMessageToBlob passing a DBusCapabilityFlags value obtained from connection.

Since: 2.26

Signature for function used in dBusConnectionAddFilter.

A filter function is passed a DBusMessage and expected to return a DBusMessage too. Passive filter functions that don't modify the message can simply return the message object:

static GDBusMessage *
passive_filter (GDBusConnection *connection
                GDBusMessage    *message,
                gboolean         incoming,
                gpointer         user_data)
{
  // inspect @message
  return message;
}

Filter functions that wants to drop a message can simply return Nothing:

static GDBusMessage *
drop_filter (GDBusConnection *connection
             GDBusMessage    *message,
             gboolean         incoming,
             gpointer         user_data)
{
  if (should_drop_message)
    {
      g_object_unref (message);
      message = NULL;
    }
  return message;
}

Finally, a filter function may modify a message by copying it:

static GDBusMessage *
modifying_filter (GDBusConnection *connection
                  GDBusMessage    *message,
                  gboolean         incoming,
                  gpointer         user_data)
{
  GDBusMessage *copy;
  GError *error;

  error = NULL;
  copy = g_dbus_message_copy (message, &error);
  // handle @error being set
  g_object_unref (message);

  // modify @copy

  return copy;
}

If the returned DBusMessage is different from message and cannot be sent on connection (it could use features, such as file descriptors, not compatible with connection), then a warning is logged to standard error. Applications can check this ahead of time using dBusMessageToBlob passing a DBusCapabilityFlags value obtained from connection.

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusMessageFilterFunction.

A convenience synonym for Nothing :: Maybe DBusMessageFilterFunction.

A convenience synonym for Nothing :: Maybe DBusMessageFilterFunction_WithClosures.

Wrap a DBusMessageFilterFunction into a C_DBusMessageFilterFunction.

Type for the callback on the (unwrapped) C side.

Function signature for a function used to determine the GType to use for an interface proxy (if interfaceName is not Nothing) or object proxy (if interfaceName is Nothing).

This function is called in the thread-default main context (see mainContextPushThreadDefault) that manager was constructed in.

Since: 2.30

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusProxyTypeFunc.

A convenience synonym for Nothing :: Maybe DBusProxyTypeFunc.

Wrap a DBusProxyTypeFunc into a C_DBusProxyTypeFunc.

Type for the callback on the (unwrapped) C side.

Signature for callback function used in dBusConnectionSignalSubscribe.

Since: 2.26

Signature for callback function used in dBusConnectionSignalSubscribe.

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusSignalCallback.

A convenience synonym for Nothing :: Maybe DBusSignalCallback.

A convenience synonym for Nothing :: Maybe DBusSignalCallback_WithClosures.

Wrap a DBusSignalCallback into a C_DBusSignalCallback.

Type for the callback on the (unwrapped) C side.

The type of the dispatch function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

Since: 2.26

The type of the dispatch function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusSubtreeDispatchFunc.

A convenience synonym for Nothing :: Maybe DBusSubtreeDispatchFunc.

A convenience synonym for Nothing :: Maybe DBusSubtreeDispatchFunc_WithClosures.

Wrap a DBusSubtreeDispatchFunc into a C_DBusSubtreeDispatchFunc.

Type for the callback on the (unwrapped) C side.

The type of the enumerate function in DBusSubtreeVTable.

This function is called when generating introspection data and also when preparing to dispatch incoming messages in the event that the DBusSubtreeFlagsDispatchToUnenumeratedNodes flag is not specified (ie: to verify that the object path is valid).

Hierarchies are not supported; the items that you return should not contain the / character.

The return value will be freed with strfreev.

Since: 2.26

The type of the enumerate function in DBusSubtreeVTable.

This function is called when generating introspection data and also when preparing to dispatch incoming messages in the event that the DBusSubtreeFlagsDispatchToUnenumeratedNodes flag is not specified (ie: to verify that the object path is valid).

Hierarchies are not supported; the items that you return should not contain the / character.

The return value will be freed with strfreev.

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusSubtreeEnumerateFunc.

A convenience synonym for Nothing :: Maybe DBusSubtreeEnumerateFunc.

A convenience synonym for Nothing :: Maybe DBusSubtreeEnumerateFunc_WithClosures.

Wrap a DBusSubtreeEnumerateFunc into a C_DBusSubtreeEnumerateFunc.

Type for the callback on the (unwrapped) C side.

The type of the introspect function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

This function should return Nothing to indicate that there is no object at this node.

If this function returns non-Nothing, the return value is expected to be a Nothing-terminated array of pointers to DBusInterfaceInfo structures describing the interfaces implemented by node. This array will have dBusInterfaceInfoUnref called on each item before being freed with free.

The difference between returning Nothing and an array containing zero items is that the standard DBus interfaces will returned to the remote introspector in the empty array case, but not in the Nothing case.

Since: 2.26

The type of the introspect function in DBusSubtreeVTable.

Subtrees are flat. node, if non-Nothing, is always exactly one segment of the object path (ie: it never contains a slash).

This function should return Nothing to indicate that there is no object at this node.

If this function returns non-Nothing, the return value is expected to be a Nothing-terminated array of pointers to DBusInterfaceInfo structures describing the interfaces implemented by node. This array will have dBusInterfaceInfoUnref called on each item before being freed with free.

The difference between returning Nothing and an array containing zero items is that the standard DBus interfaces will returned to the remote introspector in the empty array case, but not in the Nothing case.

Since: 2.26

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DBusSubtreeIntrospectFunc.

A convenience synonym for Nothing :: Maybe DBusSubtreeIntrospectFunc.

A convenience synonym for Nothing :: Maybe DBusSubtreeIntrospectFunc_WithClosures.

Wrap a DBusSubtreeIntrospectFunc into a C_DBusSubtreeIntrospectFunc.

Type for the callback on the (unwrapped) C side.

This is the function type of the callback used for the Source returned by datagramBasedCreateSource.

Since: 2.48

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DatagramBasedSourceFunc.

A convenience synonym for Nothing :: Maybe DatagramBasedSourceFunc.

Wrap a DatagramBasedSourceFunc into a C_DatagramBasedSourceFunc.

Type for the callback on the (unwrapped) C side.

During invocation, desktopAppInfoLaunchUrisAsManager may create one or more child processes. This callback is invoked once for each, providing the process ID.

During invocation, desktopAppInfoLaunchUrisAsManager may create one or more child processes. This callback is invoked once for each, providing the process ID.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_DesktopAppLaunchCallback.

A convenience synonym for Nothing :: Maybe DesktopAppLaunchCallback.

A convenience synonym for Nothing :: Maybe DesktopAppLaunchCallback_WithClosures.

Wrap a DesktopAppLaunchCallback into a C_DesktopAppLaunchCallback.

Type for the callback on the (unwrapped) C side.

This callback type is used by fileMeasureDiskUsage to make periodic progress reports when measuring the amount of disk spaced used by a directory.

These calls are made on a best-effort basis and not all types of File will support them. At the minimum, however, one call will always be made immediately.

In the case that there is no support, reporting will be set to False (and the other values undefined) and no further calls will be made. Otherwise, the reporting will be True and the other values all-zeros during the first (immediate) call. In this way, you can know which type of progress UI to show without a delay.

For fileMeasureDiskUsage the callback is made directly. For g_file_measure_disk_usage_async() the callback is made via the default main context of the calling thread (ie: the same way that the final async result would be reported).

currentSize is in the same units as requested by the operation (see FileMeasureFlagsApparentSize).

The frequency of the updates is implementation defined, but is ideally about once every 200ms.

The last progress callback may or may not be equal to the final result. Always check the async result to get the final value.

Since: 2.38

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_FileMeasureProgressCallback.

A convenience synonym for Nothing :: Maybe FileMeasureProgressCallback.

Wrap a FileMeasureProgressCallback into a C_FileMeasureProgressCallback.

Type for the callback on the (unwrapped) C side.

When doing file operations that may take a while, such as moving a file or copying a file, a progress callback is used to pass how far along that operation is to the application.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_FileProgressCallback.

A convenience synonym for Nothing :: Maybe FileProgressCallback.

Wrap a FileProgressCallback into a C_FileProgressCallback.

Type for the callback on the (unwrapped) C side.

When loading the partial contents of a file with g_file_load_partial_contents_async(), it may become necessary to determine if any more data from the file should be loaded. A FileReadMoreCallback function facilitates this by returning True if more data should be read, or False otherwise.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_FileReadMoreCallback.

A convenience synonym for Nothing :: Maybe FileReadMoreCallback.

Wrap a FileReadMoreCallback into a C_FileReadMoreCallback.

Type for the callback on the (unwrapped) C side.

I/O Job function.

Long-running jobs should periodically check the cancellable to see if they have been cancelled.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_IOSchedulerJobFunc.

A convenience synonym for Nothing :: Maybe IOSchedulerJobFunc.

Wrap a IOSchedulerJobFunc into a C_IOSchedulerJobFunc.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

No description available in the introspection data.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_InputStreamClassCloseAsyncFieldCallback.

A convenience synonym for Nothing :: Maybe InputStreamClassCloseAsyncFieldCallback.

A convenience synonym for Nothing :: Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures.

Wrap a InputStreamClassCloseAsyncFieldCallback into a C_InputStreamClassCloseAsyncFieldCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Generate a function pointer callable from C code, from a C_InputStreamClassCloseFinishFieldCallback.

A convenience synonym for Nothing :: Maybe InputStreamClassCloseFinishFieldCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Generate a function pointer callable from C code, from a C_InputStreamClassCloseFnFieldCallback.

A convenience synonym for Nothing :: Maybe InputStreamClassCloseFnFieldCallback.

Type for the callback on the (unwrapped) C side.

No description available in the introspection data.

No description available in the introspection data.

A simple wrapper that ignores the closure arguments.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

Wrap the callback into a GClosure.

Generate a function pointer callable from C code, from a C_InputStreamClassReadAsyncFieldCallback.

A convenience synonym for Nothing :: Maybe InputStreamClassReadAsyncFieldCallback.

A convenience synonym for Nothing :: Maybe InputStreamClassReadAsyncFieldCallback_WithClosures.

Wrap a InputStreamClassReadAsyncFieldCallback into a C_InputStreamClassReadAsyncFieldCallback.

Type for the callback on the (unwrapped) C side.