Copyright	Will Thompson Iñaki García Etxebarria and Jonas Platte
License	LGPL-2.1
Maintainer	Iñaki García Etxebarria (garetxe@gmail.com)
Safe Haskell	None
Language	Haskell2010

GI.GLib.Callbacks

Contents

Signals

Description

Synopsis

Signals

ChildWatchFunc

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

type ChildWatchFunc = Int32 -> Int32 -> IO () #

type ChildWatchFunc_WithClosures = Int32 -> Int32 -> Ptr () -> IO () #

drop_closures_ChildWatchFunc :: ChildWatchFunc -> ChildWatchFunc_WithClosures #

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

genClosure_ChildWatchFunc :: ChildWatchFunc -> IO Closure #

mk_ChildWatchFunc :: C_ChildWatchFunc -> IO (FunPtr C_ChildWatchFunc) #

noChildWatchFunc :: Maybe ChildWatchFunc #

noChildWatchFunc_WithClosures :: Maybe ChildWatchFunc_WithClosures #

wrap_ChildWatchFunc :: Maybe (Ptr (FunPtr C_ChildWatchFunc)) -> ChildWatchFunc_WithClosures -> Int32 -> Int32 -> Ptr () -> IO () #

CompareDataFunc

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

type CompareDataFunc = Ptr () -> Ptr () -> IO Int32 #

type CompareDataFunc_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO Int32 #

drop_closures_CompareDataFunc :: CompareDataFunc -> CompareDataFunc_WithClosures #

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`

genClosure_CompareDataFunc :: CompareDataFunc -> IO Closure #

mk_CompareDataFunc :: C_CompareDataFunc -> IO (FunPtr C_CompareDataFunc) #

noCompareDataFunc :: Maybe CompareDataFunc #

noCompareDataFunc_WithClosures :: Maybe CompareDataFunc_WithClosures #

wrap_CompareDataFunc :: Maybe (Ptr (FunPtr C_CompareDataFunc)) -> CompareDataFunc_WithClosures -> Ptr () -> Ptr () -> Ptr () -> IO Int32 #

CompareFunc

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

type CompareFunc = Ptr () -> Ptr () -> IO Int32 #

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`

genClosure_CompareFunc :: CompareFunc -> IO Closure #

mk_CompareFunc :: C_CompareFunc -> IO (FunPtr C_CompareFunc) #

noCompareFunc :: Maybe CompareFunc #

wrap_CompareFunc :: Maybe (Ptr (FunPtr C_CompareFunc)) -> CompareFunc -> Ptr () -> Ptr () -> IO Int32 #

CopyFunc

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

type CopyFunc = Ptr () -> Ptr () -> IO (Ptr ()) #

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

genClosure_CopyFunc :: CopyFunc -> IO Closure #

mk_CopyFunc :: C_CopyFunc -> IO (FunPtr C_CopyFunc) #

noCopyFunc :: Maybe CopyFunc #

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

DataForeachFunc

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

type DataForeachFunc = Word32 -> Ptr () -> IO () #

type DataForeachFunc_WithClosures = Word32 -> Ptr () -> Ptr () -> IO () #

drop_closures_DataForeachFunc :: DataForeachFunc -> DataForeachFunc_WithClosures #

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 `g_dataset_foreach()`.
-> m ()

genClosure_DataForeachFunc :: DataForeachFunc -> IO Closure #

mk_DataForeachFunc :: C_DataForeachFunc -> IO (FunPtr C_DataForeachFunc) #

noDataForeachFunc :: Maybe DataForeachFunc #

noDataForeachFunc_WithClosures :: Maybe DataForeachFunc_WithClosures #

wrap_DataForeachFunc :: Maybe (Ptr (FunPtr C_DataForeachFunc)) -> DataForeachFunc_WithClosures -> Word32 -> Ptr () -> Ptr () -> IO () #

DestroyNotify

type C_DestroyNotify = Ptr () -> IO () #

type DestroyNotify = Ptr () -> IO () #

dynamic_DestroyNotify #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_DestroyNotify
-> Ptr ()	`data`: the data element.
-> m ()

genClosure_DestroyNotify :: DestroyNotify -> IO Closure #

mk_DestroyNotify :: C_DestroyNotify -> IO (FunPtr C_DestroyNotify) #

noDestroyNotify :: Maybe DestroyNotify #

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

DuplicateFunc

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

type DuplicateFunc = Ptr () -> IO (Ptr ()) #

type DuplicateFunc_WithClosures = Ptr () -> Ptr () -> IO (Ptr ()) #

drop_closures_DuplicateFunc :: DuplicateFunc -> DuplicateFunc_WithClosures #

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

genClosure_DuplicateFunc :: DuplicateFunc -> IO Closure #

mk_DuplicateFunc :: C_DuplicateFunc -> IO (FunPtr C_DuplicateFunc) #

noDuplicateFunc :: Maybe DuplicateFunc #

noDuplicateFunc_WithClosures :: Maybe DuplicateFunc_WithClosures #

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

EqualFunc

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

type EqualFunc = Ptr () -> Ptr () -> IO Bool #

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

genClosure_EqualFunc :: EqualFunc -> IO Closure #

mk_EqualFunc :: C_EqualFunc -> IO (FunPtr C_EqualFunc) #

noEqualFunc :: Maybe EqualFunc #

wrap_EqualFunc :: Maybe (Ptr (FunPtr C_EqualFunc)) -> EqualFunc -> Ptr () -> Ptr () -> IO CInt #

FreeFunc

type C_FreeFunc = Ptr () -> IO () #

type FreeFunc = Ptr () -> IO () #

dynamic_FreeFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_FreeFunc
-> Ptr ()	`data`: a data pointer
-> m ()

genClosure_FreeFunc :: FreeFunc -> IO Closure #

