GI.GLib.Callbacks

Signals

ChildWatchFunc

type C_ChildWatchFunc = Int32 -> Int32 -> Ptr () -> IO ()

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

type ChildWatchFunc

Arguments

 = Int32

pid: the process id of the child process

-> Int32

status: Status information about the child process, encoded in a platform-specific manner

-> IO ()

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

type ChildWatchFunc_WithClosures

Arguments

 = Int32

pid: the process id of the child process

-> Int32

status: Status information about the child process, encoded in a platform-specific manner

-> Ptr ()

userData: user data passed to g_child_watch_add()

-> IO ()

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

drop_closures_ChildWatchFunc :: ChildWatchFunc -> ChildWatchFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_ChildWatchFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ChildWatchFunc

-> Int32

pid: the process id of the child process

-> Int32

status: Status information about the child process, encoded in a platform-specific manner

-> Ptr ()

userData: user data passed to g_child_watch_add()

-> m ()

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

genClosure_ChildWatchFunc :: MonadIO m => ChildWatchFunc -> m (GClosure C_ChildWatchFunc)

Wrap the callback into a GClosure.

mk_ChildWatchFunc :: C_ChildWatchFunc -> IO (FunPtr C_ChildWatchFunc)

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

noChildWatchFunc :: Maybe ChildWatchFunc

A convenience synonym for Nothing :: Maybe ChildWatchFunc.

noChildWatchFunc_WithClosures :: Maybe ChildWatchFunc_WithClosures

A convenience synonym for Nothing :: Maybe ChildWatchFunc_WithClosures.

wrap_ChildWatchFunc :: Maybe (Ptr (FunPtr C_ChildWatchFunc)) -> ChildWatchFunc_WithClosures -> C_ChildWatchFunc

Wrap a ChildWatchFunc into a C_ChildWatchFunc.

ClearHandleFunc

type C_ClearHandleFunc = Word32 -> IO ()

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

type ClearHandleFunc

Arguments

 = Word32

handleId: the handle ID to clear

-> IO ()

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

dynamic_ClearHandleFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ClearHandleFunc

-> Word32

handleId: the handle ID to clear

-> m ()

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

genClosure_ClearHandleFunc :: MonadIO m => ClearHandleFunc -> m (GClosure C_ClearHandleFunc)

Wrap the callback into a GClosure.

mk_ClearHandleFunc :: C_ClearHandleFunc -> IO (FunPtr C_ClearHandleFunc)

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

noClearHandleFunc :: Maybe ClearHandleFunc

A convenience synonym for Nothing :: Maybe ClearHandleFunc.

wrap_ClearHandleFunc :: Maybe (Ptr (FunPtr C_ClearHandleFunc)) -> ClearHandleFunc -> C_ClearHandleFunc

Wrap a ClearHandleFunc into a C_ClearHandleFunc.

CompareDataFunc

type C_CompareDataFunc = Ptr () -> Ptr () -> Ptr () -> IO Int32

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

type CompareDataFunc

Arguments

 = Ptr ()

a: a value

-> Ptr ()

b: a value to compare with

-> IO Int32

Returns: negative value if a < b; zero if a = b; positive value if a > b

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.

type CompareDataFunc_WithClosures

Arguments

 = Ptr ()

a: a value

-> Ptr ()

b: a value to compare with

-> Ptr ()

userData: user data

-> IO Int32

Returns: negative value if a < b; zero if a = b; positive value if a > b

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.

drop_closures_CompareDataFunc :: CompareDataFunc -> CompareDataFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_CompareDataFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CompareDataFunc

-> Ptr ()

a: a value

-> Ptr ()

b: a value to compare with

-> Ptr ()

userData: user data

-> m Int32

Returns: negative value if a < b; zero if a = b; positive value if a > b

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

genClosure_CompareDataFunc :: MonadIO m => CompareDataFunc -> m (GClosure C_CompareDataFunc)

Wrap the callback into a GClosure.

mk_CompareDataFunc :: C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc)

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

noCompareDataFunc :: Maybe CompareDataFunc

A convenience synonym for Nothing :: Maybe CompareDataFunc.

noCompareDataFunc_WithClosures :: Maybe CompareDataFunc_WithClosures

A convenience synonym for Nothing :: Maybe CompareDataFunc_WithClosures.

wrap_CompareDataFunc :: Maybe (Ptr (FunPtr C_CompareDataFunc)) -> CompareDataFunc_WithClosures -> C_CompareDataFunc

Wrap a CompareDataFunc into a C_CompareDataFunc.

CompareFunc

type C_CompareFunc = Ptr () -> Ptr () -> IO Int32

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

type CompareFunc

Arguments

 = Ptr ()

a: a value

-> Ptr ()

b: a value to compare with

-> IO Int32

Returns: negative value if a < b; zero if a = b; positive value if a > b

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.

dynamic_CompareFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CompareFunc

-> Ptr ()

a: a value

-> Ptr ()

b: a value to compare with

-> m Int32

Returns: negative value if a < b; zero if a = b; positive value if a > b

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

genClosure_CompareFunc :: MonadIO m => CompareFunc -> m (GClosure C_CompareFunc)

Wrap the callback into a GClosure.

mk_CompareFunc :: C_CompareFunc -> IO (FunPtr C_CompareFunc)

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

noCompareFunc :: Maybe CompareFunc

A convenience synonym for Nothing :: Maybe CompareFunc.

wrap_CompareFunc :: Maybe (Ptr (FunPtr C_CompareFunc)) -> CompareFunc -> C_CompareFunc

Wrap a CompareFunc into a C_CompareFunc.

CopyFunc

type C_CopyFunc = Ptr () -> Ptr () -> IO (Ptr ())

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

type CopyFunc

Arguments

 = Ptr ()

src: A pointer to the data which should be copied

-> Ptr ()

data: Additional data

-> IO (Ptr ())

Returns: A pointer to the copy

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

Since: 2.4

dynamic_CopyFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_CopyFunc

-> Ptr ()

src: A pointer to the data which should be copied

-> Ptr ()

data: Additional data

-> m (Ptr ())

Returns: A pointer to the copy

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

genClosure_CopyFunc :: MonadIO m => CopyFunc -> m (GClosure C_CopyFunc)

Wrap the callback into a GClosure.

mk_CopyFunc :: C_CopyFunc -> IO (FunPtr C_CopyFunc)

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

noCopyFunc :: Maybe CopyFunc

A convenience synonym for Nothing :: Maybe CopyFunc.

wrap_CopyFunc :: Maybe (Ptr (FunPtr C_CopyFunc)) -> CopyFunc -> C_CopyFunc

Wrap a CopyFunc into a C_CopyFunc.

DataForeachFunc

type C_DataForeachFunc = Word32 -> Ptr () -> Ptr () -> IO ()

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

type DataForeachFunc

Arguments

 = Word32

keyId: the GQuark id to identifying the data element.

-> Ptr ()

data: the data element.

-> IO ()

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.

type DataForeachFunc_WithClosures

Arguments

 = Word32

keyId: the GQuark id to identifying the data element.

-> Ptr ()

data: the data element.

-> Ptr ()

userData: user data passed to datasetForeach.

-> IO ()

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.

drop_closures_DataForeachFunc :: DataForeachFunc -> DataForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_DataForeachFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_DataForeachFunc

-> Word32

keyId: the GQuark id to identifying the data element.

-> Ptr ()

data: the data element.

-> Ptr ()

userData: user data passed to datasetForeach.

-> m ()

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

genClosure_DataForeachFunc :: MonadIO m => DataForeachFunc -> m (GClosure C_DataForeachFunc)

Wrap the callback into a GClosure.

mk_DataForeachFunc :: C_DataForeachFunc -> IO (FunPtr C_DataForeachFunc)

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

noDataForeachFunc :: Maybe DataForeachFunc

A convenience synonym for Nothing :: Maybe DataForeachFunc.

noDataForeachFunc_WithClosures :: Maybe DataForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe DataForeachFunc_WithClosures.

wrap_DataForeachFunc :: Maybe (Ptr (FunPtr C_DataForeachFunc)) -> DataForeachFunc_WithClosures -> C_DataForeachFunc

Wrap a DataForeachFunc into a C_DataForeachFunc.

DestroyNotify

type C_DestroyNotify = Ptr () -> IO ()

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

type DestroyNotify

Arguments

 = Ptr ()

data: the data element.

-> IO ()

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.

dynamic_DestroyNotify

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_DestroyNotify

-> Ptr ()

data: the data element.

-> m ()

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

genClosure_DestroyNotify :: MonadIO m => DestroyNotify -> m (GClosure C_DestroyNotify)

Wrap the callback into a GClosure.

mk_DestroyNotify :: C_DestroyNotify -> IO (FunPtr C_DestroyNotify)

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

noDestroyNotify :: Maybe DestroyNotify

A convenience synonym for Nothing :: Maybe DestroyNotify.

wrap_DestroyNotify :: Maybe (Ptr (FunPtr C_DestroyNotify)) -> DestroyNotify -> C_DestroyNotify

Wrap a DestroyNotify into a C_DestroyNotify.

DuplicateFunc

type C_DuplicateFunc = Ptr () -> Ptr () -> IO (Ptr ())

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

type DuplicateFunc

Arguments

 = Ptr ()

data: the data to duplicate

-> IO (Ptr ())

Returns: a duplicate of data

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.

type DuplicateFunc_WithClosures

Arguments

 = Ptr ()

data: the data to duplicate

-> Ptr ()

userData: user data that was specified in g_datalist_id_dup_data()

-> IO (Ptr ())

Returns: a duplicate of data

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.

drop_closures_DuplicateFunc :: DuplicateFunc -> DuplicateFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_DuplicateFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_DuplicateFunc

-> Ptr ()

data: the data to duplicate

-> Ptr ()

userData: user data that was specified in g_datalist_id_dup_data()

-> m (Ptr ())

Returns: a duplicate of data

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

genClosure_DuplicateFunc :: MonadIO m => DuplicateFunc -> m (GClosure C_DuplicateFunc)

Wrap the callback into a GClosure.

mk_DuplicateFunc :: C_DuplicateFunc -> IO (FunPtr C_DuplicateFunc)

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

noDuplicateFunc :: Maybe DuplicateFunc

A convenience synonym for Nothing :: Maybe DuplicateFunc.

noDuplicateFunc_WithClosures :: Maybe DuplicateFunc_WithClosures

A convenience synonym for Nothing :: Maybe DuplicateFunc_WithClosures.

wrap_DuplicateFunc :: Maybe (Ptr (FunPtr C_DuplicateFunc)) -> DuplicateFunc_WithClosures -> C_DuplicateFunc

Wrap a DuplicateFunc into a C_DuplicateFunc.

EqualFunc

type C_EqualFunc = Ptr () -> Ptr () -> IO CInt

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

type EqualFunc

Arguments

 = Ptr ()

a: a value

-> Ptr ()

b: a value to compare with

-> IO Bool

Returns: True if a = b; False otherwise

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.

dynamic_EqualFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_EqualFunc

-> Ptr ()

a: a value

-> Ptr ()

b: a value to compare with

-> m Bool

Returns: True if a = b; False otherwise

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

genClosure_EqualFunc :: MonadIO m => EqualFunc -> m (GClosure C_EqualFunc)

Wrap the callback into a GClosure.

mk_EqualFunc :: C_EqualFunc -> IO (FunPtr C_EqualFunc)

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

