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 :: MonadIO m => FunPtr C_ChildWatchFunc -> Int32 -> Int32 -> Ptr () -> 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 :: MonadIO m => FunPtr C_CompareDataFunc -> Ptr () -> Ptr () -> Ptr () -> m Int32

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 :: MonadIO m => FunPtr C_CompareFunc -> Ptr () -> Ptr () -> m Int32

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 :: MonadIO m => FunPtr C_CopyFunc -> Ptr () -> Ptr () -> m (Ptr ())

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 :: MonadIO m => FunPtr C_DataForeachFunc -> Word32 -> Ptr () -> Ptr () -> 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 :: MonadIO m => FunPtr C_DestroyNotify -> Ptr () -> 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 :: MonadIO m => FunPtr C_DuplicateFunc -> Ptr () -> Ptr () -> m (Ptr ())

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 :: MonadIO m => FunPtr C_EqualFunc -> Ptr () -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_FreeFunc -> Ptr () -> 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 :: MonadIO m => FunPtr C_Func -> Ptr () -> Ptr () -> 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 :: MonadIO m => FunPtr C_HFunc -> Ptr () -> Ptr () -> Ptr () -> 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 :: MonadIO m => FunPtr C_HRFunc -> Ptr () -> Ptr () -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_HashFunc -> Ptr () -> m Word32

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 :: MonadIO m => FunPtr C_HookCheckFunc -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_HookCheckMarshaller -> Hook -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_HookCompareFunc -> Hook -> Hook -> m Int32

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 :: MonadIO m => FunPtr C_HookFinalizeFunc -> HookList -> Hook -> 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 :: MonadIO m => FunPtr C_HookFindFunc -> Hook -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_HookFunc -> Ptr () -> 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 :: MonadIO m => FunPtr C_HookMarshaller -> Hook -> Ptr () -> 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 :: MonadIO m => FunPtr C_IOFunc -> IOChannel -> [IOCondition] -> Ptr () -> m Bool

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 -> IO CUInt

type IOFuncsIoCloseFieldCallback = IOChannel -> IO IOStatus

dynamic_IOFuncsIoCloseFieldCallback :: MonadIO m => FunPtr C_IOFuncsIoCloseFieldCallback -> IOChannel -> m IOStatus

genClosure_IOFuncsIoCloseFieldCallback :: IOFuncsIoCloseFieldCallback -> IO Closure

mk_IOFuncsIoCloseFieldCallback :: C_IOFuncsIoCloseFieldCallback -> IO (FunPtr C_IOFuncsIoCloseFieldCallback)

noIOFuncsIoCloseFieldCallback :: Maybe IOFuncsIoCloseFieldCallback

wrap_IOFuncsIoCloseFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoCloseFieldCallback)) -> IOFuncsIoCloseFieldCallback -> Ptr IOChannel -> IO CUInt

IOFuncsIoCreateWatchFieldCallback

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

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

dynamic_IOFuncsIoCreateWatchFieldCallback :: 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 :: 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 :: 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 -> IO CUInt

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

dynamic_IOFuncsIoReadFieldCallback :: MonadIO m => FunPtr C_IOFuncsIoReadFieldCallback -> IOChannel -> Text -> Word64 -> Word64 -> m IOStatus

genClosure_IOFuncsIoReadFieldCallback :: IOFuncsIoReadFieldCallback -> IO Closure

mk_IOFuncsIoReadFieldCallback :: C_IOFuncsIoReadFieldCallback -> IO (FunPtr C_IOFuncsIoReadFieldCallback)

noIOFuncsIoReadFieldCallback :: Maybe IOFuncsIoReadFieldCallback

wrap_IOFuncsIoReadFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoReadFieldCallback)) -> IOFuncsIoReadFieldCallback -> Ptr IOChannel -> CString -> Word64 -> Word64 -> IO CUInt

IOFuncsIoSeekFieldCallback

type C_IOFuncsIoSeekFieldCallback = Ptr IOChannel -> Int64 -> CUInt -> IO CUInt

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

dynamic_IOFuncsIoSeekFieldCallback :: MonadIO m => FunPtr C_IOFuncsIoSeekFieldCallback -> IOChannel -> Int64 -> SeekType -> m IOStatus

genClosure_IOFuncsIoSeekFieldCallback :: IOFuncsIoSeekFieldCallback -> IO Closure

mk_IOFuncsIoSeekFieldCallback :: C_IOFuncsIoSeekFieldCallback -> IO (FunPtr C_IOFuncsIoSeekFieldCallback)

noIOFuncsIoSeekFieldCallback :: Maybe IOFuncsIoSeekFieldCallback

wrap_IOFuncsIoSeekFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoSeekFieldCallback)) -> IOFuncsIoSeekFieldCallback -> Ptr IOChannel -> Int64 -> CUInt -> IO CUInt

IOFuncsIoSetFlagsFieldCallback

type C_IOFuncsIoSetFlagsFieldCallback = Ptr IOChannel -> CUInt -> IO CUInt

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

dynamic_IOFuncsIoSetFlagsFieldCallback :: MonadIO m => FunPtr C_IOFuncsIoSetFlagsFieldCallback -> IOChannel -> [IOFlags] -> m IOStatus