mk_FreeFunc :: C_FreeFunc -> IO (FunPtr C_FreeFunc) #

noFreeFunc :: Maybe FreeFunc #

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

Func

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

type Func = Ptr () -> IO () #

type Func_WithClosures = Ptr () -> Ptr () -> IO () #

drop_closures_Func :: Func -> Func_WithClosures #

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

genClosure_Func :: Func -> IO Closure #

mk_Func :: C_Func -> IO (FunPtr C_Func) #

noFunc :: Maybe Func #

noFunc_WithClosures :: Maybe Func_WithClosures #

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

HFunc

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

type HFunc = Ptr () -> Ptr () -> IO () #

type HFunc_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO () #

drop_closures_HFunc :: HFunc -> HFunc_WithClosures #

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

genClosure_HFunc :: HFunc -> IO Closure #

mk_HFunc :: C_HFunc -> IO (FunPtr C_HFunc) #

noHFunc :: Maybe HFunc #

noHFunc_WithClosures :: Maybe HFunc_WithClosures #

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

HRFunc

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

type HRFunc = Ptr () -> Ptr () -> IO Bool #

type HRFunc_WithClosures = Ptr () -> Ptr () -> Ptr () -> IO Bool #

drop_closures_HRFunc :: HRFunc -> HRFunc_WithClosures #

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`

genClosure_HRFunc :: HRFunc -> IO Closure #

mk_HRFunc :: C_HRFunc -> IO (FunPtr C_HRFunc) #

noHRFunc :: Maybe HRFunc #

noHRFunc_WithClosures :: Maybe HRFunc_WithClosures #

wrap_HRFunc :: Maybe (Ptr (FunPtr C_HRFunc)) -> HRFunc_WithClosures -> Ptr () -> Ptr () -> Ptr () -> IO CInt #

HashFunc

type C_HashFunc = Ptr () -> IO Word32 #

type HashFunc = Ptr () -> IO Word32 #

dynamic_HashFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_HashFunc
-> Ptr ()	`key`: a key
-> m Word32	Returns: the hash value corresponding to the key

genClosure_HashFunc :: HashFunc -> IO Closure #

mk_HashFunc :: C_HashFunc -> IO (FunPtr C_HashFunc) #

noHashFunc :: Maybe HashFunc #

wrap_HashFunc :: Maybe (Ptr (FunPtr C_HashFunc)) -> HashFunc -> Ptr () -> IO Word32 #

HookCheckFunc

type C_HookCheckFunc = Ptr () -> IO CInt #

type HookCheckFunc = Ptr () -> IO Bool #

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

genClosure_HookCheckFunc :: HookCheckFunc -> IO Closure #

mk_HookCheckFunc :: C_HookCheckFunc -> IO (FunPtr C_HookCheckFunc) #

noHookCheckFunc :: Maybe HookCheckFunc #

wrap_HookCheckFunc :: Maybe (Ptr (FunPtr C_HookCheckFunc)) -> HookCheckFunc -> Ptr () -> IO CInt #

HookCheckMarshaller

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

type HookCheckMarshaller = Hook -> Ptr () -> IO Bool #

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

genClosure_HookCheckMarshaller :: HookCheckMarshaller -> IO Closure #

mk_HookCheckMarshaller :: C_HookCheckMarshaller -> IO (FunPtr C_HookCheckMarshaller) #

noHookCheckMarshaller :: Maybe HookCheckMarshaller #

wrap_HookCheckMarshaller :: Maybe (Ptr (FunPtr C_HookCheckMarshaller)) -> HookCheckMarshaller -> Ptr Hook -> Ptr () -> IO CInt #

HookCompareFunc

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

type HookCompareFunc = Hook -> Hook -> IO Int32 #

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`

genClosure_HookCompareFunc :: HookCompareFunc -> IO Closure #

mk_HookCompareFunc :: C_HookCompareFunc -> IO (FunPtr C_HookCompareFunc) #

noHookCompareFunc :: Maybe HookCompareFunc #

wrap_HookCompareFunc :: Maybe (Ptr (FunPtr C_HookCompareFunc)) -> HookCompareFunc -> Ptr Hook -> Ptr Hook -> IO Int32 #

HookFinalizeFunc

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

type HookFinalizeFunc = HookList -> Hook -> IO () #

dynamic_HookFinalizeFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_HookFinalizeFunc
-> HookList	`hookList`: a `HookList`
-> Hook	`hook`: the hook in `hookList` that gets finalized
-> m ()

genClosure_HookFinalizeFunc :: HookFinalizeFunc -> IO Closure #

mk_HookFinalizeFunc :: C_HookFinalizeFunc -> IO (FunPtr C_HookFinalizeFunc) #

noHookFinalizeFunc :: Maybe HookFinalizeFunc #

wrap_HookFinalizeFunc :: Maybe (Ptr (FunPtr C_HookFinalizeFunc)) -> HookFinalizeFunc -> Ptr HookList -> Ptr Hook -> IO () #

HookFindFunc

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

type HookFindFunc = Hook -> Ptr () -> IO Bool #

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

genClosure_HookFindFunc :: HookFindFunc -> IO Closure #

mk_HookFindFunc :: C_HookFindFunc -> IO (FunPtr C_HookFindFunc) #

noHookFindFunc :: Maybe HookFindFunc #

wrap_HookFindFunc :: Maybe (Ptr (FunPtr C_HookFindFunc)) -> HookFindFunc -> Ptr Hook -> Ptr () -> IO CInt #

HookFunc

type C_HookFunc = Ptr () -> IO () #

type HookFunc = Ptr () -> IO () #

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

genClosure_HookFunc :: HookFunc -> IO Closure #

mk_HookFunc :: C_HookFunc -> IO (FunPtr C_HookFunc) #