noEqualFunc :: Maybe EqualFunc

A convenience synonym for Nothing :: Maybe EqualFunc.

wrap_EqualFunc :: Maybe (Ptr (FunPtr C_EqualFunc)) -> EqualFunc -> C_EqualFunc

Wrap a EqualFunc into a C_EqualFunc.

FreeFunc

type C_FreeFunc = Ptr () -> IO ()

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

type FreeFunc

Arguments

 = Ptr ()

data: a data pointer

-> IO ()

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

dynamic_FreeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_FreeFunc

-> Ptr ()

data: a data pointer

-> m ()

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

genClosure_FreeFunc :: MonadIO m => FreeFunc -> m (GClosure C_FreeFunc)

Wrap the callback into a GClosure.

mk_FreeFunc :: C_FreeFunc -> IO (FunPtr C_FreeFunc)

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

noFreeFunc :: Maybe FreeFunc

A convenience synonym for Nothing :: Maybe FreeFunc.

wrap_FreeFunc :: Maybe (Ptr (FunPtr C_FreeFunc)) -> FreeFunc -> C_FreeFunc

Wrap a FreeFunc into a C_FreeFunc.

Func

type C_Func = Ptr () -> Ptr () -> IO ()

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

type Func

Arguments

 = Ptr ()

data: the element's data

-> IO ()

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

type Func_WithClosures

Arguments

 = Ptr ()

data: the element's data

-> Ptr ()

userData: user data passed to g_list_foreach() or g_slist_foreach()

-> IO ()

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

drop_closures_Func :: Func -> Func_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_Func

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_Func

-> Ptr ()

data: the element's data

-> Ptr ()

userData: user data passed to g_list_foreach() or g_slist_foreach()

-> m ()

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

genClosure_Func :: MonadIO m => Func -> m (GClosure C_Func)

Wrap the callback into a GClosure.

mk_Func :: C_Func -> IO (FunPtr C_Func)

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

noFunc :: Maybe Func

A convenience synonym for Nothing :: Maybe Func.

noFunc_WithClosures :: Maybe Func_WithClosures

A convenience synonym for Nothing :: Maybe Func_WithClosures.

wrap_Func :: Maybe (Ptr (FunPtr C_Func)) -> Func_WithClosures -> C_Func

Wrap a Func into a C_Func.

HFunc

type C_HFunc = Ptr () -> Ptr () -> Ptr () -> IO ()

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

type HFunc

Arguments

 = Ptr ()

key: a key

-> Ptr ()

value: the value corresponding to the key

-> IO ()

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

type HFunc_WithClosures

Arguments

 = Ptr ()

key: a key

-> Ptr ()

value: the value corresponding to the key

-> Ptr ()

userData: user data passed to g_hash_table_foreach()

-> IO ()

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

drop_closures_HFunc :: HFunc -> HFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_HFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HFunc

-> Ptr ()

key: a key

-> Ptr ()

value: the value corresponding to the key

-> Ptr ()

userData: user data passed to g_hash_table_foreach()

-> m ()

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

genClosure_HFunc :: MonadIO m => HFunc -> m (GClosure C_HFunc)

Wrap the callback into a GClosure.

mk_HFunc :: C_HFunc -> IO (FunPtr C_HFunc)

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

noHFunc :: Maybe HFunc

A convenience synonym for Nothing :: Maybe HFunc.

noHFunc_WithClosures :: Maybe HFunc_WithClosures

A convenience synonym for Nothing :: Maybe HFunc_WithClosures.

wrap_HFunc :: Maybe (Ptr (FunPtr C_HFunc)) -> HFunc_WithClosures -> C_HFunc

Wrap a HFunc into a C_HFunc.

HRFunc

type C_HRFunc = Ptr () -> Ptr () -> Ptr () -> IO CInt

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

type HRFunc

Arguments

 = Ptr ()

key: a key

-> Ptr ()

value: the value associated with the key

-> IO Bool

Returns: 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.

type HRFunc_WithClosures

Arguments

 = Ptr ()

key: a key

-> Ptr ()

value: the value associated with the key

-> Ptr ()

userData: user data passed to hashTableRemove

-> IO Bool

Returns: 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.

drop_closures_HRFunc :: HRFunc -> HRFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_HRFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HRFunc

-> Ptr ()

key: a key

-> Ptr ()

value: the value associated with the key

-> Ptr ()

userData: user data passed to hashTableRemove

-> m Bool

Returns: True if the key/value pair should be removed from the HashTable

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

genClosure_HRFunc :: MonadIO m => HRFunc -> m (GClosure C_HRFunc)

Wrap the callback into a GClosure.

mk_HRFunc :: C_HRFunc -> IO (FunPtr C_HRFunc)

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

noHRFunc :: Maybe HRFunc

A convenience synonym for Nothing :: Maybe HRFunc.

noHRFunc_WithClosures :: Maybe HRFunc_WithClosures

A convenience synonym for Nothing :: Maybe HRFunc_WithClosures.

wrap_HRFunc :: Maybe (Ptr (FunPtr C_HRFunc)) -> HRFunc_WithClosures -> C_HRFunc

Wrap a HRFunc into a C_HRFunc.

HashFunc

type C_HashFunc = Ptr () -> IO Word32

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

type HashFunc

Arguments

 = Ptr ()

key: a key

-> IO Word32

Returns: the hash value corresponding to the key

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.

dynamic_HashFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HashFunc

-> Ptr ()

key: a key

-> m Word32

Returns: the hash value corresponding to the key

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

genClosure_HashFunc :: MonadIO m => HashFunc -> m (GClosure C_HashFunc)

Wrap the callback into a GClosure.

mk_HashFunc :: C_HashFunc -> IO (FunPtr C_HashFunc)

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

noHashFunc :: Maybe HashFunc

A convenience synonym for Nothing :: Maybe HashFunc.

wrap_HashFunc :: Maybe (Ptr (FunPtr C_HashFunc)) -> HashFunc -> C_HashFunc

Wrap a HashFunc into a C_HashFunc.

HookCheckFunc

type C_HookCheckFunc = Ptr () -> IO CInt

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

type HookCheckFunc

Arguments

 = Ptr ()

data: the data field of the Hook is passed to the hook function here

-> IO Bool

Returns: False if the Hook should be destroyed

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

dynamic_HookCheckFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HookCheckFunc

-> Ptr ()

data: the data field of the Hook is passed to the hook function here

-> m Bool

Returns: False if the Hook should be destroyed

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

genClosure_HookCheckFunc :: MonadIO m => HookCheckFunc -> m (GClosure C_HookCheckFunc)

Wrap the callback into a GClosure.

mk_HookCheckFunc :: C_HookCheckFunc -> IO (FunPtr C_HookCheckFunc)

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

noHookCheckFunc :: Maybe HookCheckFunc

A convenience synonym for Nothing :: Maybe HookCheckFunc.

wrap_HookCheckFunc :: Maybe (Ptr (FunPtr C_HookCheckFunc)) -> HookCheckFunc -> C_HookCheckFunc

Wrap a HookCheckFunc into a C_HookCheckFunc.

HookCheckMarshaller

type C_HookCheckMarshaller = Ptr Hook -> Ptr () -> IO CInt

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

type HookCheckMarshaller

Arguments

 = Hook

hook: a Hook

-> Ptr ()

marshalData: user data

-> IO Bool

Returns: False if hook should be destroyed

Defines the type of function used by g_hook_list_marshal_check().

dynamic_HookCheckMarshaller

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HookCheckMarshaller

-> Hook

hook: a Hook

-> Ptr ()

marshalData: user data

-> m Bool

Returns: False if hook should be destroyed

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

genClosure_HookCheckMarshaller :: MonadIO m => HookCheckMarshaller -> m (GClosure C_HookCheckMarshaller)

Wrap the callback into a GClosure.

mk_HookCheckMarshaller :: C_HookCheckMarshaller -> IO (FunPtr C_HookCheckMarshaller)

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

noHookCheckMarshaller :: Maybe HookCheckMarshaller

A convenience synonym for Nothing :: Maybe HookCheckMarshaller.

wrap_HookCheckMarshaller :: Maybe (Ptr (FunPtr C_HookCheckMarshaller)) -> HookCheckMarshaller -> C_HookCheckMarshaller

Wrap a HookCheckMarshaller into a C_HookCheckMarshaller.

HookCompareFunc

type C_HookCompareFunc = Ptr Hook -> Ptr Hook -> IO Int32

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

type HookCompareFunc

Arguments

 = Hook

newHook: the Hook being inserted

-> Hook

sibling: the Hook to compare with newHook

-> IO Int32

Returns: a value <= 0 if newHook should be before sibling

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

dynamic_HookCompareFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HookCompareFunc

-> Hook

newHook: the Hook being inserted

-> Hook

sibling: the Hook to compare with newHook

-> m Int32

Returns: a value <= 0 if newHook should be before sibling

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

genClosure_HookCompareFunc :: MonadIO m => HookCompareFunc -> m (GClosure C_HookCompareFunc)

Wrap the callback into a GClosure.

mk_HookCompareFunc :: C_HookCompareFunc -> IO (FunPtr C_HookCompareFunc)

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

noHookCompareFunc :: Maybe HookCompareFunc

A convenience synonym for Nothing :: Maybe HookCompareFunc.

wrap_HookCompareFunc :: Maybe (Ptr (FunPtr C_HookCompareFunc)) -> HookCompareFunc -> C_HookCompareFunc

Wrap a HookCompareFunc into a C_HookCompareFunc.

HookFinalizeFunc

type C_HookFinalizeFunc = Ptr HookList -> Ptr Hook -> IO ()

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

type HookFinalizeFunc

Arguments

 = HookList

hookList: a HookList

-> Hook

hook: the hook in hookList that gets finalized

-> IO ()

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

dynamic_HookFinalizeFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HookFinalizeFunc

-> HookList

hookList: a HookList

-> Hook

hook: the hook in hookList that gets finalized

-> m ()

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

genClosure_HookFinalizeFunc :: MonadIO m => HookFinalizeFunc -> m (GClosure C_HookFinalizeFunc)

Wrap the callback into a GClosure.

mk_HookFinalizeFunc :: C_HookFinalizeFunc -> IO (FunPtr C_HookFinalizeFunc)

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

noHookFinalizeFunc :: Maybe HookFinalizeFunc

A convenience synonym for Nothing :: Maybe HookFinalizeFunc.

wrap_HookFinalizeFunc :: Maybe (Ptr (FunPtr C_HookFinalizeFunc)) -> HookFinalizeFunc -> C_HookFinalizeFunc

Wrap a HookFinalizeFunc into a C_HookFinalizeFunc.

HookFindFunc

type C_HookFindFunc = Ptr Hook -> Ptr () -> IO CInt

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

type HookFindFunc

Arguments

 = Hook

hook: a Hook

-> Ptr ()

data: user data passed to g_hook_find_func()

-> IO Bool

Returns: True if the required Hook has been found

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

dynamic_HookFindFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HookFindFunc

-> Hook

hook: a Hook

-> Ptr ()

data: user data passed to g_hook_find_func()

-> m Bool

Returns: True if the required Hook has been found

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

genClosure_HookFindFunc :: MonadIO m => HookFindFunc -> m (GClosure C_HookFindFunc)

Wrap the callback into a GClosure.

mk_HookFindFunc :: C_HookFindFunc -> IO (FunPtr C_HookFindFunc)

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

noHookFindFunc :: Maybe HookFindFunc

