Signals

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

Prototype of a GChildWatchSource callback, called when a child process has exited. To interpret status, see the documentation for spawnCheckExitStatus.

Prototype of a GChildWatchSource callback, called when a child process has exited. To interpret status, see the documentation for spawnCheckExitStatus.

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

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

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

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

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

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

Wrap the callback into a Closure.

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

A convenience synonym for Nothing :: Maybe CopyFunc.

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

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

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

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

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.

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

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

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

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

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 vulerable 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 Closure.

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

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().

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

Wrap the callback into a Closure.

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

A convenience synonym for Nothing :: Maybe HookCheckMarshaller.

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

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

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().

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

Wrap the callback into a Closure.

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

A convenience synonym for Nothing :: Maybe HookFindFunc.

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

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().

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

Wrap the callback into a Closure.

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

A convenience synonym for Nothing :: Maybe HookMarshaller.

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.

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

Wrap the callback into a Closure.

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

A convenience synonym for Nothing :: Maybe IOFunc.

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

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

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

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

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

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.

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.

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

A convenience synonym for Nothing :: Maybe MarkupParserEndElementFieldCallback.

A convenience synonym for Nothing :: Maybe MarkupParserEndElementFieldCallback_WithClosures.

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

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

A convenience synonym for Nothing :: Maybe MarkupParserErrorFieldCallback.

A convenience synonym for Nothing :: Maybe MarkupParserErrorFieldCallback_WithClosures.

Wrap a MarkupParserErrorFieldCallback into a C_MarkupParserErrorFieldCallback.

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.

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

A convenience synonym for Nothing :: Maybe MarkupParserPassthroughFieldCallback.

A convenience synonym for Nothing :: Maybe MarkupParserPassthroughFieldCallback_WithClosures.

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.

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

A convenience synonym for Nothing :: Maybe MarkupParserStartElementFieldCallback.

A convenience synonym for Nothing :: Maybe MarkupParserStartElementFieldCallback_WithClosures.

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.

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

A convenience synonym for Nothing :: Maybe MarkupParserTextFieldCallback.

A convenience synonym for Nothing :: Maybe MarkupParserTextFieldCallback_WithClosures.

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

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

A convenience synonym for Nothing :: Maybe MemVTableCallocFieldCallback.

Wrap a MemVTableCallocFieldCallback into a C_MemVTableCallocFieldCallback.

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

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

A convenience synonym for Nothing :: Maybe MemVTableFreeFieldCallback.

Wrap a MemVTableFreeFieldCallback into a C_MemVTableFreeFieldCallback.

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

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

A convenience synonym for Nothing :: Maybe MemVTableMallocFieldCallback.

Wrap a MemVTableMallocFieldCallback into a C_MemVTableMallocFieldCallback.

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

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

A convenience synonym for Nothing :: Maybe MemVTableReallocFieldCallback.

Wrap a MemVTableReallocFieldCallback into a C_MemVTableReallocFieldCallback.

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

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

A convenience synonym for Nothing :: Maybe MemVTableTryMallocFieldCallback.

Wrap a MemVTableTryMallocFieldCallback into a C_MemVTableTryMallocFieldCallback.

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

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

A convenience synonym for Nothing :: Maybe MemVTableTryReallocFieldCallback.

Wrap a MemVTableTryReallocFieldCallback into a C_MemVTableTryReallocFieldCallback.

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

Specifies the type of function passed to g_node_children_foreach(). The function is called with each child node, together with the user data passed to g_node_children_foreach().