noHookFunc :: Maybe HookFunc #

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

HookMarshaller

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

type HookMarshaller = Hook -> Ptr () -> IO () #

dynamic_HookMarshaller #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_HookMarshaller
-> Hook	`hook`: a `Hook`
-> Ptr ()	`marshalData`: user data
-> m ()

genClosure_HookMarshaller :: HookMarshaller -> IO Closure #

mk_HookMarshaller :: C_HookMarshaller -> IO (FunPtr C_HookMarshaller) #

noHookMarshaller :: Maybe HookMarshaller #

wrap_HookMarshaller :: Maybe (Ptr (FunPtr C_HookMarshaller)) -> HookMarshaller -> Ptr Hook -> Ptr () -> IO () #

IOFunc

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

type IOFunc = IOChannel -> [IOCondition] -> Ptr () -> IO Bool #

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

genClosure_IOFunc :: IOFunc -> IO Closure #

mk_IOFunc :: C_IOFunc -> IO (FunPtr C_IOFunc) #

noIOFunc :: Maybe IOFunc #

wrap_IOFunc :: Maybe (Ptr (FunPtr C_IOFunc)) -> IOFunc -> Ptr IOChannel -> CUInt -> Ptr () -> IO CInt #

IOFuncsIoCloseFieldCallback

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

type IOFuncsIoCloseFieldCallback = IOChannel -> IO IOStatus #

dynamic_IOFuncsIoCloseFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_IOFuncsIoCloseFieldCallback
-> IOChannel
-> m IOStatus	(Can throw `GError`)

mk_IOFuncsIoCloseFieldCallback :: C_IOFuncsIoCloseFieldCallback -> IO (FunPtr C_IOFuncsIoCloseFieldCallback) #

noIOFuncsIoCloseFieldCallback :: Maybe IOFuncsIoCloseFieldCallback #

IOFuncsIoCreateWatchFieldCallback

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

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

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

genClosure_IOFuncsIoCreateWatchFieldCallback :: IOFuncsIoCreateWatchFieldCallback -> IO Closure #

mk_IOFuncsIoCreateWatchFieldCallback :: C_IOFuncsIoCreateWatchFieldCallback -> IO (FunPtr C_IOFuncsIoCreateWatchFieldCallback) #

noIOFuncsIoCreateWatchFieldCallback :: Maybe IOFuncsIoCreateWatchFieldCallback #

wrap_IOFuncsIoCreateWatchFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)) -> IOFuncsIoCreateWatchFieldCallback -> Ptr IOChannel -> CUInt -> IO (Ptr Source) #

IOFuncsIoFreeFieldCallback

type C_IOFuncsIoFreeFieldCallback = Ptr IOChannel -> IO () #

type IOFuncsIoFreeFieldCallback = IOChannel -> IO () #

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

genClosure_IOFuncsIoFreeFieldCallback :: IOFuncsIoFreeFieldCallback -> IO Closure #

mk_IOFuncsIoFreeFieldCallback :: C_IOFuncsIoFreeFieldCallback -> IO (FunPtr C_IOFuncsIoFreeFieldCallback) #

noIOFuncsIoFreeFieldCallback :: Maybe IOFuncsIoFreeFieldCallback #

wrap_IOFuncsIoFreeFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)) -> IOFuncsIoFreeFieldCallback -> Ptr IOChannel -> IO () #

IOFuncsIoGetFlagsFieldCallback

type C_IOFuncsIoGetFlagsFieldCallback = Ptr IOChannel -> IO CUInt #

type IOFuncsIoGetFlagsFieldCallback = IOChannel -> IO [IOFlags] #

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

genClosure_IOFuncsIoGetFlagsFieldCallback :: IOFuncsIoGetFlagsFieldCallback -> IO Closure #

mk_IOFuncsIoGetFlagsFieldCallback :: C_IOFuncsIoGetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoGetFlagsFieldCallback) #

noIOFuncsIoGetFlagsFieldCallback :: Maybe IOFuncsIoGetFlagsFieldCallback #

wrap_IOFuncsIoGetFlagsFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)) -> IOFuncsIoGetFlagsFieldCallback -> Ptr IOChannel -> IO CUInt #

IOFuncsIoReadFieldCallback

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

type IOFuncsIoReadFieldCallback = IOChannel -> Text -> Word64 -> Word64 -> IO IOStatus #

dynamic_IOFuncsIoReadFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_IOFuncsIoReadFieldCallback
-> IOChannel
-> Text
-> Word64
-> Word64
-> m IOStatus	(Can throw `GError`)

mk_IOFuncsIoReadFieldCallback :: C_IOFuncsIoReadFieldCallback -> IO (FunPtr C_IOFuncsIoReadFieldCallback) #

noIOFuncsIoReadFieldCallback :: Maybe IOFuncsIoReadFieldCallback #

IOFuncsIoSeekFieldCallback

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

type IOFuncsIoSeekFieldCallback = IOChannel -> Int64 -> SeekType -> IO IOStatus #

dynamic_IOFuncsIoSeekFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_IOFuncsIoSeekFieldCallback
-> IOChannel
-> Int64
-> SeekType
-> m IOStatus	(Can throw `GError`)

mk_IOFuncsIoSeekFieldCallback :: C_IOFuncsIoSeekFieldCallback -> IO (FunPtr C_IOFuncsIoSeekFieldCallback) #

noIOFuncsIoSeekFieldCallback :: Maybe IOFuncsIoSeekFieldCallback #

IOFuncsIoSetFlagsFieldCallback

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

type IOFuncsIoSetFlagsFieldCallback = IOChannel -> [IOFlags] -> IO IOStatus #

dynamic_IOFuncsIoSetFlagsFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_IOFuncsIoSetFlagsFieldCallback
-> IOChannel
-> [IOFlags]
-> m IOStatus	(Can throw `GError`)