A convenience synonym for Nothing :: Maybe HookFindFunc.

wrap_HookFindFunc :: Maybe (Ptr (FunPtr C_HookFindFunc)) -> HookFindFunc -> C_HookFindFunc

Wrap a HookFindFunc into a C_HookFindFunc.

HookFunc

type C_HookFunc = Ptr () -> IO ()

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

type HookFunc

Arguments

 = Ptr ()

data: the data field of the Hook is passed to the hook function here

-> IO ()

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

dynamic_HookFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HookFunc

-> Ptr ()

data: the data field of the Hook is passed to the hook function here

-> m ()

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

genClosure_HookFunc :: MonadIO m => HookFunc -> m (GClosure C_HookFunc)

Wrap the callback into a GClosure.

mk_HookFunc :: C_HookFunc -> IO (FunPtr C_HookFunc)

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

noHookFunc :: Maybe HookFunc

A convenience synonym for Nothing :: Maybe HookFunc.

wrap_HookFunc :: Maybe (Ptr (FunPtr C_HookFunc)) -> HookFunc -> C_HookFunc

Wrap a HookFunc into a C_HookFunc.

HookMarshaller

type C_HookMarshaller = Ptr Hook -> Ptr () -> IO ()

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

type HookMarshaller

Arguments

 = Hook

hook: a Hook

-> Ptr ()

marshalData: user data

-> IO ()

Defines the type of function used by g_hook_list_marshal().

dynamic_HookMarshaller

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_HookMarshaller

-> Hook

hook: a Hook

-> Ptr ()

marshalData: user data

-> m ()

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

genClosure_HookMarshaller :: MonadIO m => HookMarshaller -> m (GClosure C_HookMarshaller)

Wrap the callback into a GClosure.

mk_HookMarshaller :: C_HookMarshaller -> IO (FunPtr C_HookMarshaller)

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

noHookMarshaller :: Maybe HookMarshaller

A convenience synonym for Nothing :: Maybe HookMarshaller.

wrap_HookMarshaller :: Maybe (Ptr (FunPtr C_HookMarshaller)) -> HookMarshaller -> C_HookMarshaller

Wrap a HookMarshaller into a C_HookMarshaller.

IOFunc

type C_IOFunc = Ptr IOChannel -> CUInt -> Ptr () -> IO CInt

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

type IOFunc

Arguments

 = IOChannel

source: the IOChannel event source

-> [IOCondition]

condition: the condition which has been satisfied

-> Ptr ()

data: user data set in g_io_add_watch() or ioAddWatch

-> IO Bool

Returns: the function should return False if the event source should be removed

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.

dynamic_IOFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IOFunc

-> IOChannel

source: the IOChannel event source

-> [IOCondition]

condition: the condition which has been satisfied

-> Ptr ()

data: user data set in g_io_add_watch() or ioAddWatch

-> m Bool

Returns: the function should return False if the event source should be removed

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

genClosure_IOFunc :: MonadIO m => IOFunc -> m (GClosure C_IOFunc)

Wrap the callback into a GClosure.

mk_IOFunc :: C_IOFunc -> IO (FunPtr C_IOFunc)

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

noIOFunc :: Maybe IOFunc

A convenience synonym for Nothing :: Maybe IOFunc.

wrap_IOFunc :: Maybe (Ptr (FunPtr C_IOFunc)) -> IOFunc -> C_IOFunc

Wrap a IOFunc into a C_IOFunc.

IOFuncsIoCloseFieldCallback

type C_IOFuncsIoCloseFieldCallback = Ptr IOChannel -> Ptr (Ptr GError) -> IO CUInt

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

type IOFuncsIoCloseFieldCallback

Arguments

 = IOChannel

-> IO IOStatus

(Can throw GError)

No description available in the introspection data.

dynamic_IOFuncsIoCloseFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IOFuncsIoCloseFieldCallback

-> IOChannel

-> m IOStatus

(Can throw GError)

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

mk_IOFuncsIoCloseFieldCallback :: C_IOFuncsIoCloseFieldCallback -> IO (FunPtr C_IOFuncsIoCloseFieldCallback)

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

noIOFuncsIoCloseFieldCallback :: Maybe IOFuncsIoCloseFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoCloseFieldCallback.

IOFuncsIoCreateWatchFieldCallback

type C_IOFuncsIoCreateWatchFieldCallback = Ptr IOChannel -> CUInt -> IO (Ptr Source)

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

type IOFuncsIoCreateWatchFieldCallback = IOChannel -> [IOCondition] -> IO Source

No description available in the introspection data.

dynamic_IOFuncsIoCreateWatchFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoCreateWatchFieldCallback -> IOChannel -> [IOCondition] -> m Source

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

genClosure_IOFuncsIoCreateWatchFieldCallback :: MonadIO m => IOFuncsIoCreateWatchFieldCallback -> m (GClosure C_IOFuncsIoCreateWatchFieldCallback)

Wrap the callback into a GClosure.

mk_IOFuncsIoCreateWatchFieldCallback :: C_IOFuncsIoCreateWatchFieldCallback -> IO (FunPtr C_IOFuncsIoCreateWatchFieldCallback)

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

noIOFuncsIoCreateWatchFieldCallback :: Maybe IOFuncsIoCreateWatchFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoCreateWatchFieldCallback.

wrap_IOFuncsIoCreateWatchFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)) -> IOFuncsIoCreateWatchFieldCallback -> C_IOFuncsIoCreateWatchFieldCallback

Wrap a IOFuncsIoCreateWatchFieldCallback into a C_IOFuncsIoCreateWatchFieldCallback.

IOFuncsIoFreeFieldCallback

type C_IOFuncsIoFreeFieldCallback = Ptr IOChannel -> IO ()

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

type IOFuncsIoFreeFieldCallback = IOChannel -> IO ()

No description available in the introspection data.

dynamic_IOFuncsIoFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoFreeFieldCallback -> IOChannel -> m ()

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

genClosure_IOFuncsIoFreeFieldCallback :: MonadIO m => IOFuncsIoFreeFieldCallback -> m (GClosure C_IOFuncsIoFreeFieldCallback)

Wrap the callback into a GClosure.

mk_IOFuncsIoFreeFieldCallback :: C_IOFuncsIoFreeFieldCallback -> IO (FunPtr C_IOFuncsIoFreeFieldCallback)

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

noIOFuncsIoFreeFieldCallback :: Maybe IOFuncsIoFreeFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoFreeFieldCallback.

wrap_IOFuncsIoFreeFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)) -> IOFuncsIoFreeFieldCallback -> C_IOFuncsIoFreeFieldCallback

Wrap a IOFuncsIoFreeFieldCallback into a C_IOFuncsIoFreeFieldCallback.

IOFuncsIoGetFlagsFieldCallback

type C_IOFuncsIoGetFlagsFieldCallback = Ptr IOChannel -> IO CUInt

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

type IOFuncsIoGetFlagsFieldCallback = IOChannel -> IO [IOFlags]

No description available in the introspection data.

dynamic_IOFuncsIoGetFlagsFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_IOFuncsIoGetFlagsFieldCallback -> IOChannel -> m [IOFlags]

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

genClosure_IOFuncsIoGetFlagsFieldCallback :: MonadIO m => IOFuncsIoGetFlagsFieldCallback -> m (GClosure C_IOFuncsIoGetFlagsFieldCallback)

Wrap the callback into a GClosure.

mk_IOFuncsIoGetFlagsFieldCallback :: C_IOFuncsIoGetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoGetFlagsFieldCallback)

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

noIOFuncsIoGetFlagsFieldCallback :: Maybe IOFuncsIoGetFlagsFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoGetFlagsFieldCallback.

wrap_IOFuncsIoGetFlagsFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)) -> IOFuncsIoGetFlagsFieldCallback -> C_IOFuncsIoGetFlagsFieldCallback

Wrap a IOFuncsIoGetFlagsFieldCallback into a C_IOFuncsIoGetFlagsFieldCallback.

IOFuncsIoReadFieldCallback

type C_IOFuncsIoReadFieldCallback = Ptr IOChannel -> CString -> Word64 -> Word64 -> Ptr (Ptr GError) -> IO CUInt

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

type IOFuncsIoReadFieldCallback

Arguments

 = IOChannel

-> Text

-> Word64

-> Word64

-> IO IOStatus

(Can throw GError)

No description available in the introspection data.

dynamic_IOFuncsIoReadFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IOFuncsIoReadFieldCallback

-> IOChannel

-> Text

-> Word64

-> Word64

-> m IOStatus

(Can throw GError)

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

mk_IOFuncsIoReadFieldCallback :: C_IOFuncsIoReadFieldCallback -> IO (FunPtr C_IOFuncsIoReadFieldCallback)

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

noIOFuncsIoReadFieldCallback :: Maybe IOFuncsIoReadFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoReadFieldCallback.

IOFuncsIoSeekFieldCallback

type C_IOFuncsIoSeekFieldCallback = Ptr IOChannel -> Int64 -> CUInt -> Ptr (Ptr GError) -> IO CUInt

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

type IOFuncsIoSeekFieldCallback

Arguments

 = IOChannel

-> Int64

-> SeekType

-> IO IOStatus

(Can throw GError)

No description available in the introspection data.

dynamic_IOFuncsIoSeekFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IOFuncsIoSeekFieldCallback

-> IOChannel

-> Int64

-> SeekType

-> m IOStatus

(Can throw GError)

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

mk_IOFuncsIoSeekFieldCallback :: C_IOFuncsIoSeekFieldCallback -> IO (FunPtr C_IOFuncsIoSeekFieldCallback)

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

noIOFuncsIoSeekFieldCallback :: Maybe IOFuncsIoSeekFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoSeekFieldCallback.

IOFuncsIoSetFlagsFieldCallback

type C_IOFuncsIoSetFlagsFieldCallback = Ptr IOChannel -> CUInt -> Ptr (Ptr GError) -> IO CUInt

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

type IOFuncsIoSetFlagsFieldCallback

Arguments

 = IOChannel

-> [IOFlags]

-> IO IOStatus

(Can throw GError)

No description available in the introspection data.

dynamic_IOFuncsIoSetFlagsFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IOFuncsIoSetFlagsFieldCallback

-> IOChannel

-> [IOFlags]

-> m IOStatus

(Can throw GError)

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

mk_IOFuncsIoSetFlagsFieldCallback :: C_IOFuncsIoSetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoSetFlagsFieldCallback)

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

noIOFuncsIoSetFlagsFieldCallback :: Maybe IOFuncsIoSetFlagsFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoSetFlagsFieldCallback.

IOFuncsIoWriteFieldCallback

type C_IOFuncsIoWriteFieldCallback = Ptr IOChannel -> CString -> Word64 -> Word64 -> Ptr (Ptr GError) -> IO CUInt

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

type IOFuncsIoWriteFieldCallback

Arguments

 = IOChannel

-> Text

-> Word64

-> Word64

-> IO IOStatus

(Can throw GError)

No description available in the introspection data.

dynamic_IOFuncsIoWriteFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_IOFuncsIoWriteFieldCallback

-> IOChannel

-> Text

-> Word64

-> Word64

-> m IOStatus

(Can throw GError)

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

mk_IOFuncsIoWriteFieldCallback :: C_IOFuncsIoWriteFieldCallback -> IO (FunPtr C_IOFuncsIoWriteFieldCallback)

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

noIOFuncsIoWriteFieldCallback :: Maybe IOFuncsIoWriteFieldCallback