genClosure_IOFuncsIoSetFlagsFieldCallback :: IOFuncsIoSetFlagsFieldCallback -> IO Closure

mk_IOFuncsIoSetFlagsFieldCallback :: C_IOFuncsIoSetFlagsFieldCallback -> IO (FunPtr C_IOFuncsIoSetFlagsFieldCallback)

noIOFuncsIoSetFlagsFieldCallback :: Maybe IOFuncsIoSetFlagsFieldCallback

wrap_IOFuncsIoSetFlagsFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoSetFlagsFieldCallback)) -> IOFuncsIoSetFlagsFieldCallback -> Ptr IOChannel -> CUInt -> IO CUInt

IOFuncsIoWriteFieldCallback

type C_IOFuncsIoWriteFieldCallback = Ptr IOChannel -> CString -> Word64 -> Word64 -> IO CUInt

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

dynamic_IOFuncsIoWriteFieldCallback :: MonadIO m => FunPtr C_IOFuncsIoWriteFieldCallback -> IOChannel -> Text -> Word64 -> Word64 -> m IOStatus

genClosure_IOFuncsIoWriteFieldCallback :: IOFuncsIoWriteFieldCallback -> IO Closure

mk_IOFuncsIoWriteFieldCallback :: C_IOFuncsIoWriteFieldCallback -> IO (FunPtr C_IOFuncsIoWriteFieldCallback)

noIOFuncsIoWriteFieldCallback :: Maybe IOFuncsIoWriteFieldCallback

wrap_IOFuncsIoWriteFieldCallback :: Maybe (Ptr (FunPtr C_IOFuncsIoWriteFieldCallback)) -> IOFuncsIoWriteFieldCallback -> Ptr IOChannel -> CString -> Word64 -> Word64 -> IO CUInt

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 :: MonadIO m => FunPtr C_LogFunc -> Text -> [LogLevelFlags] -> Text -> Ptr () -> 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 ()

MarkupParserEndElementFieldCallback

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

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

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

drop_closures_MarkupParserEndElementFieldCallback :: MarkupParserEndElementFieldCallback -> MarkupParserEndElementFieldCallback_WithClosures

dynamic_MarkupParserEndElementFieldCallback :: MonadIO m => FunPtr C_MarkupParserEndElementFieldCallback -> MarkupParseContext -> Text -> Ptr () -> m ()

genClosure_MarkupParserEndElementFieldCallback :: MarkupParserEndElementFieldCallback -> IO Closure

mk_MarkupParserEndElementFieldCallback :: C_MarkupParserEndElementFieldCallback -> IO (FunPtr C_MarkupParserEndElementFieldCallback)

noMarkupParserEndElementFieldCallback :: Maybe MarkupParserEndElementFieldCallback

noMarkupParserEndElementFieldCallback_WithClosures :: Maybe MarkupParserEndElementFieldCallback_WithClosures

wrap_MarkupParserEndElementFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserEndElementFieldCallback)) -> MarkupParserEndElementFieldCallback_WithClosures -> Ptr MarkupParseContext -> CString -> Ptr () -> IO ()

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

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

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

drop_closures_MarkupParserPassthroughFieldCallback :: MarkupParserPassthroughFieldCallback -> MarkupParserPassthroughFieldCallback_WithClosures

dynamic_MarkupParserPassthroughFieldCallback :: MonadIO m => FunPtr C_MarkupParserPassthroughFieldCallback -> MarkupParseContext -> Text -> Word64 -> Ptr () -> m ()

genClosure_MarkupParserPassthroughFieldCallback :: MarkupParserPassthroughFieldCallback -> IO Closure

mk_MarkupParserPassthroughFieldCallback :: C_MarkupParserPassthroughFieldCallback -> IO (FunPtr C_MarkupParserPassthroughFieldCallback)

noMarkupParserPassthroughFieldCallback :: Maybe MarkupParserPassthroughFieldCallback

noMarkupParserPassthroughFieldCallback_WithClosures :: Maybe MarkupParserPassthroughFieldCallback_WithClosures

wrap_MarkupParserPassthroughFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserPassthroughFieldCallback)) -> MarkupParserPassthroughFieldCallback_WithClosures -> Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> IO ()

MarkupParserStartElementFieldCallback

type C_MarkupParserStartElementFieldCallback = Ptr MarkupParseContext -> CString -> CString -> CString -> Ptr () -> 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 :: MonadIO m => FunPtr C_MarkupParserStartElementFieldCallback -> MarkupParseContext -> Text -> Text -> Text -> Ptr () -> m ()

genClosure_MarkupParserStartElementFieldCallback :: MarkupParserStartElementFieldCallback -> IO Closure

mk_MarkupParserStartElementFieldCallback :: C_MarkupParserStartElementFieldCallback -> IO (FunPtr C_MarkupParserStartElementFieldCallback)

noMarkupParserStartElementFieldCallback :: Maybe MarkupParserStartElementFieldCallback

noMarkupParserStartElementFieldCallback_WithClosures :: Maybe MarkupParserStartElementFieldCallback_WithClosures

