Signals

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

Prototype of a GChildWatchSource callback, called when a child process has exited.

To interpret waitStatus, see the documentation for spawnCheckWaitStatus. In particular, on Unix platforms, note that it is usually not equal to the integer passed to exit() or returned from main().

Prototype of a GChildWatchSource callback, called when a child process has exited.

To interpret waitStatus, see the documentation for spawnCheckWaitStatus. In particular, on Unix platforms, note that it is usually not equal to the integer passed to exit() or returned from main().

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_ChildWatchFunc.

A convenience synonym for Nothing :: Maybe ChildWatchFunc.

A convenience synonym for Nothing :: Maybe ChildWatchFunc_WithClosures.

Wrap a ChildWatchFunc into a C_ChildWatchFunc.

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

Specifies the type of function passed to g_clear_handle_id(). The implementation is expected to free the resource identified by handleId; for instance, if handleId is a Source ID, sourceRemove can be used.

Since: 2.56

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_ClearHandleFunc.

A convenience synonym for Nothing :: Maybe ClearHandleFunc.

Wrap a ClearHandleFunc into a C_ClearHandleFunc.

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

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

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_CompareDataFunc.

A convenience synonym for Nothing :: Maybe CompareDataFunc.

A convenience synonym for Nothing :: Maybe CompareDataFunc_WithClosures.

Wrap a CompareDataFunc into a C_CompareDataFunc.

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

Specifies the type of a comparison function used to compare two values. The function should return a negative integer if the first value comes before the second, 0 if they are equal, or a positive integer if the first value comes after the second.

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_CompareFunc.

A convenience synonym for Nothing :: Maybe CompareFunc.

Wrap a CompareFunc into a C_CompareFunc.

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

A function of this signature is used to copy the node data when doing a deep-copy of a tree.

Since: 2.4

A function of this signature is used to copy the node data when doing a deep-copy of a tree.

Since: 2.4

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_CopyFunc.

A convenience synonym for Nothing :: Maybe CopyFunc.

A convenience synonym for Nothing :: Maybe CopyFunc_WithClosures.

Wrap a CopyFunc into a C_CopyFunc.

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

Specifies the type of function passed to datasetForeach. It is called with each GQuark id and associated data element, together with the userData parameter supplied to datasetForeach.

Specifies the type of function passed to datasetForeach. It is called with each GQuark id and associated data element, together with the userData parameter supplied to datasetForeach.

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_DataForeachFunc.

A convenience synonym for Nothing :: Maybe DataForeachFunc.

A convenience synonym for Nothing :: Maybe DataForeachFunc_WithClosures.

Wrap a DataForeachFunc into a C_DataForeachFunc.

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

Specifies the type of function which is called when a data element is destroyed. It is passed the pointer to the data element and should free any memory and resources allocated for it.

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_DestroyNotify.

A convenience synonym for Nothing :: Maybe DestroyNotify.

Wrap a DestroyNotify into a C_DestroyNotify.

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

The type of functions that are used to 'duplicate' an object. What this means depends on the context, it could just be incrementing the reference count, if data is a ref-counted object.

The type of functions that are used to 'duplicate' an object. What this means depends on the context, it could just be incrementing the reference count, if data is a ref-counted object.

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_DuplicateFunc.

A convenience synonym for Nothing :: Maybe DuplicateFunc.

A convenience synonym for Nothing :: Maybe DuplicateFunc_WithClosures.

Wrap a DuplicateFunc into a C_DuplicateFunc.

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

Specifies the type of a function used to test two values for equality. The function should return True if both values are equal and 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_EqualFunc.

A convenience synonym for Nothing :: Maybe EqualFunc.

Wrap a EqualFunc into a C_EqualFunc.

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

Specifies the type of a function used to test two values for equality. The function should return True if both values are equal and False otherwise.

This is a version of EqualFunc which provides a userData closure from the caller.

Since: 2.74

Specifies the type of a function used to test two values for equality. The function should return True if both values are equal and False otherwise.

This is a version of EqualFunc which provides a userData closure from the caller.

Since: 2.74

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_EqualFuncFull.

A convenience synonym for Nothing :: Maybe EqualFuncFull.

A convenience synonym for Nothing :: Maybe EqualFuncFull_WithClosures.

Wrap a EqualFuncFull into a C_EqualFuncFull.

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

Specifies the type of function which is called when an extended error instance is freed. It is passed the error pointer about to be freed, and should free the error's private data fields.

Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from error.

Since: 2.68

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_ErrorClearFunc.

A convenience synonym for Nothing :: Maybe ErrorClearFunc.

Wrap a ErrorClearFunc into a C_ErrorClearFunc.

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

Specifies the type of function which is called when an extended error instance is copied. It is passed the pointer to the destination error and source error, and should copy only the fields of the private data from srcError to destError.

Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from srcError and destError.

Since: 2.68

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_ErrorCopyFunc.

A convenience synonym for Nothing :: Maybe ErrorCopyFunc.