A convenience synonym for Nothing :: Maybe IOFuncsIoWriteFieldCallback.

LogFunc

type C_LogFunc = CString -> CInt -> CString -> Ptr () -> IO ()

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

type LogFunc

Arguments

 = Text

logDomain: the log domain of the message

-> [LogLevelFlags]

logLevel: the log level of the message (including the fatal and recursion flags)

-> Text

message: the message to process

-> IO ()

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

type LogFunc_WithClosures

Arguments

 = Text

logDomain: the log domain of the message

-> [LogLevelFlags]

logLevel: the log level of the message (including the fatal and recursion flags)

-> Text

message: the message to process

-> Ptr ()

userData: user data, set in g_log_set_handler()

-> IO ()

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

drop_closures_LogFunc :: LogFunc -> LogFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_LogFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_LogFunc

-> Text

logDomain: the log domain of the message

-> [LogLevelFlags]

logLevel: the log level of the message (including the fatal and recursion flags)

-> Text

message: the message to process

-> Ptr ()

userData: user data, set in g_log_set_handler()

-> m ()

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

genClosure_LogFunc :: MonadIO m => LogFunc -> m (GClosure C_LogFunc)

Wrap the callback into a GClosure.

mk_LogFunc :: C_LogFunc -> IO (FunPtr C_LogFunc)

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

noLogFunc :: Maybe LogFunc

A convenience synonym for Nothing :: Maybe LogFunc.

noLogFunc_WithClosures :: Maybe LogFunc_WithClosures

A convenience synonym for Nothing :: Maybe LogFunc_WithClosures.

wrap_LogFunc :: Maybe (Ptr (FunPtr C_LogFunc)) -> LogFunc_WithClosures -> C_LogFunc

Wrap a LogFunc into a C_LogFunc.

LogWriterFunc

type C_LogWriterFunc = CInt -> Ptr LogField -> Word64 -> Ptr () -> IO CUInt

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

type LogWriterFunc

Arguments

 = [LogLevelFlags]

logLevel: log level of the message

-> [LogField]

fields: fields forming the message

-> IO LogWriterOutput

Returns: LogWriterOutputHandled if the log entry was handled successfully; LogWriterOutputUnhandled otherwise

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

type LogWriterFunc_WithClosures

Arguments

 = [LogLevelFlags]

logLevel: log level of the message

-> [LogField]

fields: fields forming the message

-> Ptr ()

userData: user data passed to logSetWriterFunc

-> IO LogWriterOutput

Returns: LogWriterOutputHandled if the log entry was handled successfully; LogWriterOutputUnhandled otherwise

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

drop_closures_LogWriterFunc :: LogWriterFunc -> LogWriterFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_LogWriterFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_LogWriterFunc

-> [LogLevelFlags]

logLevel: log level of the message

-> [LogField]

fields: fields forming the message

-> Ptr ()

userData: user data passed to logSetWriterFunc

-> m LogWriterOutput

Returns: LogWriterOutputHandled if the log entry was handled successfully; LogWriterOutputUnhandled otherwise

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

genClosure_LogWriterFunc :: MonadIO m => LogWriterFunc -> m (GClosure C_LogWriterFunc)

Wrap the callback into a GClosure.

mk_LogWriterFunc :: C_LogWriterFunc -> IO (FunPtr C_LogWriterFunc)

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

noLogWriterFunc :: Maybe LogWriterFunc

A convenience synonym for Nothing :: Maybe LogWriterFunc.

noLogWriterFunc_WithClosures :: Maybe LogWriterFunc_WithClosures

A convenience synonym for Nothing :: Maybe LogWriterFunc_WithClosures.

wrap_LogWriterFunc :: Maybe (Ptr (FunPtr C_LogWriterFunc)) -> LogWriterFunc_WithClosures -> C_LogWriterFunc

Wrap a LogWriterFunc into a C_LogWriterFunc.

MarkupParserEndElementFieldCallback

type C_MarkupParserEndElementFieldCallback = Ptr MarkupParseContext -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

type MarkupParserEndElementFieldCallback

Arguments

 = MarkupParseContext

-> Text

-> IO ()

(Can throw GError)

No description available in the introspection data.

type MarkupParserEndElementFieldCallback_WithClosures

Arguments

 = MarkupParseContext

-> Text

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

drop_closures_MarkupParserEndElementFieldCallback :: MarkupParserEndElementFieldCallback -> MarkupParserEndElementFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserEndElementFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MarkupParserEndElementFieldCallback

-> MarkupParseContext

-> Text

-> Ptr ()

-> m ()

(Can throw GError)

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

mk_MarkupParserEndElementFieldCallback :: C_MarkupParserEndElementFieldCallback -> IO (FunPtr C_MarkupParserEndElementFieldCallback)

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

noMarkupParserEndElementFieldCallback :: Maybe MarkupParserEndElementFieldCallback

A convenience synonym for Nothing :: Maybe MarkupParserEndElementFieldCallback.

noMarkupParserEndElementFieldCallback_WithClosures :: Maybe MarkupParserEndElementFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe MarkupParserEndElementFieldCallback_WithClosures.

MarkupParserErrorFieldCallback

type C_MarkupParserErrorFieldCallback = Ptr MarkupParseContext -> Ptr GError -> Ptr () -> IO ()

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

type MarkupParserErrorFieldCallback = MarkupParseContext -> GError -> IO ()

No description available in the introspection data.

type MarkupParserErrorFieldCallback_WithClosures = MarkupParseContext -> GError -> Ptr () -> IO ()

No description available in the introspection data.

drop_closures_MarkupParserErrorFieldCallback :: MarkupParserErrorFieldCallback -> MarkupParserErrorFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserErrorFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MarkupParserErrorFieldCallback -> MarkupParseContext -> GError -> Ptr () -> m ()

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

genClosure_MarkupParserErrorFieldCallback :: MonadIO m => MarkupParserErrorFieldCallback -> m (GClosure C_MarkupParserErrorFieldCallback)

Wrap the callback into a GClosure.

mk_MarkupParserErrorFieldCallback :: C_MarkupParserErrorFieldCallback -> IO (FunPtr C_MarkupParserErrorFieldCallback)

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

noMarkupParserErrorFieldCallback :: Maybe MarkupParserErrorFieldCallback

A convenience synonym for Nothing :: Maybe MarkupParserErrorFieldCallback.

noMarkupParserErrorFieldCallback_WithClosures :: Maybe MarkupParserErrorFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe MarkupParserErrorFieldCallback_WithClosures.

wrap_MarkupParserErrorFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserErrorFieldCallback)) -> MarkupParserErrorFieldCallback_WithClosures -> C_MarkupParserErrorFieldCallback

Wrap a MarkupParserErrorFieldCallback into a C_MarkupParserErrorFieldCallback.

MarkupParserPassthroughFieldCallback

type C_MarkupParserPassthroughFieldCallback = Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

type MarkupParserPassthroughFieldCallback

Arguments

 = MarkupParseContext

-> Text

-> Word64

-> IO ()

(Can throw GError)

No description available in the introspection data.

type MarkupParserPassthroughFieldCallback_WithClosures

Arguments

 = MarkupParseContext

-> Text

-> Word64

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

drop_closures_MarkupParserPassthroughFieldCallback :: MarkupParserPassthroughFieldCallback -> MarkupParserPassthroughFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserPassthroughFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MarkupParserPassthroughFieldCallback

-> MarkupParseContext

-> Text

-> Word64

-> Ptr ()

-> m ()

(Can throw GError)

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

mk_MarkupParserPassthroughFieldCallback :: C_MarkupParserPassthroughFieldCallback -> IO (FunPtr C_MarkupParserPassthroughFieldCallback)

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

noMarkupParserPassthroughFieldCallback :: Maybe MarkupParserPassthroughFieldCallback

A convenience synonym for Nothing :: Maybe MarkupParserPassthroughFieldCallback.

noMarkupParserPassthroughFieldCallback_WithClosures :: Maybe MarkupParserPassthroughFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe MarkupParserPassthroughFieldCallback_WithClosures.

MarkupParserStartElementFieldCallback

type C_MarkupParserStartElementFieldCallback = Ptr MarkupParseContext -> CString -> CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

type MarkupParserStartElementFieldCallback

Arguments

 = MarkupParseContext

-> Text

-> Text

-> Text

-> IO ()

(Can throw GError)

No description available in the introspection data.

type MarkupParserStartElementFieldCallback_WithClosures

Arguments

 = MarkupParseContext

-> Text

-> Text

-> Text

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

drop_closures_MarkupParserStartElementFieldCallback :: MarkupParserStartElementFieldCallback -> MarkupParserStartElementFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserStartElementFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MarkupParserStartElementFieldCallback

-> MarkupParseContext

-> Text

-> Text

-> Text

-> Ptr ()

-> m ()

(Can throw GError)

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

mk_MarkupParserStartElementFieldCallback :: C_MarkupParserStartElementFieldCallback -> IO (FunPtr C_MarkupParserStartElementFieldCallback)

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

noMarkupParserStartElementFieldCallback :: Maybe MarkupParserStartElementFieldCallback

A convenience synonym for Nothing :: Maybe MarkupParserStartElementFieldCallback.

noMarkupParserStartElementFieldCallback_WithClosures :: Maybe MarkupParserStartElementFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe MarkupParserStartElementFieldCallback_WithClosures.

MarkupParserTextFieldCallback

type C_MarkupParserTextFieldCallback = Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

type MarkupParserTextFieldCallback

Arguments

 = MarkupParseContext

-> Text

-> Word64

-> IO ()

(Can throw GError)

No description available in the introspection data.

type MarkupParserTextFieldCallback_WithClosures

Arguments

 = MarkupParseContext

-> Text

-> Word64

-> Ptr ()

-> IO ()

(Can throw GError)

No description available in the introspection data.

drop_closures_MarkupParserTextFieldCallback :: MarkupParserTextFieldCallback -> MarkupParserTextFieldCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MarkupParserTextFieldCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MarkupParserTextFieldCallback

-> MarkupParseContext

-> Text

-> Word64

-> Ptr ()

-> m ()

(Can throw GError)

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

mk_MarkupParserTextFieldCallback :: C_MarkupParserTextFieldCallback -> IO (FunPtr C_MarkupParserTextFieldCallback)

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

noMarkupParserTextFieldCallback :: Maybe MarkupParserTextFieldCallback

A convenience synonym for Nothing :: Maybe MarkupParserTextFieldCallback.

noMarkupParserTextFieldCallback_WithClosures :: Maybe MarkupParserTextFieldCallback_WithClosures

A convenience synonym for Nothing :: Maybe MarkupParserTextFieldCallback_WithClosures.

MemVTableCallocFieldCallback

type C_MemVTableCallocFieldCallback = Word64 -> Word64 -> IO (Ptr ())

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

type MemVTableCallocFieldCallback = Word64 -> Word64 -> IO (Ptr ())

No description available in the introspection data.

dynamic_MemVTableCallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableCallocFieldCallback -> Word64 -> Word64 -> m (Ptr ())

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

genClosure_MemVTableCallocFieldCallback :: MonadIO m => MemVTableCallocFieldCallback -> m (GClosure C_MemVTableCallocFieldCallback)

Wrap the callback into a GClosure.

mk_MemVTableCallocFieldCallback :: C_MemVTableCallocFieldCallback -> IO (FunPtr C_MemVTableCallocFieldCallback)

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

