GI.GLib.Callbacks

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