Wrap a ErrorCopyFunc into a C_ErrorCopyFunc.

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

Specifies the type of function which is called just after an extended error instance is created and its fields filled. It should only initialize the fields in the private data, which can be received with the generated *_get_private() function.

Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it already takes care of getting the private data from error.

Since: 2.68

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_ErrorInitFunc.

A convenience synonym for Nothing :: Maybe ErrorInitFunc.

Wrap a ErrorInitFunc into a C_ErrorInitFunc.

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

Declares a type of function which takes an arbitrary data pointer argument and has no return value. It is not currently used in GLib or GTK+.

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_FreeFunc.

A convenience synonym for Nothing :: Maybe FreeFunc.

Wrap a FreeFunc into a C_FreeFunc.

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

Specifies the type of functions passed to g_list_foreach() and g_slist_foreach().

Specifies the type of functions passed to g_list_foreach() and g_slist_foreach().

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_Func.

A convenience synonym for Nothing :: Maybe Func.

A convenience synonym for Nothing :: Maybe Func_WithClosures.

Wrap a Func into a C_Func.

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

Specifies the type of the function passed to g_hash_table_foreach(). It is called with each key/value pair, together with the userData parameter which is passed to g_hash_table_foreach().

Specifies the type of the function passed to g_hash_table_foreach(). It is called with each key/value pair, together with the userData parameter which is passed to g_hash_table_foreach().

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_HFunc.

A convenience synonym for Nothing :: Maybe HFunc.

A convenience synonym for Nothing :: Maybe HFunc_WithClosures.

Wrap a HFunc into a C_HFunc.

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

Specifies the type of the function passed to g_hash_table_foreach_remove(). It is called with each key/value pair, together with the userData parameter passed to g_hash_table_foreach_remove(). It should return True if the key/value pair should be removed from the HashTable.

Specifies the type of the function passed to g_hash_table_foreach_remove(). It is called with each key/value pair, together with the userData parameter passed to g_hash_table_foreach_remove(). It should return True if the key/value pair should be removed from the HashTable.

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_HRFunc.

A convenience synonym for Nothing :: Maybe HRFunc.

A convenience synonym for Nothing :: Maybe HRFunc_WithClosures.

Wrap a HRFunc into a C_HRFunc.

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

Specifies the type of the hash function which is passed to g_hash_table_new() when a HashTable is created.

The function is passed a key and should return a guint hash value. The functions directHash, intHash and strHash provide hash functions which can be used when the key is a gpointer, gint*, and gchar* respectively.

directHash is also the appropriate hash function for keys of the form GINT_TO_POINTER (n) (or similar macros).

A good hash functions should produce hash values that are evenly distributed over a fairly large range. The modulus is taken with the hash table size (a prime number) to find the 'bucket' to place each key into. The function should also be very fast, since it is called for each key lookup.

Note that the hash functions provided by GLib have these qualities, but are not particularly robust against manufactured keys that cause hash collisions. Therefore, you should consider choosing a more secure hash function when using a GHashTable with keys that originate in untrusted data (such as HTTP requests). Using strHash in that situation might make your application vulnerable to Algorithmic Complexity Attacks.

The key to choosing a good hash is unpredictability. Even cryptographic hashes are very easy to find collisions for when the remainder is taken modulo a somewhat predictable prime number. There must be an element of randomness that an attacker is unable to guess.

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_HashFunc.

A convenience synonym for Nothing :: Maybe HashFunc.

Wrap a HashFunc into a C_HashFunc.

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

Defines the type of a hook function that can be invoked by hookListInvokeCheck.

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_HookCheckFunc.

A convenience synonym for Nothing :: Maybe HookCheckFunc.

Wrap a HookCheckFunc into a C_HookCheckFunc.

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

Defines the type of function used by g_hook_list_marshal_check().

Defines the type of function used by g_hook_list_marshal_check().

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_HookCheckMarshaller.

A convenience synonym for Nothing :: Maybe HookCheckMarshaller.

A convenience synonym for Nothing :: Maybe HookCheckMarshaller_WithClosures.

Wrap a HookCheckMarshaller into a C_HookCheckMarshaller.

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

Defines the type of function used to compare Hook elements in g_hook_insert_sorted().

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_HookCompareFunc.

A convenience synonym for Nothing :: Maybe HookCompareFunc.

Wrap a HookCompareFunc into a C_HookCompareFunc.

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

Defines the type of function to be called when a hook in a list of hooks gets finalized.

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_HookFinalizeFunc.

A convenience synonym for Nothing :: Maybe HookFinalizeFunc.

Wrap a HookFinalizeFunc into a C_HookFinalizeFunc.

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

Defines the type of the function passed to g_hook_find().

Defines the type of the function passed to g_hook_find().

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_HookFindFunc.

A convenience synonym for Nothing :: Maybe HookFindFunc.

A convenience synonym for Nothing :: Maybe HookFindFunc_WithClosures.

Wrap a HookFindFunc into a C_HookFindFunc.

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