noMemVTableCallocFieldCallback :: Maybe MemVTableCallocFieldCallback

A convenience synonym for Nothing :: Maybe MemVTableCallocFieldCallback.

wrap_MemVTableCallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableCallocFieldCallback)) -> MemVTableCallocFieldCallback -> C_MemVTableCallocFieldCallback

Wrap a MemVTableCallocFieldCallback into a C_MemVTableCallocFieldCallback.

MemVTableFreeFieldCallback

type C_MemVTableFreeFieldCallback = Ptr () -> IO ()

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

type MemVTableFreeFieldCallback = Ptr () -> IO ()

No description available in the introspection data.

dynamic_MemVTableFreeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableFreeFieldCallback -> Ptr () -> m ()

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

genClosure_MemVTableFreeFieldCallback :: MonadIO m => MemVTableFreeFieldCallback -> m (GClosure C_MemVTableFreeFieldCallback)

Wrap the callback into a GClosure.

mk_MemVTableFreeFieldCallback :: C_MemVTableFreeFieldCallback -> IO (FunPtr C_MemVTableFreeFieldCallback)

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

noMemVTableFreeFieldCallback :: Maybe MemVTableFreeFieldCallback

A convenience synonym for Nothing :: Maybe MemVTableFreeFieldCallback.

wrap_MemVTableFreeFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableFreeFieldCallback)) -> MemVTableFreeFieldCallback -> C_MemVTableFreeFieldCallback

Wrap a MemVTableFreeFieldCallback into a C_MemVTableFreeFieldCallback.

MemVTableMallocFieldCallback

type C_MemVTableMallocFieldCallback = Word64 -> IO (Ptr ())

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

type MemVTableMallocFieldCallback = Word64 -> IO (Ptr ())

No description available in the introspection data.

dynamic_MemVTableMallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableMallocFieldCallback -> Word64 -> m (Ptr ())

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

genClosure_MemVTableMallocFieldCallback :: MonadIO m => MemVTableMallocFieldCallback -> m (GClosure C_MemVTableMallocFieldCallback)

Wrap the callback into a GClosure.

mk_MemVTableMallocFieldCallback :: C_MemVTableMallocFieldCallback -> IO (FunPtr C_MemVTableMallocFieldCallback)

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

noMemVTableMallocFieldCallback :: Maybe MemVTableMallocFieldCallback

A convenience synonym for Nothing :: Maybe MemVTableMallocFieldCallback.

wrap_MemVTableMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableMallocFieldCallback)) -> MemVTableMallocFieldCallback -> C_MemVTableMallocFieldCallback

Wrap a MemVTableMallocFieldCallback into a C_MemVTableMallocFieldCallback.

MemVTableReallocFieldCallback

type C_MemVTableReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())

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

type MemVTableReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())

No description available in the introspection data.

dynamic_MemVTableReallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableReallocFieldCallback -> Ptr () -> Word64 -> m (Ptr ())

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

genClosure_MemVTableReallocFieldCallback :: MonadIO m => MemVTableReallocFieldCallback -> m (GClosure C_MemVTableReallocFieldCallback)

Wrap the callback into a GClosure.

mk_MemVTableReallocFieldCallback :: C_MemVTableReallocFieldCallback -> IO (FunPtr C_MemVTableReallocFieldCallback)

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

noMemVTableReallocFieldCallback :: Maybe MemVTableReallocFieldCallback

A convenience synonym for Nothing :: Maybe MemVTableReallocFieldCallback.

wrap_MemVTableReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableReallocFieldCallback)) -> MemVTableReallocFieldCallback -> C_MemVTableReallocFieldCallback

Wrap a MemVTableReallocFieldCallback into a C_MemVTableReallocFieldCallback.

MemVTableTryMallocFieldCallback

type C_MemVTableTryMallocFieldCallback = Word64 -> IO (Ptr ())

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

type MemVTableTryMallocFieldCallback = Word64 -> IO (Ptr ())

No description available in the introspection data.

dynamic_MemVTableTryMallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableTryMallocFieldCallback -> Word64 -> m (Ptr ())

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

genClosure_MemVTableTryMallocFieldCallback :: MonadIO m => MemVTableTryMallocFieldCallback -> m (GClosure C_MemVTableTryMallocFieldCallback)

Wrap the callback into a GClosure.

mk_MemVTableTryMallocFieldCallback :: C_MemVTableTryMallocFieldCallback -> IO (FunPtr C_MemVTableTryMallocFieldCallback)

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

noMemVTableTryMallocFieldCallback :: Maybe MemVTableTryMallocFieldCallback

A convenience synonym for Nothing :: Maybe MemVTableTryMallocFieldCallback.

wrap_MemVTableTryMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryMallocFieldCallback)) -> MemVTableTryMallocFieldCallback -> C_MemVTableTryMallocFieldCallback

Wrap a MemVTableTryMallocFieldCallback into a C_MemVTableTryMallocFieldCallback.

MemVTableTryReallocFieldCallback

type C_MemVTableTryReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())

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

type MemVTableTryReallocFieldCallback = Ptr () -> Word64 -> IO (Ptr ())

No description available in the introspection data.

dynamic_MemVTableTryReallocFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_MemVTableTryReallocFieldCallback -> Ptr () -> Word64 -> m (Ptr ())

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

genClosure_MemVTableTryReallocFieldCallback :: MonadIO m => MemVTableTryReallocFieldCallback -> m (GClosure C_MemVTableTryReallocFieldCallback)

Wrap the callback into a GClosure.

mk_MemVTableTryReallocFieldCallback :: C_MemVTableTryReallocFieldCallback -> IO (FunPtr C_MemVTableTryReallocFieldCallback)

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

noMemVTableTryReallocFieldCallback :: Maybe MemVTableTryReallocFieldCallback

A convenience synonym for Nothing :: Maybe MemVTableTryReallocFieldCallback.

wrap_MemVTableTryReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryReallocFieldCallback)) -> MemVTableTryReallocFieldCallback -> C_MemVTableTryReallocFieldCallback

Wrap a MemVTableTryReallocFieldCallback into a C_MemVTableTryReallocFieldCallback.

NodeForeachFunc

type C_NodeForeachFunc = Ptr Node -> Ptr () -> IO ()

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

type NodeForeachFunc

Arguments

 = Node

node: a Node.

-> Ptr ()

data: user data passed to g_node_children_foreach().

-> IO ()

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

dynamic_NodeForeachFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_NodeForeachFunc

-> Node

node: a Node.

-> Ptr ()

data: user data passed to g_node_children_foreach().

-> m ()

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

genClosure_NodeForeachFunc :: MonadIO m => NodeForeachFunc -> m (GClosure C_NodeForeachFunc)

Wrap the callback into a GClosure.

mk_NodeForeachFunc :: C_NodeForeachFunc -> IO (FunPtr C_NodeForeachFunc)

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

noNodeForeachFunc :: Maybe NodeForeachFunc

A convenience synonym for Nothing :: Maybe NodeForeachFunc.

wrap_NodeForeachFunc :: Maybe (Ptr (FunPtr C_NodeForeachFunc)) -> NodeForeachFunc -> C_NodeForeachFunc

Wrap a NodeForeachFunc into a C_NodeForeachFunc.

NodeTraverseFunc

type C_NodeTraverseFunc = Ptr Node -> Ptr () -> IO CInt

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

type NodeTraverseFunc

Arguments

 = Node

node: a Node.

-> Ptr ()

data: user data passed to g_node_traverse().

-> IO Bool

Returns: True to stop the traversal.

Specifies the type of function passed to g_node_traverse(). The function is called with each of the nodes visited, together with the user data passed to g_node_traverse(). If the function returns True, then the traversal is stopped.

dynamic_NodeTraverseFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_NodeTraverseFunc

-> Node

node: a Node.

-> Ptr ()

data: user data passed to g_node_traverse().

-> m Bool

Returns: True to stop the traversal.

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

genClosure_NodeTraverseFunc :: MonadIO m => NodeTraverseFunc -> m (GClosure C_NodeTraverseFunc)

Wrap the callback into a GClosure.

mk_NodeTraverseFunc :: C_NodeTraverseFunc -> IO (FunPtr C_NodeTraverseFunc)

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

noNodeTraverseFunc :: Maybe NodeTraverseFunc

A convenience synonym for Nothing :: Maybe NodeTraverseFunc.

wrap_NodeTraverseFunc :: Maybe (Ptr (FunPtr C_NodeTraverseFunc)) -> NodeTraverseFunc -> C_NodeTraverseFunc

Wrap a NodeTraverseFunc into a C_NodeTraverseFunc.

OptionArgFunc

type C_OptionArgFunc = CString -> CString -> Ptr () -> Ptr (Ptr GError) -> IO CInt

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

type OptionArgFunc

Arguments

 = Text

optionName: The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name.

-> Text

value: The value to be parsed.

-> Ptr ()

data: User data added to the OptionGroup containing the option when it was created with optionGroupNew

-> IO ()

Returns: True if the option was successfully parsed, False if an error occurred, in which case error should be set with g_set_error() (Can throw GError)

The type of function to be passed as callback for OptionArgCallback options.

dynamic_OptionArgFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_OptionArgFunc

-> Text

optionName: The name of the option being parsed. This will be either a single dash followed by a single letter (for a short name) or two dashes followed by a long option name.

-> Text

value: The value to be parsed.

-> Ptr ()

data: User data added to the OptionGroup containing the option when it was created with optionGroupNew

-> m ()

(Can throw GError)

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

mk_OptionArgFunc :: C_OptionArgFunc -> IO (FunPtr C_OptionArgFunc)

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

noOptionArgFunc :: Maybe OptionArgFunc

A convenience synonym for Nothing :: Maybe OptionArgFunc.

OptionErrorFunc

type C_OptionErrorFunc = Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> Ptr (Ptr GError) -> IO ()

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

type OptionErrorFunc

Arguments

 = OptionContext

context: The active OptionContext

-> OptionGroup

group: The group to which the function belongs

-> Ptr ()

data: User data added to the OptionGroup containing the option when it was created with optionGroupNew

-> IO ()

(Can throw GError)

The type of function to be used as callback when a parse error occurs.

dynamic_OptionErrorFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_OptionErrorFunc

-> OptionContext

context: The active OptionContext

-> OptionGroup

group: The group to which the function belongs

-> Ptr ()

data: User data added to the OptionGroup containing the option when it was created with optionGroupNew

-> m ()

(Can throw GError)

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

mk_OptionErrorFunc :: C_OptionErrorFunc -> IO (FunPtr C_OptionErrorFunc)

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

noOptionErrorFunc :: Maybe OptionErrorFunc

A convenience synonym for Nothing :: Maybe OptionErrorFunc.

OptionParseFunc

type C_OptionParseFunc = Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> Ptr (Ptr GError) -> IO CInt

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

type OptionParseFunc

Arguments

 = OptionContext

context: The active OptionContext

-> OptionGroup

group: The group to which the function belongs

-> Ptr ()

data: User data added to the OptionGroup containing the option when it was created with optionGroupNew

-> IO ()

Returns: True if the function completed successfully, False if an error occurred, in which case error should be set with g_set_error() (Can throw GError)

The type of function that can be called before and after parsing.

dynamic_OptionParseFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_OptionParseFunc

-> OptionContext

context: The active OptionContext

-> OptionGroup

group: The group to which the function belongs

-> Ptr ()