mk_IOFuncsIoSetFlagsFieldCallback :: C_IOFuncsIoSetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoSetFlagsFieldCallback) #

noIOFuncsIoSetFlagsFieldCallback :: Maybe IOFuncsIoSetFlagsFieldCallback #

IOFuncsIoWriteFieldCallback

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

type IOFuncsIoWriteFieldCallback = IOChannel -> Text -> Word64 -> Word64 -> IO IOStatus #

dynamic_IOFuncsIoWriteFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_IOFuncsIoWriteFieldCallback
-> IOChannel
-> Text
-> Word64
-> Word64
-> m IOStatus	(Can throw `GError`)

mk_IOFuncsIoWriteFieldCallback :: C_IOFuncsIoWriteFieldCallback -> IO (FunPtr C_IOFuncsIoWriteFieldCallback) #

noIOFuncsIoWriteFieldCallback :: Maybe IOFuncsIoWriteFieldCallback #

LogFunc

type C_LogFunc = CString -> CUInt -> CString -> Ptr () -> IO () #

type LogFunc = Text -> [LogLevelFlags] -> Text -> IO () #

type LogFunc_WithClosures = Text -> [LogLevelFlags] -> Text -> Ptr () -> IO () #

drop_closures_LogFunc :: LogFunc -> LogFunc_WithClosures #

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

genClosure_LogFunc :: LogFunc -> IO Closure #

mk_LogFunc :: C_LogFunc -> IO (FunPtr C_LogFunc) #

noLogFunc :: Maybe LogFunc #

noLogFunc_WithClosures :: Maybe LogFunc_WithClosures #

wrap_LogFunc :: Maybe (Ptr (FunPtr C_LogFunc)) -> LogFunc_WithClosures -> CString -> CUInt -> CString -> Ptr () -> IO () #

LogWriterFunc

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

type LogWriterFunc = [LogLevelFlags] -> [LogField] -> IO LogWriterOutput #

type LogWriterFunc_WithClosures = [LogLevelFlags] -> [LogField] -> Ptr () -> IO LogWriterOutput #

drop_closures_LogWriterFunc :: LogWriterFunc -> LogWriterFunc_WithClosures #

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

genClosure_LogWriterFunc :: LogWriterFunc -> IO Closure #

mk_LogWriterFunc :: C_LogWriterFunc -> IO (FunPtr C_LogWriterFunc) #

noLogWriterFunc :: Maybe LogWriterFunc #

noLogWriterFunc_WithClosures :: Maybe LogWriterFunc_WithClosures #

wrap_LogWriterFunc :: Maybe (Ptr (FunPtr C_LogWriterFunc)) -> LogWriterFunc_WithClosures -> CUInt -> Ptr LogField -> Word64 -> Ptr () -> IO CUInt #

MarkupParserEndElementFieldCallback

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

type MarkupParserEndElementFieldCallback = MarkupParseContext -> Text -> IO () #

type MarkupParserEndElementFieldCallback_WithClosures = MarkupParseContext -> Text -> Ptr () -> IO () #

drop_closures_MarkupParserEndElementFieldCallback :: MarkupParserEndElementFieldCallback -> MarkupParserEndElementFieldCallback_WithClosures #

dynamic_MarkupParserEndElementFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_MarkupParserEndElementFieldCallback
-> MarkupParseContext
-> Text
-> Ptr ()
-> m ()	(Can throw `GError`)

mk_MarkupParserEndElementFieldCallback :: C_MarkupParserEndElementFieldCallback -> IO (FunPtr C_MarkupParserEndElementFieldCallback) #

noMarkupParserEndElementFieldCallback :: Maybe MarkupParserEndElementFieldCallback #

noMarkupParserEndElementFieldCallback_WithClosures :: Maybe MarkupParserEndElementFieldCallback_WithClosures #

MarkupParserErrorFieldCallback

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

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

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

drop_closures_MarkupParserErrorFieldCallback :: MarkupParserErrorFieldCallback -> MarkupParserErrorFieldCallback_WithClosures #

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

genClosure_MarkupParserErrorFieldCallback :: MarkupParserErrorFieldCallback -> IO Closure #

mk_MarkupParserErrorFieldCallback :: C_MarkupParserErrorFieldCallback -> IO (FunPtr C_MarkupParserErrorFieldCallback) #

noMarkupParserErrorFieldCallback :: Maybe MarkupParserErrorFieldCallback #

noMarkupParserErrorFieldCallback_WithClosures :: Maybe MarkupParserErrorFieldCallback_WithClosures #

wrap_MarkupParserErrorFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserErrorFieldCallback)) -> MarkupParserErrorFieldCallback_WithClosures -> Ptr MarkupParseContext -> Ptr GError -> Ptr () -> IO () #

MarkupParserPassthroughFieldCallback

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

type MarkupParserPassthroughFieldCallback = MarkupParseContext -> Text -> Word64 -> IO () #

type MarkupParserPassthroughFieldCallback_WithClosures = MarkupParseContext -> Text -> Word64 -> Ptr () -> IO () #

drop_closures_MarkupParserPassthroughFieldCallback :: MarkupParserPassthroughFieldCallback -> MarkupParserPassthroughFieldCallback_WithClosures #

dynamic_MarkupParserPassthroughFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_MarkupParserPassthroughFieldCallback
-> MarkupParseContext
-> Text
-> Word64
-> Ptr ()
-> m ()	(Can throw `GError`)

mk_MarkupParserPassthroughFieldCallback :: C_MarkupParserPassthroughFieldCallback -> IO (FunPtr C_MarkupParserPassthroughFieldCallback) #

noMarkupParserPassthroughFieldCallback :: Maybe MarkupParserPassthroughFieldCallback #