wrap_MarkupParserStartElementFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserStartElementFieldCallback)) -> MarkupParserStartElementFieldCallback_WithClosures -> Ptr MarkupParseContext -> CString -> CString -> CString -> Ptr () -> IO ()

MarkupParserTextFieldCallback

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

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

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

drop_closures_MarkupParserTextFieldCallback :: MarkupParserTextFieldCallback -> MarkupParserTextFieldCallback_WithClosures

dynamic_MarkupParserTextFieldCallback :: MonadIO m => FunPtr C_MarkupParserTextFieldCallback -> MarkupParseContext -> Text -> Word64 -> Ptr () -> m ()

genClosure_MarkupParserTextFieldCallback :: MarkupParserTextFieldCallback -> IO Closure

mk_MarkupParserTextFieldCallback :: C_MarkupParserTextFieldCallback -> IO (FunPtr C_MarkupParserTextFieldCallback)

noMarkupParserTextFieldCallback :: Maybe MarkupParserTextFieldCallback

noMarkupParserTextFieldCallback_WithClosures :: Maybe MarkupParserTextFieldCallback_WithClosures

wrap_MarkupParserTextFieldCallback :: Maybe (Ptr (FunPtr C_MarkupParserTextFieldCallback)) -> MarkupParserTextFieldCallback_WithClosures -> Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> IO ()

MemVTableCallocFieldCallback

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

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

dynamic_MemVTableCallocFieldCallback :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: MonadIO m => FunPtr C_NodeForeachFunc -> Node -> Ptr () -> 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 :: MonadIO m => FunPtr C_NodeTraverseFunc -> Node -> Ptr () -> m Bool

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

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

dynamic_OptionArgFunc :: MonadIO m => FunPtr C_OptionArgFunc -> Text -> Text -> Ptr () -> m Bool

genClosure_OptionArgFunc :: OptionArgFunc -> IO Closure

mk_OptionArgFunc :: C_OptionArgFunc -> IO (FunPtr C_OptionArgFunc)

noOptionArgFunc :: Maybe OptionArgFunc

wrap_OptionArgFunc :: Maybe (Ptr (FunPtr C_OptionArgFunc)) -> OptionArgFunc -> CString -> CString -> Ptr () -> IO CInt

OptionErrorFunc

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

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

dynamic_OptionErrorFunc :: MonadIO m => FunPtr C_OptionErrorFunc -> OptionContext -> OptionGroup -> Ptr () -> m ()

genClosure_OptionErrorFunc :: OptionErrorFunc -> IO Closure

mk_OptionErrorFunc :: C_OptionErrorFunc -> IO (FunPtr C_OptionErrorFunc)

noOptionErrorFunc :: Maybe OptionErrorFunc

wrap_OptionErrorFunc :: Maybe (Ptr (FunPtr C_OptionErrorFunc)) -> OptionErrorFunc -> Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> IO ()

OptionParseFunc

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

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

dynamic_OptionParseFunc :: MonadIO m => FunPtr C_OptionParseFunc -> OptionContext -> OptionGroup -> Ptr () -> m Bool

genClosure_OptionParseFunc :: OptionParseFunc -> IO Closure

mk_OptionParseFunc :: C_OptionParseFunc -> IO (FunPtr C_OptionParseFunc)

noOptionParseFunc :: Maybe OptionParseFunc

wrap_OptionParseFunc :: Maybe (Ptr (FunPtr C_OptionParseFunc)) -> OptionParseFunc -> Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> IO CInt

PollFunc

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

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

dynamic_PollFunc :: MonadIO m => FunPtr C_PollFunc -> PollFD -> Word32 -> Int32 -> m Int32

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 :: MonadIO m => FunPtr C_PrintFunc -> Text -> 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 :: MonadIO m => FunPtr C_RegexEvalCallback -> MatchInfo -> String -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_ScannerMsgFunc -> Scanner -> Text -> Bool -> 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 :: MonadIO m => FunPtr C_SequenceIterCompareFunc -> SequenceIter -> SequenceIter -> Ptr () -> m Int32

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 :: 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 :: 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 :: 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 :: MonadIO m => FunPtr C_SourceFunc -> Ptr () -> m Bool

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 :: 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 :: 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 :: 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 :: MonadIO m => FunPtr C_SpawnChildSetupFunc -> Ptr () -> 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 :: MonadIO m => FunPtr C_TestDataFunc -> Ptr () -> 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 :: MonadIO m => FunPtr C_TestFixtureFunc -> Ptr () -> Ptr () -> 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 :: 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 :: MonadIO m => FunPtr C_TestLogFatalFunc -> Text -> [LogLevelFlags] -> Text -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_ThreadFunc -> Ptr () -> m (Ptr ())

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 :: MonadIO m => FunPtr C_TranslateFunc -> Text -> Ptr () -> m Text

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 :: MonadIO m => FunPtr C_TraverseFunc -> Ptr () -> Ptr () -> Ptr () -> m Bool

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 :: MonadIO m => FunPtr C_UnixFDSourceFunc -> Int32 -> [IOCondition] -> Ptr () -> m Bool

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