data: User data added to the OptionGroup containing the option when it was created with optionGroupNew

-> m ()

(Can throw GError)

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

mk_OptionParseFunc :: C_OptionParseFunc -> IO (FunPtr C_OptionParseFunc)

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

noOptionParseFunc :: Maybe OptionParseFunc

A convenience synonym for Nothing :: Maybe OptionParseFunc.

PollFunc

type C_PollFunc = Ptr PollFD -> Word32 -> Int32 -> IO Int32

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

type PollFunc

Arguments

 = PollFD

ufds: an array of PollFD elements

-> Word32

nfsd: the number of elements in ufds

-> Int32

timeout_: the maximum time to wait for an event of the file descriptors. A negative value indicates an infinite timeout.

-> IO Int32

Returns: the number of PollFD elements which have events or errors reported, or -1 if an error occurred.

Specifies the type of function passed to g_main_context_set_poll_func(). The semantics of the function should match those of the poll() system call.

dynamic_PollFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_PollFunc

-> PollFD

ufds: an array of PollFD elements

-> Word32

nfsd: the number of elements in ufds

-> Int32

timeout_: the maximum time to wait for an event of the file descriptors. A negative value indicates an infinite timeout.

-> m Int32

Returns: the number of PollFD elements which have events or errors reported, or -1 if an error occurred.

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

genClosure_PollFunc :: MonadIO m => PollFunc -> m (GClosure C_PollFunc)

Wrap the callback into a GClosure.

mk_PollFunc :: C_PollFunc -> IO (FunPtr C_PollFunc)

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

noPollFunc :: Maybe PollFunc

A convenience synonym for Nothing :: Maybe PollFunc.

wrap_PollFunc :: Maybe (Ptr (FunPtr C_PollFunc)) -> PollFunc -> C_PollFunc

Wrap a PollFunc into a C_PollFunc.

PrintFunc

type C_PrintFunc = CString -> IO ()

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

type PrintFunc

Arguments

 = Text

string: the message to output

-> IO ()

Specifies the type of the print handler functions. These are called with the complete formatted string to output.

dynamic_PrintFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_PrintFunc

-> Text

string: the message to output

-> m ()

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

genClosure_PrintFunc :: MonadIO m => PrintFunc -> m (GClosure C_PrintFunc)

Wrap the callback into a GClosure.

mk_PrintFunc :: C_PrintFunc -> IO (FunPtr C_PrintFunc)

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

noPrintFunc :: Maybe PrintFunc

A convenience synonym for Nothing :: Maybe PrintFunc.

wrap_PrintFunc :: Maybe (Ptr (FunPtr C_PrintFunc)) -> PrintFunc -> C_PrintFunc

Wrap a PrintFunc into a C_PrintFunc.

RegexEvalCallback

type C_RegexEvalCallback = Ptr MatchInfo -> Ptr String -> Ptr () -> IO CInt

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

type RegexEvalCallback

Arguments

 = MatchInfo

matchInfo: the MatchInfo generated by the match. Use matchInfoGetRegex and matchInfoGetString if you need the Regex or the matched string.

-> String

result: a String containing the new string

-> IO Bool

Returns: False to continue the replacement process, True to stop it

Specifies the type of the function passed to g_regex_replace_eval(). It is called for each occurrence of the pattern in the string passed to g_regex_replace_eval(), and it should append the replacement to result.

Since: 2.14

type RegexEvalCallback_WithClosures

Arguments

 = MatchInfo

matchInfo: the MatchInfo generated by the match. Use matchInfoGetRegex and matchInfoGetString if you need the Regex or the matched string.

-> String

result: a String containing the new string

-> Ptr ()

userData: user data passed to g_regex_replace_eval()

-> IO Bool

Returns: False to continue the replacement process, True to stop it

Specifies the type of the function passed to g_regex_replace_eval(). It is called for each occurrence of the pattern in the string passed to g_regex_replace_eval(), and it should append the replacement to result.

Since: 2.14

drop_closures_RegexEvalCallback :: RegexEvalCallback -> RegexEvalCallback_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_RegexEvalCallback

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_RegexEvalCallback

-> MatchInfo

matchInfo: the MatchInfo generated by the match. Use matchInfoGetRegex and matchInfoGetString if you need the Regex or the matched string.

-> String

result: a String containing the new string

-> Ptr ()

userData: user data passed to g_regex_replace_eval()

-> m Bool

Returns: False to continue the replacement process, True to stop it

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

genClosure_RegexEvalCallback :: MonadIO m => RegexEvalCallback -> m (GClosure C_RegexEvalCallback)

Wrap the callback into a GClosure.

mk_RegexEvalCallback :: C_RegexEvalCallback -> IO (FunPtr C_RegexEvalCallback)

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

noRegexEvalCallback :: Maybe RegexEvalCallback

A convenience synonym for Nothing :: Maybe RegexEvalCallback.

noRegexEvalCallback_WithClosures :: Maybe RegexEvalCallback_WithClosures

A convenience synonym for Nothing :: Maybe RegexEvalCallback_WithClosures.

wrap_RegexEvalCallback :: Maybe (Ptr (FunPtr C_RegexEvalCallback)) -> RegexEvalCallback_WithClosures -> C_RegexEvalCallback

Wrap a RegexEvalCallback into a C_RegexEvalCallback.

ScannerMsgFunc

type C_ScannerMsgFunc = Ptr Scanner -> CString -> CInt -> IO ()

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

type ScannerMsgFunc

Arguments

 = Scanner

scanner: a Scanner

-> Text

message: the message

-> Bool

error: True if the message signals an error, False if it signals a warning.

-> IO ()

Specifies the type of the message handler function.

dynamic_ScannerMsgFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ScannerMsgFunc

-> Scanner

scanner: a Scanner

-> Text

message: the message

-> Bool

error: True if the message signals an error, False if it signals a warning.

-> m ()

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

genClosure_ScannerMsgFunc :: MonadIO m => ScannerMsgFunc -> m (GClosure C_ScannerMsgFunc)

Wrap the callback into a GClosure.

mk_ScannerMsgFunc :: C_ScannerMsgFunc -> IO (FunPtr C_ScannerMsgFunc)

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

noScannerMsgFunc :: Maybe ScannerMsgFunc

A convenience synonym for Nothing :: Maybe ScannerMsgFunc.

wrap_ScannerMsgFunc :: Maybe (Ptr (FunPtr C_ScannerMsgFunc)) -> ScannerMsgFunc -> C_ScannerMsgFunc

Wrap a ScannerMsgFunc into a C_ScannerMsgFunc.

SequenceIterCompareFunc

type C_SequenceIterCompareFunc = Ptr SequenceIter -> Ptr SequenceIter -> Ptr () -> IO Int32

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

type SequenceIterCompareFunc

Arguments

 = SequenceIter

a: a SequenceIter

-> SequenceIter

b: a SequenceIter

-> Ptr ()

data: user data

-> IO Int32

Returns: zero if the iterators are equal, a negative value if a comes before b, and a positive value if b comes before a.

A SequenceIterCompareFunc is a function used to compare iterators. It must return zero if the iterators compare equal, a negative value if a comes before b, and a positive value if b comes before a.

dynamic_SequenceIterCompareFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_SequenceIterCompareFunc

-> SequenceIter

a: a SequenceIter

-> SequenceIter

b: a SequenceIter

-> Ptr ()

data: user data

-> m Int32

Returns: zero if the iterators are equal, a negative value if a comes before b, and a positive value if b comes before a.

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

genClosure_SequenceIterCompareFunc :: MonadIO m => SequenceIterCompareFunc -> m (GClosure C_SequenceIterCompareFunc)

Wrap the callback into a GClosure.

mk_SequenceIterCompareFunc :: C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc)

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

noSequenceIterCompareFunc :: Maybe SequenceIterCompareFunc

A convenience synonym for Nothing :: Maybe SequenceIterCompareFunc.

wrap_SequenceIterCompareFunc :: Maybe (Ptr (FunPtr C_SequenceIterCompareFunc)) -> SequenceIterCompareFunc -> C_SequenceIterCompareFunc

Wrap a SequenceIterCompareFunc into a C_SequenceIterCompareFunc.

SourceCallbackFuncsRefFieldCallback

type C_SourceCallbackFuncsRefFieldCallback = Ptr () -> IO ()

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

type SourceCallbackFuncsRefFieldCallback = Ptr () -> IO ()

No description available in the introspection data.

dynamic_SourceCallbackFuncsRefFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceCallbackFuncsRefFieldCallback -> Ptr () -> m ()

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

genClosure_SourceCallbackFuncsRefFieldCallback :: MonadIO m => SourceCallbackFuncsRefFieldCallback -> m (GClosure C_SourceCallbackFuncsRefFieldCallback)

Wrap the callback into a GClosure.

mk_SourceCallbackFuncsRefFieldCallback :: C_SourceCallbackFuncsRefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsRefFieldCallback)

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

noSourceCallbackFuncsRefFieldCallback :: Maybe SourceCallbackFuncsRefFieldCallback

A convenience synonym for Nothing :: Maybe SourceCallbackFuncsRefFieldCallback.

wrap_SourceCallbackFuncsRefFieldCallback :: Maybe (Ptr (FunPtr C_SourceCallbackFuncsRefFieldCallback)) -> SourceCallbackFuncsRefFieldCallback -> C_SourceCallbackFuncsRefFieldCallback

Wrap a SourceCallbackFuncsRefFieldCallback into a C_SourceCallbackFuncsRefFieldCallback.

SourceCallbackFuncsUnrefFieldCallback

type C_SourceCallbackFuncsUnrefFieldCallback = Ptr () -> IO ()

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

type SourceCallbackFuncsUnrefFieldCallback = Ptr () -> IO ()

No description available in the introspection data.

dynamic_SourceCallbackFuncsUnrefFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceCallbackFuncsUnrefFieldCallback -> Ptr () -> m ()

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

genClosure_SourceCallbackFuncsUnrefFieldCallback :: MonadIO m => SourceCallbackFuncsUnrefFieldCallback -> m (GClosure C_SourceCallbackFuncsUnrefFieldCallback)

Wrap the callback into a GClosure.

mk_SourceCallbackFuncsUnrefFieldCallback :: C_SourceCallbackFuncsUnrefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsUnrefFieldCallback)

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

noSourceCallbackFuncsUnrefFieldCallback :: Maybe SourceCallbackFuncsUnrefFieldCallback

A convenience synonym for Nothing :: Maybe SourceCallbackFuncsUnrefFieldCallback.

wrap_SourceCallbackFuncsUnrefFieldCallback :: Maybe (Ptr (FunPtr C_SourceCallbackFuncsUnrefFieldCallback)) -> SourceCallbackFuncsUnrefFieldCallback -> C_SourceCallbackFuncsUnrefFieldCallback

Wrap a SourceCallbackFuncsUnrefFieldCallback into a C_SourceCallbackFuncsUnrefFieldCallback.

SourceDummyMarshal

type C_SourceDummyMarshal = IO ()

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

type SourceDummyMarshal = IO ()

This is just a placeholder for GClosureMarshal, which cannot be used here for dependency reasons.

dynamic_SourceDummyMarshal :: (HasCallStack, MonadIO m) => FunPtr C_SourceDummyMarshal -> m ()

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

genClosure_SourceDummyMarshal :: MonadIO m => SourceDummyMarshal -> m (GClosure C_SourceDummyMarshal)

Wrap the callback into a GClosure.