noMarkupParserPassthroughFieldCallback_WithClosures :: Maybe MarkupParserPassthroughFieldCallback_WithClosures #

MarkupParserStartElementFieldCallback

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

type MarkupParserStartElementFieldCallback = MarkupParseContext -> Text -> Text -> Text -> IO () #

type MarkupParserStartElementFieldCallback_WithClosures = MarkupParseContext -> Text -> Text -> Text -> Ptr () -> IO () #

drop_closures_MarkupParserStartElementFieldCallback :: MarkupParserStartElementFieldCallback -> MarkupParserStartElementFieldCallback_WithClosures #

dynamic_MarkupParserStartElementFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_MarkupParserStartElementFieldCallback
-> MarkupParseContext
-> Text
-> Text
-> Text
-> Ptr ()
-> m ()	(Can throw `GError`)

mk_MarkupParserStartElementFieldCallback :: C_MarkupParserStartElementFieldCallback -> IO (FunPtr C_MarkupParserStartElementFieldCallback) #

noMarkupParserStartElementFieldCallback :: Maybe MarkupParserStartElementFieldCallback #

noMarkupParserStartElementFieldCallback_WithClosures :: Maybe MarkupParserStartElementFieldCallback_WithClosures #

MarkupParserTextFieldCallback

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

type MarkupParserTextFieldCallback = MarkupParseContext -> Text -> Word64 -> IO () #

type MarkupParserTextFieldCallback_WithClosures = MarkupParseContext -> Text -> Word64 -> Ptr () -> IO () #

drop_closures_MarkupParserTextFieldCallback :: MarkupParserTextFieldCallback -> MarkupParserTextFieldCallback_WithClosures #

dynamic_MarkupParserTextFieldCallback #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_MarkupParserTextFieldCallback
-> MarkupParseContext
-> Text
-> Word64
-> Ptr ()
-> m ()	(Can throw `GError`)

mk_MarkupParserTextFieldCallback :: C_MarkupParserTextFieldCallback -> IO (FunPtr C_MarkupParserTextFieldCallback) #

noMarkupParserTextFieldCallback :: Maybe MarkupParserTextFieldCallback #

noMarkupParserTextFieldCallback_WithClosures :: Maybe MarkupParserTextFieldCallback_WithClosures #

MemVTableCallocFieldCallback

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

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

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

genClosure_MemVTableCallocFieldCallback :: MemVTableCallocFieldCallback -> IO Closure #

mk_MemVTableCallocFieldCallback :: C_MemVTableCallocFieldCallback -> IO (FunPtr C_MemVTableCallocFieldCallback) #

noMemVTableCallocFieldCallback :: Maybe MemVTableCallocFieldCallback #

wrap_MemVTableCallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableCallocFieldCallback)) -> MemVTableCallocFieldCallback -> Word64 -> Word64 -> IO (Ptr ()) #

MemVTableFreeFieldCallback

type C_MemVTableFreeFieldCallback = Ptr () -> IO () #

type MemVTableFreeFieldCallback = Ptr () -> IO () #

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

genClosure_MemVTableFreeFieldCallback :: MemVTableFreeFieldCallback -> IO Closure #

mk_MemVTableFreeFieldCallback :: C_MemVTableFreeFieldCallback -> IO (FunPtr C_MemVTableFreeFieldCallback) #

noMemVTableFreeFieldCallback :: Maybe MemVTableFreeFieldCallback #

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

MemVTableMallocFieldCallback

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

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

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

genClosure_MemVTableMallocFieldCallback :: MemVTableMallocFieldCallback -> IO Closure #

mk_MemVTableMallocFieldCallback :: C_MemVTableMallocFieldCallback -> IO (FunPtr C_MemVTableMallocFieldCallback) #

noMemVTableMallocFieldCallback :: Maybe MemVTableMallocFieldCallback #

wrap_MemVTableMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableMallocFieldCallback)) -> MemVTableMallocFieldCallback -> Word64 -> IO (Ptr ()) #

MemVTableReallocFieldCallback

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

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

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

genClosure_MemVTableReallocFieldCallback :: MemVTableReallocFieldCallback -> IO Closure #

mk_MemVTableReallocFieldCallback :: C_MemVTableReallocFieldCallback -> IO (FunPtr C_MemVTableReallocFieldCallback) #

noMemVTableReallocFieldCallback :: Maybe MemVTableReallocFieldCallback #

wrap_MemVTableReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableReallocFieldCallback)) -> MemVTableReallocFieldCallback -> Ptr () -> Word64 -> IO (Ptr ()) #

MemVTableTryMallocFieldCallback

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

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

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

genClosure_MemVTableTryMallocFieldCallback :: MemVTableTryMallocFieldCallback -> IO Closure #

mk_MemVTableTryMallocFieldCallback :: C_MemVTableTryMallocFieldCallback -> IO (FunPtr C_MemVTableTryMallocFieldCallback) #

noMemVTableTryMallocFieldCallback :: Maybe MemVTableTryMallocFieldCallback #

wrap_MemVTableTryMallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryMallocFieldCallback)) -> MemVTableTryMallocFieldCallback -> Word64 -> IO (Ptr ()) #

MemVTableTryReallocFieldCallback

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

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

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

genClosure_MemVTableTryReallocFieldCallback :: MemVTableTryReallocFieldCallback -> IO Closure #

mk_MemVTableTryReallocFieldCallback :: C_MemVTableTryReallocFieldCallback -> IO (FunPtr C_MemVTableTryReallocFieldCallback) #

noMemVTableTryReallocFieldCallback :: Maybe MemVTableTryReallocFieldCallback #

wrap_MemVTableTryReallocFieldCallback :: Maybe (Ptr (FunPtr C_MemVTableTryReallocFieldCallback)) -> MemVTableTryReallocFieldCallback -> Ptr () -> Word64 -> IO (Ptr ()) #