Defines the type of a hook function that can be invoked by hookListInvoke.

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_HookFunc.

A convenience synonym for Nothing :: Maybe HookFunc.

Wrap a HookFunc into a C_HookFunc.

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

Defines the type of function used by g_hook_list_marshal().

Defines the type of function used by g_hook_list_marshal().

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_HookMarshaller.

A convenience synonym for Nothing :: Maybe HookMarshaller.

A convenience synonym for Nothing :: Maybe HookMarshaller_WithClosures.

Wrap a HookMarshaller into a C_HookMarshaller.

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

Specifies the type of function passed to g_io_add_watch() or ioAddWatch, which is called when the requested condition on a IOChannel is satisfied.

Specifies the type of function passed to g_io_add_watch() or ioAddWatch, which is called when the requested condition on a IOChannel is satisfied.

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_IOFunc.

A convenience synonym for Nothing :: Maybe IOFunc.

A convenience synonym for Nothing :: Maybe IOFunc_WithClosures.

Wrap a IOFunc into a C_IOFunc.

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_IOFuncsIoCloseFieldCallback.

A convenience synonym for Nothing :: Maybe IOFuncsIoCloseFieldCallback.

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.

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe IOFuncsIoCreateWatchFieldCallback.

Wrap a IOFuncsIoCreateWatchFieldCallback into a C_IOFuncsIoCreateWatchFieldCallback.

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.

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe IOFuncsIoFreeFieldCallback.

Wrap a IOFuncsIoFreeFieldCallback into a C_IOFuncsIoFreeFieldCallback.

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.

Wrap the callback into a GClosure.

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

A convenience synonym for Nothing :: Maybe IOFuncsIoGetFlagsFieldCallback.

Wrap a IOFuncsIoGetFlagsFieldCallback into a C_IOFuncsIoGetFlagsFieldCallback.

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_IOFuncsIoReadFieldCallback.

A convenience synonym for Nothing :: Maybe IOFuncsIoReadFieldCallback.

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_IOFuncsIoSeekFieldCallback.

A convenience synonym for Nothing :: Maybe IOFuncsIoSeekFieldCallback.

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_IOFuncsIoSetFlagsFieldCallback.

A convenience synonym for Nothing :: Maybe IOFuncsIoSetFlagsFieldCallback.

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_IOFuncsIoWriteFieldCallback.

A convenience synonym for Nothing :: Maybe IOFuncsIoWriteFieldCallback.

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

Specifies the prototype of log handler functions.

The default log handler, logDefaultHandler, automatically appends a new-line character to message when printing it. It is advised that any custom log handler functions behave similarly, so that logging calls in user code do not need modifying to add a new-line character to the message if the log handler is changed.

This is not used if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

Specifies the prototype of log handler functions.

The default log handler, logDefaultHandler, automatically appends a new-line character to message when printing it. It is advised that any custom log handler functions behave similarly, so that logging calls in user code do not need modifying to add a new-line character to the message if the log handler is changed.

This is not used if structured logging is enabled; see [Using Structured Logging][using-structured-logging].

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_LogFunc.

A convenience synonym for Nothing :: Maybe LogFunc.

A convenience synonym for Nothing :: Maybe LogFunc_WithClosures.

Wrap a LogFunc into a C_LogFunc.

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

Writer function for log entries. A log entry is a collection of one or more GLogFields, using the standard <https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html field names from journal specification>. See g_log_structured() for more information.

Writer functions must ignore fields which they do not recognise, unless they can write arbitrary binary output, as field values may be arbitrary binary.

logLevel is guaranteed to be included in fields as the PRIORITY field, but is provided separately for convenience of deciding whether or where to output the log entry.

Writer functions should return LogWriterOutputHandled if they handled the log message successfully or if they deliberately ignored it. If there was an error handling the message (for example, if the writer function is meant to send messages to a remote logging server and there is a network error), it should return LogWriterOutputUnhandled. This allows writer functions to be chained and fall back to simpler handlers in case of failure.

Since: 2.50

Writer function for log entries. A log entry is a collection of one or more GLogFields, using the standard <https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html field names from journal specification>. See g_log_structured() for more information.

Writer functions must ignore fields which they do not recognise, unless they can write arbitrary binary output, as field values may be arbitrary binary.

logLevel is guaranteed to be included in fields as the PRIORITY field, but is provided separately for convenience of deciding whether or where to output the log entry.

Writer functions should return LogWriterOutputHandled if they handled the log message successfully or if they deliberately ignored it. If there was an error handling the message (for example, if the writer function is meant to send messages to a remote logging server and there is a network error), it should return LogWriterOutputUnhandled. This allows writer functions to be chained and fall back to simpler handlers in case of failure.

Since: 2.50

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_LogWriterFunc.

A convenience synonym for Nothing :: Maybe LogWriterFunc.

A convenience synonym for Nothing :: Maybe LogWriterFunc_WithClosures.

Wrap a LogWriterFunc into a C_LogWriterFunc.

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