mk_SourceDummyMarshal :: C_SourceDummyMarshal -> IO (FunPtr C_SourceDummyMarshal)

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

noSourceDummyMarshal :: Maybe SourceDummyMarshal

A convenience synonym for Nothing :: Maybe SourceDummyMarshal.

wrap_SourceDummyMarshal :: Maybe (Ptr (FunPtr C_SourceDummyMarshal)) -> SourceDummyMarshal -> C_SourceDummyMarshal

Wrap a SourceDummyMarshal into a C_SourceDummyMarshal.

SourceFunc

type C_SourceFunc = Ptr () -> IO CInt

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

type SourceFunc

Arguments

 = IO Bool

Returns: False if the source should be removed. SOURCE_CONTINUE and SOURCE_REMOVE are more memorable names for the return value.

Specifies the type of function passed to g_timeout_add(), timeoutAdd, g_idle_add(), and idleAdd.

When calling sourceSetCallback, you may need to cast a function of a different type to this type. Use G_SOURCE_FUNC() to avoid warnings about incompatible function types.

type SourceFunc_WithClosures

Arguments

 = Ptr ()

userData: data passed to the function, set when the source was created with one of the above functions

-> IO Bool

Returns: False if the source should be removed. SOURCE_CONTINUE and SOURCE_REMOVE are more memorable names for the return value.

Specifies the type of function passed to g_timeout_add(), timeoutAdd, g_idle_add(), and idleAdd.

When calling sourceSetCallback, you may need to cast a function of a different type to this type. Use G_SOURCE_FUNC() to avoid warnings about incompatible function types.

drop_closures_SourceFunc :: SourceFunc -> SourceFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SourceFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_SourceFunc

-> Ptr ()

userData: data passed to the function, set when the source was created with one of the above functions

-> m Bool

Returns: False if the source should be removed. SOURCE_CONTINUE and SOURCE_REMOVE are more memorable names for the return value.

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

genClosure_SourceFunc :: MonadIO m => SourceFunc -> m (GClosure C_SourceFunc)

Wrap the callback into a GClosure.

mk_SourceFunc :: C_SourceFunc -> IO (FunPtr C_SourceFunc)

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

noSourceFunc :: Maybe SourceFunc

A convenience synonym for Nothing :: Maybe SourceFunc.

noSourceFunc_WithClosures :: Maybe SourceFunc_WithClosures

A convenience synonym for Nothing :: Maybe SourceFunc_WithClosures.

wrap_SourceFunc :: Maybe (Ptr (FunPtr C_SourceFunc)) -> SourceFunc_WithClosures -> C_SourceFunc

Wrap a SourceFunc into a C_SourceFunc.

SourceFuncsCheckFieldCallback

type C_SourceFuncsCheckFieldCallback = Ptr Source -> IO CInt

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

type SourceFuncsCheckFieldCallback = Source -> IO Bool

No description available in the introspection data.

dynamic_SourceFuncsCheckFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsCheckFieldCallback -> Source -> m Bool

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

genClosure_SourceFuncsCheckFieldCallback :: MonadIO m => SourceFuncsCheckFieldCallback -> m (GClosure C_SourceFuncsCheckFieldCallback)

Wrap the callback into a GClosure.

mk_SourceFuncsCheckFieldCallback :: C_SourceFuncsCheckFieldCallback -> IO (FunPtr C_SourceFuncsCheckFieldCallback)

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

noSourceFuncsCheckFieldCallback :: Maybe SourceFuncsCheckFieldCallback

A convenience synonym for Nothing :: Maybe SourceFuncsCheckFieldCallback.

wrap_SourceFuncsCheckFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsCheckFieldCallback)) -> SourceFuncsCheckFieldCallback -> C_SourceFuncsCheckFieldCallback

Wrap a SourceFuncsCheckFieldCallback into a C_SourceFuncsCheckFieldCallback.

SourceFuncsFinalizeFieldCallback

type C_SourceFuncsFinalizeFieldCallback = Ptr Source -> IO ()

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

type SourceFuncsFinalizeFieldCallback = Source -> IO ()

No description available in the introspection data.

dynamic_SourceFuncsFinalizeFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsFinalizeFieldCallback -> Source -> m ()

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

genClosure_SourceFuncsFinalizeFieldCallback :: MonadIO m => SourceFuncsFinalizeFieldCallback -> m (GClosure C_SourceFuncsFinalizeFieldCallback)

Wrap the callback into a GClosure.

mk_SourceFuncsFinalizeFieldCallback :: C_SourceFuncsFinalizeFieldCallback -> IO (FunPtr C_SourceFuncsFinalizeFieldCallback)

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

noSourceFuncsFinalizeFieldCallback :: Maybe SourceFuncsFinalizeFieldCallback

A convenience synonym for Nothing :: Maybe SourceFuncsFinalizeFieldCallback.

wrap_SourceFuncsFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsFinalizeFieldCallback)) -> SourceFuncsFinalizeFieldCallback -> C_SourceFuncsFinalizeFieldCallback

Wrap a SourceFuncsFinalizeFieldCallback into a C_SourceFuncsFinalizeFieldCallback.

SourceFuncsPrepareFieldCallback

type C_SourceFuncsPrepareFieldCallback = Ptr Source -> Int32 -> IO CInt

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

type SourceFuncsPrepareFieldCallback = Source -> Int32 -> IO Bool

No description available in the introspection data.

dynamic_SourceFuncsPrepareFieldCallback :: (HasCallStack, MonadIO m) => FunPtr C_SourceFuncsPrepareFieldCallback -> Source -> Int32 -> m Bool

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

genClosure_SourceFuncsPrepareFieldCallback :: MonadIO m => SourceFuncsPrepareFieldCallback -> m (GClosure C_SourceFuncsPrepareFieldCallback)

Wrap the callback into a GClosure.

mk_SourceFuncsPrepareFieldCallback :: C_SourceFuncsPrepareFieldCallback -> IO (FunPtr C_SourceFuncsPrepareFieldCallback)

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

noSourceFuncsPrepareFieldCallback :: Maybe SourceFuncsPrepareFieldCallback

A convenience synonym for Nothing :: Maybe SourceFuncsPrepareFieldCallback.

wrap_SourceFuncsPrepareFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsPrepareFieldCallback)) -> SourceFuncsPrepareFieldCallback -> C_SourceFuncsPrepareFieldCallback

Wrap a SourceFuncsPrepareFieldCallback into a C_SourceFuncsPrepareFieldCallback.

SpawnChildSetupFunc

type C_SpawnChildSetupFunc = Ptr () -> IO ()

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

type SpawnChildSetupFunc = IO ()

Specifies the type of the setup function passed to spawnAsync, spawnSync and spawnAsyncWithPipes, which can, in very limited ways, be used to affect the child's execution.

On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform, but before calling exec(). Actions taken in this function will only affect the child, not the parent.

On Windows, the function is called in the parent. Its usefulness on Windows is thus questionable. In many cases executing the child setup function in the parent can have ill effects, and you should be very careful when porting software to Windows that uses child setup functions.