NodeForeachFunc

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

type NodeForeachFunc = Node -> Ptr () -> IO () #

dynamic_NodeForeachFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_NodeForeachFunc
-> Node	`node`: a `Node`.
-> Ptr ()	`data`: user data passed to `g_node_children_foreach()`.
-> m ()

genClosure_NodeForeachFunc :: NodeForeachFunc -> IO Closure #

mk_NodeForeachFunc :: C_NodeForeachFunc -> IO (FunPtr C_NodeForeachFunc) #

noNodeForeachFunc :: Maybe NodeForeachFunc #

wrap_NodeForeachFunc :: Maybe (Ptr (FunPtr C_NodeForeachFunc)) -> NodeForeachFunc -> Ptr Node -> Ptr () -> IO () #

NodeTraverseFunc

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

type NodeTraverseFunc = Node -> Ptr () -> IO Bool #

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.

genClosure_NodeTraverseFunc :: NodeTraverseFunc -> IO Closure #

mk_NodeTraverseFunc :: C_NodeTraverseFunc -> IO (FunPtr C_NodeTraverseFunc) #

noNodeTraverseFunc :: Maybe NodeTraverseFunc #

wrap_NodeTraverseFunc :: Maybe (Ptr (FunPtr C_NodeTraverseFunc)) -> NodeTraverseFunc -> Ptr Node -> Ptr () -> IO CInt #

OptionArgFunc

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

type OptionArgFunc = Text -> Text -> Ptr () -> IO () #

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`)

mk_OptionArgFunc :: C_OptionArgFunc -> IO (FunPtr C_OptionArgFunc) #

noOptionArgFunc :: Maybe OptionArgFunc #

OptionErrorFunc

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

type OptionErrorFunc = OptionContext -> OptionGroup -> Ptr () -> IO () #

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`)

mk_OptionErrorFunc :: C_OptionErrorFunc -> IO (FunPtr C_OptionErrorFunc) #

noOptionErrorFunc :: Maybe OptionErrorFunc #

OptionParseFunc

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