However, even on POSIX, you are extremely limited in what you can safely do from a SpawnChildSetupFunc, because any mutexes that were held by other threads in the parent process at the time of the fork() will still be locked in the child process, and they will never be unlocked (since the threads that held them don't exist in the child). POSIX allows only async-signal-safe functions (see signal(7)) to be called in the child between fork() and exec(), which drastically limits the usefulness of child setup functions.

In particular, it is not safe to call any function which may call malloc(), which includes POSIX functions such as setenv(). If you need to set up the child environment differently from the parent, you should use getEnviron, environSetenv, and environUnsetenv, and then pass the complete environment list to the g_spawn... function.

type SpawnChildSetupFunc_WithClosures

Arguments

 = Ptr ()

userData: user data to pass to the function.

-> IO ()

Specifies the type of the setup function passed to spawnAsync, spawnSync and spawnAsyncWithPipes, which can, in very limited ways, be used to affect the child's execution.

On POSIX platforms, the function is called in the child after GLib has performed all the setup it plans to perform, but before calling exec(). Actions taken in this function will only affect the child, not the parent.

On Windows, the function is called in the parent. Its usefulness on Windows is thus questionable. In many cases executing the child setup function in the parent can have ill effects, and you should be very careful when porting software to Windows that uses child setup functions.

However, even on POSIX, you are extremely limited in what you can safely do from a SpawnChildSetupFunc, because any mutexes that were held by other threads in the parent process at the time of the fork() will still be locked in the child process, and they will never be unlocked (since the threads that held them don't exist in the child). POSIX allows only async-signal-safe functions (see signal(7)) to be called in the child between fork() and exec(), which drastically limits the usefulness of child setup functions.

In particular, it is not safe to call any function which may call malloc(), which includes POSIX functions such as setenv(). If you need to set up the child environment differently from the parent, you should use getEnviron, environSetenv, and environUnsetenv, and then pass the complete environment list to the g_spawn... function.

drop_closures_SpawnChildSetupFunc :: SpawnChildSetupFunc -> SpawnChildSetupFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_SpawnChildSetupFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_SpawnChildSetupFunc

-> Ptr ()

userData: user data to pass to the function.

-> m ()

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

genClosure_SpawnChildSetupFunc :: MonadIO m => SpawnChildSetupFunc -> m (GClosure C_SpawnChildSetupFunc)

Wrap the callback into a GClosure.

mk_SpawnChildSetupFunc :: C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc)

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

noSpawnChildSetupFunc :: Maybe SpawnChildSetupFunc

A convenience synonym for Nothing :: Maybe SpawnChildSetupFunc.

noSpawnChildSetupFunc_WithClosures :: Maybe SpawnChildSetupFunc_WithClosures

A convenience synonym for Nothing :: Maybe SpawnChildSetupFunc_WithClosures.

wrap_SpawnChildSetupFunc :: Maybe (Ptr (FunPtr C_SpawnChildSetupFunc)) -> SpawnChildSetupFunc_WithClosures -> C_SpawnChildSetupFunc

Wrap a SpawnChildSetupFunc into a C_SpawnChildSetupFunc.

TestDataFunc

type C_TestDataFunc = Ptr () -> IO ()

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

type TestDataFunc = IO ()

The type used for test case functions that take an extra pointer argument.

Since: 2.28

type TestDataFunc_WithClosures

Arguments

 = Ptr ()

userData: the data provided when registering the test

-> IO ()

The type used for test case functions that take an extra pointer argument.

Since: 2.28

drop_closures_TestDataFunc :: TestDataFunc -> TestDataFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TestDataFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TestDataFunc

-> Ptr ()

userData: the data provided when registering the test

-> m ()

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

genClosure_TestDataFunc :: MonadIO m => TestDataFunc -> m (GClosure C_TestDataFunc)

Wrap the callback into a GClosure.

mk_TestDataFunc :: C_TestDataFunc -> IO (FunPtr C_TestDataFunc)

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

noTestDataFunc :: Maybe TestDataFunc

A convenience synonym for Nothing :: Maybe TestDataFunc.

noTestDataFunc_WithClosures :: Maybe TestDataFunc_WithClosures

A convenience synonym for Nothing :: Maybe TestDataFunc_WithClosures.

wrap_TestDataFunc :: Maybe (Ptr (FunPtr C_TestDataFunc)) -> TestDataFunc_WithClosures -> C_TestDataFunc

Wrap a TestDataFunc into a C_TestDataFunc.

TestFixtureFunc

type C_TestFixtureFunc = Ptr () -> Ptr () -> IO ()

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

type TestFixtureFunc

Arguments

 = Ptr ()

fixture: the test fixture

-> IO ()

The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves.

userData is a pointer to the data that was given when registering the test case.

fixture will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then fixture will be equal to userData.

Since: 2.28

type TestFixtureFunc_WithClosures

Arguments

 = Ptr ()

fixture: the test fixture

-> Ptr ()

userData: the data provided when registering the test

-> IO ()

The type used for functions that operate on test fixtures. This is used for the fixture setup and teardown functions as well as for the testcases themselves.

userData is a pointer to the data that was given when registering the test case.

fixture will be a pointer to the area of memory allocated by the test framework, of the size requested. If the requested size was zero then fixture will be equal to userData.

Since: 2.28

drop_closures_TestFixtureFunc :: TestFixtureFunc -> TestFixtureFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TestFixtureFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TestFixtureFunc

-> Ptr ()

fixture: the test fixture

-> Ptr ()

userData: the data provided when registering the test

-> m ()

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

genClosure_TestFixtureFunc :: MonadIO m => TestFixtureFunc -> m (GClosure C_TestFixtureFunc)

Wrap the callback into a GClosure.

mk_TestFixtureFunc :: C_TestFixtureFunc -> IO (FunPtr C_TestFixtureFunc)

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

noTestFixtureFunc :: Maybe TestFixtureFunc

A convenience synonym for Nothing :: Maybe TestFixtureFunc.

noTestFixtureFunc_WithClosures :: Maybe TestFixtureFunc_WithClosures

A convenience synonym for Nothing :: Maybe TestFixtureFunc_WithClosures.

wrap_TestFixtureFunc :: Maybe (Ptr (FunPtr C_TestFixtureFunc)) -> TestFixtureFunc_WithClosures -> C_TestFixtureFunc

Wrap a TestFixtureFunc into a C_TestFixtureFunc.

TestFunc

type C_TestFunc = IO ()

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

type TestFunc = IO ()

The type used for test case functions.

Since: 2.28

dynamic_TestFunc :: (HasCallStack, MonadIO m) => FunPtr C_TestFunc -> m ()

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

genClosure_TestFunc :: MonadIO m => TestFunc -> m (GClosure C_TestFunc)

Wrap the callback into a GClosure.

mk_TestFunc :: C_TestFunc -> IO (FunPtr C_TestFunc)

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

noTestFunc :: Maybe TestFunc

A convenience synonym for Nothing :: Maybe TestFunc.

wrap_TestFunc :: Maybe (Ptr (FunPtr C_TestFunc)) -> TestFunc -> C_TestFunc

Wrap a TestFunc into a C_TestFunc.

TestLogFatalFunc

type C_TestLogFatalFunc = CString -> CInt -> CString -> Ptr () -> IO CInt

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

type TestLogFatalFunc

Arguments

 = Text

logDomain: the log domain of the message

-> [LogLevelFlags]

logLevel: the log level of the message (including the fatal and recursion flags)

-> Text

message: the message to process

-> IO Bool

Returns: True if the program should abort, False otherwise

Specifies the prototype of fatal log handler functions.

Since: 2.22

type TestLogFatalFunc_WithClosures

Arguments

 = Text

logDomain: the log domain of the message

-> [LogLevelFlags]

logLevel: the log level of the message (including the fatal and recursion flags)

-> Text

message: the message to process

-> Ptr ()

userData: user data, set in g_test_log_set_fatal_handler()

-> IO Bool

Returns: True if the program should abort, False otherwise

Specifies the prototype of fatal log handler functions.

Since: 2.22

drop_closures_TestLogFatalFunc :: TestLogFatalFunc -> TestLogFatalFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_TestLogFatalFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TestLogFatalFunc

-> Text

logDomain: the log domain of the message

-> [LogLevelFlags]

logLevel: the log level of the message (including the fatal and recursion flags)

-> Text

message: the message to process

-> Ptr ()

userData: user data, set in g_test_log_set_fatal_handler()

-> m Bool

Returns: True if the program should abort, False otherwise

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

genClosure_TestLogFatalFunc :: MonadIO m => TestLogFatalFunc -> m (GClosure C_TestLogFatalFunc)

Wrap the callback into a GClosure.

mk_TestLogFatalFunc :: C_TestLogFatalFunc -> IO (FunPtr C_TestLogFatalFunc)

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

noTestLogFatalFunc :: Maybe TestLogFatalFunc

A convenience synonym for Nothing :: Maybe TestLogFatalFunc.

noTestLogFatalFunc_WithClosures :: Maybe TestLogFatalFunc_WithClosures

A convenience synonym for Nothing :: Maybe TestLogFatalFunc_WithClosures.

wrap_TestLogFatalFunc :: Maybe (Ptr (FunPtr C_TestLogFatalFunc)) -> TestLogFatalFunc_WithClosures -> C_TestLogFatalFunc

Wrap a TestLogFatalFunc into a C_TestLogFatalFunc.

ThreadFunc

type C_ThreadFunc = Ptr () -> IO (Ptr ())

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

type ThreadFunc

Arguments

 = Ptr ()

data: data passed to the thread

-> IO (Ptr ())

Returns: the return value of the thread

Specifies the type of the func functions passed to g_thread_new() or g_thread_try_new().

dynamic_ThreadFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ThreadFunc

-> Ptr ()

data: data passed to the thread

-> m (Ptr ())

Returns: the return value of the thread

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

genClosure_ThreadFunc :: MonadIO m => ThreadFunc -> m (GClosure C_ThreadFunc)

Wrap the callback into a GClosure.

mk_ThreadFunc :: C_ThreadFunc -> IO (FunPtr C_ThreadFunc)

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

noThreadFunc :: Maybe ThreadFunc

A convenience synonym for Nothing :: Maybe ThreadFunc.

wrap_ThreadFunc :: Maybe (Ptr (FunPtr C_ThreadFunc)) -> ThreadFunc -> C_ThreadFunc

Wrap a ThreadFunc into a C_ThreadFunc.

TranslateFunc

type C_TranslateFunc = CString -> Ptr () -> IO CString

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

type TranslateFunc

Arguments

 = Text

str: the untranslated string

-> Ptr ()

data: user data specified when installing the function, e.g. in optionGroupSetTranslateFunc

-> IO Text

Returns: a translation of the string for the current locale. The returned string is owned by GLib and must not be freed.

The type of functions which are used to translate user-visible strings, for <option>--help</option> output.

dynamic_TranslateFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TranslateFunc

-> Text

str: the untranslated string

-> Ptr ()

data: user data specified when installing the function, e.g. in optionGroupSetTranslateFunc

-> m Text

Returns: a translation of the string for the current locale. The returned string is owned by GLib and must not be freed.

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

genClosure_TranslateFunc :: MonadIO m => TranslateFunc -> m (GClosure C_TranslateFunc)

Wrap the callback into a GClosure.

mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc)

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

noTranslateFunc :: Maybe TranslateFunc

A convenience synonym for Nothing :: Maybe TranslateFunc.

wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc -> C_TranslateFunc

Wrap a TranslateFunc into a C_TranslateFunc.

TraverseFunc

type C_TraverseFunc = Ptr () -> Ptr () -> Ptr () -> IO CInt

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

type TraverseFunc

Arguments

 = Ptr ()

key: a key of a Tree node

-> Ptr ()

value: the value corresponding to the key

-> Ptr ()

data: user data passed to g_tree_traverse()

-> IO Bool

Returns: True to stop the traversal

Specifies the type of function passed to g_tree_traverse(). It is passed the key and value of each node, together with the userData parameter passed to g_tree_traverse(). If the function returns True, the traversal is stopped.

dynamic_TraverseFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_TraverseFunc

-> Ptr ()

key: a key of a Tree node

-> Ptr ()

value: the value corresponding to the key

-> Ptr ()

data: user data passed to g_tree_traverse()

-> m Bool

Returns: True to stop the traversal

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

genClosure_TraverseFunc :: MonadIO m => TraverseFunc -> m (GClosure C_TraverseFunc)

Wrap the callback into a GClosure.

mk_TraverseFunc :: C_TraverseFunc -> IO (FunPtr C_TraverseFunc)

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

noTraverseFunc :: Maybe TraverseFunc

A convenience synonym for Nothing :: Maybe TraverseFunc.

wrap_TraverseFunc :: Maybe (Ptr (FunPtr C_TraverseFunc)) -> TraverseFunc -> C_TraverseFunc

Wrap a TraverseFunc into a C_TraverseFunc.

UnixFDSourceFunc

type C_UnixFDSourceFunc = Int32 -> CUInt -> Ptr () -> IO CInt

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

type UnixFDSourceFunc

Arguments

 = Int32

fd: the fd that triggered the event

-> [IOCondition]

condition: the IO conditions reported on fd

-> IO Bool

Returns: False if the source should be removed

The type of functions to be called when a UNIX fd watch source triggers.

type UnixFDSourceFunc_WithClosures

Arguments

 = Int32

fd: the fd that triggered the event

-> [IOCondition]

condition: the IO conditions reported on fd

-> Ptr ()

userData: user data passed to g_unix_fd_add()

-> IO Bool

Returns: False if the source should be removed

The type of functions to be called when a UNIX fd watch source triggers.

drop_closures_UnixFDSourceFunc :: UnixFDSourceFunc -> UnixFDSourceFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_UnixFDSourceFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_UnixFDSourceFunc

-> Int32

fd: the fd that triggered the event

-> [IOCondition]

condition: the IO conditions reported on fd

-> Ptr ()

userData: user data passed to g_unix_fd_add()

-> m Bool

Returns: False if the source should be removed

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

genClosure_UnixFDSourceFunc :: MonadIO m => UnixFDSourceFunc -> m (GClosure C_UnixFDSourceFunc)

Wrap the callback into a GClosure.

mk_UnixFDSourceFunc :: C_UnixFDSourceFunc -> IO (FunPtr C_UnixFDSourceFunc)

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

noUnixFDSourceFunc :: Maybe UnixFDSourceFunc

A convenience synonym for Nothing :: Maybe UnixFDSourceFunc.

noUnixFDSourceFunc_WithClosures :: Maybe UnixFDSourceFunc_WithClosures

A convenience synonym for Nothing :: Maybe UnixFDSourceFunc_WithClosures.

wrap_UnixFDSourceFunc :: Maybe (Ptr (FunPtr C_UnixFDSourceFunc)) -> UnixFDSourceFunc_WithClosures -> C_UnixFDSourceFunc

Wrap a UnixFDSourceFunc into a C_UnixFDSourceFunc.

VoidFunc

type C_VoidFunc = IO ()

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

type VoidFunc = IO ()

Declares a type of function which takes no arguments and has no return value. It is used to specify the type function passed to atexit.

dynamic_VoidFunc :: (HasCallStack, MonadIO m) => FunPtr C_VoidFunc -> m ()

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

genClosure_VoidFunc :: MonadIO m => VoidFunc -> m (GClosure C_VoidFunc)

Wrap the callback into a GClosure.

mk_VoidFunc :: C_VoidFunc -> IO (FunPtr C_VoidFunc)

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

noVoidFunc :: Maybe VoidFunc

A convenience synonym for Nothing :: Maybe VoidFunc.

wrap_VoidFunc :: Maybe (Ptr (FunPtr C_VoidFunc)) -> VoidFunc -> C_VoidFunc

Wrap a VoidFunc into a C_VoidFunc.