type OptionParseFunc = OptionContext -> OptionGroup -> Ptr () -> IO () #

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`)

mk_OptionParseFunc :: C_OptionParseFunc -> IO (FunPtr C_OptionParseFunc) #

noOptionParseFunc :: Maybe OptionParseFunc #

PollFunc

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

type PollFunc = PollFD -> Word32 -> Int32 -> IO Int32 #

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.

genClosure_PollFunc :: PollFunc -> IO Closure #

mk_PollFunc :: C_PollFunc -> IO (FunPtr C_PollFunc) #

noPollFunc :: Maybe PollFunc #

wrap_PollFunc :: Maybe (Ptr (FunPtr C_PollFunc)) -> PollFunc -> Ptr PollFD -> Word32 -> Int32 -> IO Int32 #

PrintFunc

type C_PrintFunc = CString -> IO () #

type PrintFunc = Text -> IO () #

dynamic_PrintFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_PrintFunc
-> Text	`string`: the message to output
-> m ()

genClosure_PrintFunc :: PrintFunc -> IO Closure #

mk_PrintFunc :: C_PrintFunc -> IO (FunPtr C_PrintFunc) #

noPrintFunc :: Maybe PrintFunc #

wrap_PrintFunc :: Maybe (Ptr (FunPtr C_PrintFunc)) -> PrintFunc -> CString -> IO () #

RegexEvalCallback

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

type RegexEvalCallback = MatchInfo -> String -> IO Bool #

type RegexEvalCallback_WithClosures = MatchInfo -> String -> Ptr () -> IO Bool #

drop_closures_RegexEvalCallback :: RegexEvalCallback -> RegexEvalCallback_WithClosures #

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

genClosure_RegexEvalCallback :: RegexEvalCallback -> IO Closure #

mk_RegexEvalCallback :: C_RegexEvalCallback -> IO (FunPtr C_RegexEvalCallback) #

noRegexEvalCallback :: Maybe RegexEvalCallback #

noRegexEvalCallback_WithClosures :: Maybe RegexEvalCallback_WithClosures #

wrap_RegexEvalCallback :: Maybe (Ptr (FunPtr C_RegexEvalCallback)) -> RegexEvalCallback_WithClosures -> Ptr MatchInfo -> Ptr String -> Ptr () -> IO CInt #

ScannerMsgFunc

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

type ScannerMsgFunc = Scanner -> Text -> Bool -> IO () #

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

genClosure_ScannerMsgFunc :: ScannerMsgFunc -> IO Closure #

mk_ScannerMsgFunc :: C_ScannerMsgFunc -> IO (FunPtr C_ScannerMsgFunc) #

noScannerMsgFunc :: Maybe ScannerMsgFunc #

wrap_ScannerMsgFunc :: Maybe (Ptr (FunPtr C_ScannerMsgFunc)) -> ScannerMsgFunc -> Ptr Scanner -> CString -> CInt -> IO () #

SequenceIterCompareFunc

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

type SequenceIterCompareFunc = SequenceIter -> SequenceIter -> Ptr () -> IO Int32 #

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

genClosure_SequenceIterCompareFunc :: SequenceIterCompareFunc -> IO Closure #

mk_SequenceIterCompareFunc :: C_SequenceIterCompareFunc -> IO (FunPtr C_SequenceIterCompareFunc) #

noSequenceIterCompareFunc :: Maybe SequenceIterCompareFunc #

wrap_SequenceIterCompareFunc :: Maybe (Ptr (FunPtr C_SequenceIterCompareFunc)) -> SequenceIterCompareFunc -> Ptr SequenceIter -> Ptr SequenceIter -> Ptr () -> IO Int32 #

SourceCallbackFuncsRefFieldCallback

type C_SourceCallbackFuncsRefFieldCallback = Ptr () -> IO () #

type SourceCallbackFuncsRefFieldCallback = Ptr () -> IO () #

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

genClosure_SourceCallbackFuncsRefFieldCallback :: SourceCallbackFuncsRefFieldCallback -> IO Closure #

mk_SourceCallbackFuncsRefFieldCallback :: C_SourceCallbackFuncsRefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsRefFieldCallback) #

noSourceCallbackFuncsRefFieldCallback :: Maybe SourceCallbackFuncsRefFieldCallback #

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

SourceCallbackFuncsUnrefFieldCallback

type C_SourceCallbackFuncsUnrefFieldCallback = Ptr () -> IO () #

type SourceCallbackFuncsUnrefFieldCallback = Ptr () -> IO () #

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

genClosure_SourceCallbackFuncsUnrefFieldCallback :: SourceCallbackFuncsUnrefFieldCallback -> IO Closure #

mk_SourceCallbackFuncsUnrefFieldCallback :: C_SourceCallbackFuncsUnrefFieldCallback -> IO (FunPtr C_SourceCallbackFuncsUnrefFieldCallback) #

noSourceCallbackFuncsUnrefFieldCallback :: Maybe SourceCallbackFuncsUnrefFieldCallback #

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

SourceDummyMarshal

type C_SourceDummyMarshal = IO () #

type SourceDummyMarshal = IO () #

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

genClosure_SourceDummyMarshal :: SourceDummyMarshal -> IO Closure #

mk_SourceDummyMarshal :: C_SourceDummyMarshal -> IO (FunPtr C_SourceDummyMarshal) #

noSourceDummyMarshal :: Maybe SourceDummyMarshal #

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

SourceFunc

type C_SourceFunc = Ptr () -> IO CInt #

type SourceFunc = IO Bool #

type SourceFunc_WithClosures = Ptr () -> IO Bool #

drop_closures_SourceFunc :: SourceFunc -> SourceFunc_WithClosures #

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.

genClosure_SourceFunc :: SourceFunc -> IO Closure #

mk_SourceFunc :: C_SourceFunc -> IO (FunPtr C_SourceFunc) #

noSourceFunc :: Maybe SourceFunc #

noSourceFunc_WithClosures :: Maybe SourceFunc_WithClosures #

wrap_SourceFunc :: Maybe (Ptr (FunPtr C_SourceFunc)) -> SourceFunc_WithClosures -> Ptr () -> IO CInt #

SourceFuncsCheckFieldCallback

type C_SourceFuncsCheckFieldCallback = Ptr Source -> IO CInt #

type SourceFuncsCheckFieldCallback = Source -> IO Bool #

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

genClosure_SourceFuncsCheckFieldCallback :: SourceFuncsCheckFieldCallback -> IO Closure #

mk_SourceFuncsCheckFieldCallback :: C_SourceFuncsCheckFieldCallback -> IO (FunPtr C_SourceFuncsCheckFieldCallback) #

noSourceFuncsCheckFieldCallback :: Maybe SourceFuncsCheckFieldCallback #

wrap_SourceFuncsCheckFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsCheckFieldCallback)) -> SourceFuncsCheckFieldCallback -> Ptr Source -> IO CInt #

SourceFuncsFinalizeFieldCallback

type C_SourceFuncsFinalizeFieldCallback = Ptr Source -> IO () #

type SourceFuncsFinalizeFieldCallback = Source -> IO () #

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

genClosure_SourceFuncsFinalizeFieldCallback :: SourceFuncsFinalizeFieldCallback -> IO Closure #

mk_SourceFuncsFinalizeFieldCallback :: C_SourceFuncsFinalizeFieldCallback -> IO (FunPtr C_SourceFuncsFinalizeFieldCallback) #

noSourceFuncsFinalizeFieldCallback :: Maybe SourceFuncsFinalizeFieldCallback #

wrap_SourceFuncsFinalizeFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsFinalizeFieldCallback)) -> SourceFuncsFinalizeFieldCallback -> Ptr Source -> IO () #

SourceFuncsPrepareFieldCallback

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

type SourceFuncsPrepareFieldCallback = Source -> Int32 -> IO Bool #

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

genClosure_SourceFuncsPrepareFieldCallback :: SourceFuncsPrepareFieldCallback -> IO Closure #

mk_SourceFuncsPrepareFieldCallback :: C_SourceFuncsPrepareFieldCallback -> IO (FunPtr C_SourceFuncsPrepareFieldCallback) #

noSourceFuncsPrepareFieldCallback :: Maybe SourceFuncsPrepareFieldCallback #

wrap_SourceFuncsPrepareFieldCallback :: Maybe (Ptr (FunPtr C_SourceFuncsPrepareFieldCallback)) -> SourceFuncsPrepareFieldCallback -> Ptr Source -> Int32 -> IO CInt #

SpawnChildSetupFunc

type C_SpawnChildSetupFunc = Ptr () -> IO () #

type SpawnChildSetupFunc = IO () #

type SpawnChildSetupFunc_WithClosures = Ptr () -> IO () #

drop_closures_SpawnChildSetupFunc :: SpawnChildSetupFunc -> SpawnChildSetupFunc_WithClosures #

dynamic_SpawnChildSetupFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_SpawnChildSetupFunc
-> Ptr ()	`userData`: user data to pass to the function.
-> m ()

genClosure_SpawnChildSetupFunc :: SpawnChildSetupFunc -> IO Closure #

mk_SpawnChildSetupFunc :: C_SpawnChildSetupFunc -> IO (FunPtr C_SpawnChildSetupFunc) #

noSpawnChildSetupFunc :: Maybe SpawnChildSetupFunc #

noSpawnChildSetupFunc_WithClosures :: Maybe SpawnChildSetupFunc_WithClosures #

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

TestDataFunc

type C_TestDataFunc = Ptr () -> IO () #

type TestDataFunc = IO () #

type TestDataFunc_WithClosures = Ptr () -> IO () #

drop_closures_TestDataFunc :: TestDataFunc -> TestDataFunc_WithClosures #

dynamic_TestDataFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_TestDataFunc
-> Ptr ()	`userData`: the data provided when registering the test
-> m ()

genClosure_TestDataFunc :: TestDataFunc -> IO Closure #

mk_TestDataFunc :: C_TestDataFunc -> IO (FunPtr C_TestDataFunc) #

noTestDataFunc :: Maybe TestDataFunc #

noTestDataFunc_WithClosures :: Maybe TestDataFunc_WithClosures #

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

TestFixtureFunc

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

type TestFixtureFunc = Ptr () -> IO () #

type TestFixtureFunc_WithClosures = Ptr () -> Ptr () -> IO () #

drop_closures_TestFixtureFunc :: TestFixtureFunc -> TestFixtureFunc_WithClosures #

dynamic_TestFixtureFunc #

Arguments

:: (HasCallStack, MonadIO m)
=> FunPtr C_TestFixtureFunc
-> Ptr ()	`fixture`: the test fixture
-> Ptr ()	`userData`: the data provided when registering the test
-> m ()

genClosure_TestFixtureFunc :: TestFixtureFunc -> IO Closure #

mk_TestFixtureFunc :: C_TestFixtureFunc -> IO (FunPtr C_TestFixtureFunc) #

noTestFixtureFunc :: Maybe TestFixtureFunc #

noTestFixtureFunc_WithClosures :: Maybe TestFixtureFunc_WithClosures #

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

TestFunc

type C_TestFunc = IO () #

type TestFunc = IO () #

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

genClosure_TestFunc :: TestFunc -> IO Closure #

mk_TestFunc :: C_TestFunc -> IO (FunPtr C_TestFunc) #

noTestFunc :: Maybe TestFunc #

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

TestLogFatalFunc

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

type TestLogFatalFunc = Text -> [LogLevelFlags] -> Text -> IO Bool #

type TestLogFatalFunc_WithClosures = Text -> [LogLevelFlags] -> Text -> Ptr () -> IO Bool #

drop_closures_TestLogFatalFunc :: TestLogFatalFunc -> TestLogFatalFunc_WithClosures #

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

genClosure_TestLogFatalFunc :: TestLogFatalFunc -> IO Closure #

mk_TestLogFatalFunc :: C_TestLogFatalFunc -> IO (FunPtr C_TestLogFatalFunc) #

noTestLogFatalFunc :: Maybe TestLogFatalFunc #

noTestLogFatalFunc_WithClosures :: Maybe TestLogFatalFunc_WithClosures #

wrap_TestLogFatalFunc :: Maybe (Ptr (FunPtr C_TestLogFatalFunc)) -> TestLogFatalFunc_WithClosures -> CString -> CUInt -> CString -> Ptr () -> IO CInt #

ThreadFunc

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

type ThreadFunc = Ptr () -> IO (Ptr ()) #

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

genClosure_ThreadFunc :: ThreadFunc -> IO Closure #

mk_ThreadFunc :: C_ThreadFunc -> IO (FunPtr C_ThreadFunc) #

noThreadFunc :: Maybe ThreadFunc #

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

TranslateFunc

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

type TranslateFunc = Text -> Ptr () -> IO Text #

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.

genClosure_TranslateFunc :: TranslateFunc -> IO Closure #

mk_TranslateFunc :: C_TranslateFunc -> IO (FunPtr C_TranslateFunc) #

noTranslateFunc :: Maybe TranslateFunc #

wrap_TranslateFunc :: Maybe (Ptr (FunPtr C_TranslateFunc)) -> TranslateFunc -> CString -> Ptr () -> IO CString #

TraverseFunc

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

type TraverseFunc = Ptr () -> Ptr () -> Ptr () -> IO Bool #

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

genClosure_TraverseFunc :: TraverseFunc -> IO Closure #

mk_TraverseFunc :: C_TraverseFunc -> IO (FunPtr C_TraverseFunc) #

noTraverseFunc :: Maybe TraverseFunc #

wrap_TraverseFunc :: Maybe (Ptr (FunPtr C_TraverseFunc)) -> TraverseFunc -> Ptr () -> Ptr () -> Ptr () -> IO CInt #

UnixFDSourceFunc

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

type UnixFDSourceFunc = Int32 -> [IOCondition] -> IO Bool #

type UnixFDSourceFunc_WithClosures = Int32 -> [IOCondition] -> Ptr () -> IO Bool #

drop_closures_UnixFDSourceFunc :: UnixFDSourceFunc -> UnixFDSourceFunc_WithClosures #

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

genClosure_UnixFDSourceFunc :: UnixFDSourceFunc -> IO Closure #

mk_UnixFDSourceFunc :: C_UnixFDSourceFunc -> IO (FunPtr C_UnixFDSourceFunc) #

noUnixFDSourceFunc :: Maybe UnixFDSourceFunc #

noUnixFDSourceFunc_WithClosures :: Maybe UnixFDSourceFunc_WithClosures #

wrap_UnixFDSourceFunc :: Maybe (Ptr (FunPtr C_UnixFDSourceFunc)) -> UnixFDSourceFunc_WithClosures -> Int32 -> CUInt -> Ptr () -> IO CInt #

VoidFunc

type C_VoidFunc = IO () #

type VoidFunc = IO () #

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

genClosure_VoidFunc :: VoidFunc -> IO Closure #

mk_VoidFunc :: C_VoidFunc -> IO (FunPtr C_VoidFunc) #

noVoidFunc :: Maybe VoidFunc #

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