GI.GLib.Callbacks

Signals

ChildWatchFunc

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

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

childWatchFuncClosure :: ChildWatchFunc -> IO Closure

childWatchFuncWrapper :: Maybe (Ptr (FunPtr ChildWatchFuncC)) -> ChildWatchFunc -> Int32 -> Int32 -> Ptr () -> IO ()

mkChildWatchFunc :: ChildWatchFuncC -> IO (FunPtr ChildWatchFuncC)

noChildWatchFunc :: Maybe ChildWatchFunc

CompareDataFunc

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

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

compareDataFuncClosure :: CompareDataFunc -> IO Closure

compareDataFuncWrapper :: Maybe (Ptr (FunPtr CompareDataFuncC)) -> CompareDataFunc -> Ptr () -> Ptr () -> Ptr () -> IO Int32

mkCompareDataFunc :: CompareDataFuncC -> IO (FunPtr CompareDataFuncC)

noCompareDataFunc :: Maybe CompareDataFunc

CompareFunc

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

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

compareFuncClosure :: CompareFunc -> IO Closure

compareFuncWrapper :: Maybe (Ptr (FunPtr CompareFuncC)) -> CompareFunc -> Ptr () -> Ptr () -> IO Int32

mkCompareFunc :: CompareFuncC -> IO (FunPtr CompareFuncC)

noCompareFunc :: Maybe CompareFunc

CopyFunc

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

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

copyFuncClosure :: CopyFunc -> IO Closure

copyFuncWrapper :: Maybe (Ptr (FunPtr CopyFuncC)) -> CopyFunc -> Ptr () -> Ptr () -> IO (Ptr ())

mkCopyFunc :: CopyFuncC -> IO (FunPtr CopyFuncC)

noCopyFunc :: Maybe CopyFunc

DataForeachFunc

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

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

dataForeachFuncClosure :: DataForeachFunc -> IO Closure

dataForeachFuncWrapper :: Maybe (Ptr (FunPtr DataForeachFuncC)) -> DataForeachFunc -> Word32 -> Ptr () -> Ptr () -> IO ()

mkDataForeachFunc :: DataForeachFuncC -> IO (FunPtr DataForeachFuncC)

noDataForeachFunc :: Maybe DataForeachFunc

DestroyNotify

type DestroyNotify = Ptr () -> IO ()

type DestroyNotifyC = Ptr () -> IO ()

destroyNotifyClosure :: DestroyNotify -> IO Closure

destroyNotifyWrapper :: Maybe (Ptr (FunPtr DestroyNotifyC)) -> DestroyNotify -> Ptr () -> IO ()

mkDestroyNotify :: DestroyNotifyC -> IO (FunPtr DestroyNotifyC)

noDestroyNotify :: Maybe DestroyNotify

DuplicateFunc

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

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

duplicateFuncClosure :: DuplicateFunc -> IO Closure

duplicateFuncWrapper :: Maybe (Ptr (FunPtr DuplicateFuncC)) -> DuplicateFunc -> Ptr () -> Ptr () -> IO (Ptr ())

mkDuplicateFunc :: DuplicateFuncC -> IO (FunPtr DuplicateFuncC)

noDuplicateFunc :: Maybe DuplicateFunc

EqualFunc

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

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

equalFuncClosure :: EqualFunc -> IO Closure

equalFuncWrapper :: Maybe (Ptr (FunPtr EqualFuncC)) -> EqualFunc -> Ptr () -> Ptr () -> IO CInt

mkEqualFunc :: EqualFuncC -> IO (FunPtr EqualFuncC)

noEqualFunc :: Maybe EqualFunc

FreeFunc

type FreeFunc = Ptr () -> IO ()

type FreeFuncC = Ptr () -> IO ()

freeFuncClosure :: FreeFunc -> IO Closure

freeFuncWrapper :: Maybe (Ptr (FunPtr FreeFuncC)) -> FreeFunc -> Ptr () -> IO ()

mkFreeFunc :: FreeFuncC -> IO (FunPtr FreeFuncC)

noFreeFunc :: Maybe FreeFunc

Func

type Func = Ptr () -> IO ()

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

funcClosure :: Func -> IO Closure

funcWrapper :: Maybe (Ptr (FunPtr FuncC)) -> Func -> Ptr () -> Ptr () -> IO ()

mkFunc :: FuncC -> IO (FunPtr FuncC)

noFunc :: Maybe Func

HFunc

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

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

hFuncClosure :: HFunc -> IO Closure

hFuncWrapper :: Maybe (Ptr (FunPtr HFuncC)) -> HFunc -> Ptr () -> Ptr () -> Ptr () -> IO ()

mkHFunc :: HFuncC -> IO (FunPtr HFuncC)

noHFunc :: Maybe HFunc

HRFunc

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

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

hRFuncClosure :: HRFunc -> IO Closure

hRFuncWrapper :: Maybe (Ptr (FunPtr HRFuncC)) -> HRFunc -> Ptr () -> Ptr () -> Ptr () -> IO CInt

mkHRFunc :: HRFuncC -> IO (FunPtr HRFuncC)

noHRFunc :: Maybe HRFunc

HashFunc

type HashFunc = Ptr () -> IO Word32

type HashFuncC = Ptr () -> IO Word32

hashFuncClosure :: HashFunc -> IO Closure

hashFuncWrapper :: Maybe (Ptr (FunPtr HashFuncC)) -> HashFunc -> Ptr () -> IO Word32

mkHashFunc :: HashFuncC -> IO (FunPtr HashFuncC)

noHashFunc :: Maybe HashFunc

HookCheckFunc

type HookCheckFunc = Ptr () -> IO Bool

type HookCheckFuncC = Ptr () -> IO CInt

hookCheckFuncClosure :: HookCheckFunc -> IO Closure

hookCheckFuncWrapper :: Maybe (Ptr (FunPtr HookCheckFuncC)) -> HookCheckFunc -> Ptr () -> IO CInt

mkHookCheckFunc :: HookCheckFuncC -> IO (FunPtr HookCheckFuncC)

noHookCheckFunc :: Maybe HookCheckFunc

HookCheckMarshaller

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

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

hookCheckMarshallerClosure :: HookCheckMarshaller -> IO Closure

hookCheckMarshallerWrapper :: Maybe (Ptr (FunPtr HookCheckMarshallerC)) -> HookCheckMarshaller -> Ptr Hook -> Ptr () -> IO CInt

mkHookCheckMarshaller :: HookCheckMarshallerC -> IO (FunPtr HookCheckMarshallerC)

noHookCheckMarshaller :: Maybe HookCheckMarshaller

HookCompareFunc

type HookCompareFunc = Hook -> Hook -> IO Int32

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

hookCompareFuncClosure :: HookCompareFunc -> IO Closure

hookCompareFuncWrapper :: Maybe (Ptr (FunPtr HookCompareFuncC)) -> HookCompareFunc -> Ptr Hook -> Ptr Hook -> IO Int32

mkHookCompareFunc :: HookCompareFuncC -> IO (FunPtr HookCompareFuncC)

noHookCompareFunc :: Maybe HookCompareFunc

HookFinalizeFunc

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

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

hookFinalizeFuncClosure :: HookFinalizeFunc -> IO Closure

hookFinalizeFuncWrapper :: Maybe (Ptr (FunPtr HookFinalizeFuncC)) -> HookFinalizeFunc -> Ptr HookList -> Ptr Hook -> IO ()

mkHookFinalizeFunc :: HookFinalizeFuncC -> IO (FunPtr HookFinalizeFuncC)

noHookFinalizeFunc :: Maybe HookFinalizeFunc

HookFindFunc

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

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

hookFindFuncClosure :: HookFindFunc -> IO Closure

hookFindFuncWrapper :: Maybe (Ptr (FunPtr HookFindFuncC)) -> HookFindFunc -> Ptr Hook -> Ptr () -> IO CInt

mkHookFindFunc :: HookFindFuncC -> IO (FunPtr HookFindFuncC)

noHookFindFunc :: Maybe HookFindFunc

HookFunc

type HookFunc = Ptr () -> IO ()

type HookFuncC = Ptr () -> IO ()

hookFuncClosure :: HookFunc -> IO Closure

hookFuncWrapper :: Maybe (Ptr (FunPtr HookFuncC)) -> HookFunc -> Ptr () -> IO ()

mkHookFunc :: HookFuncC -> IO (FunPtr HookFuncC)

noHookFunc :: Maybe HookFunc

HookMarshaller

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

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

hookMarshallerClosure :: HookMarshaller -> IO Closure

hookMarshallerWrapper :: Maybe (Ptr (FunPtr HookMarshallerC)) -> HookMarshaller -> Ptr Hook -> Ptr () -> IO ()

mkHookMarshaller :: HookMarshallerC -> IO (FunPtr HookMarshallerC)

noHookMarshaller :: Maybe HookMarshaller

IOFunc

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

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

iOFuncClosure :: IOFunc -> IO Closure

iOFuncWrapper :: Maybe (Ptr (FunPtr IOFuncC)) -> IOFunc -> Ptr IOChannel -> CUInt -> Ptr () -> IO CInt

mkIOFunc :: IOFuncC -> IO (FunPtr IOFuncC)

noIOFunc :: Maybe IOFunc

IOFuncsIoCloseFieldCallback

type IOFuncsIoCloseFieldCallback = IOChannel -> IO IOStatus

type IOFuncsIoCloseFieldCallbackC = Ptr IOChannel -> IO CUInt

iOFuncsIoCloseFieldCallbackClosure :: IOFuncsIoCloseFieldCallback -> IO Closure

iOFuncsIoCloseFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoCloseFieldCallbackC)) -> IOFuncsIoCloseFieldCallback -> Ptr IOChannel -> IO CUInt

mkIOFuncsIoCloseFieldCallback :: IOFuncsIoCloseFieldCallbackC -> IO (FunPtr IOFuncsIoCloseFieldCallbackC)

noIOFuncsIoCloseFieldCallback :: Maybe IOFuncsIoCloseFieldCallback

IOFuncsIoCreateWatchFieldCallback

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

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

iOFuncsIoCreateWatchFieldCallbackClosure :: IOFuncsIoCreateWatchFieldCallback -> IO Closure

iOFuncsIoCreateWatchFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoCreateWatchFieldCallbackC)) -> IOFuncsIoCreateWatchFieldCallback -> Ptr IOChannel -> CUInt -> IO (Ptr Source)

mkIOFuncsIoCreateWatchFieldCallback :: IOFuncsIoCreateWatchFieldCallbackC -> IO (FunPtr IOFuncsIoCreateWatchFieldCallbackC)

noIOFuncsIoCreateWatchFieldCallback :: Maybe IOFuncsIoCreateWatchFieldCallback

IOFuncsIoFreeFieldCallback

type IOFuncsIoFreeFieldCallback = IOChannel -> IO ()

type IOFuncsIoFreeFieldCallbackC = Ptr IOChannel -> IO ()

iOFuncsIoFreeFieldCallbackClosure :: IOFuncsIoFreeFieldCallback -> IO Closure

iOFuncsIoFreeFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoFreeFieldCallbackC)) -> IOFuncsIoFreeFieldCallback -> Ptr IOChannel -> IO ()

mkIOFuncsIoFreeFieldCallback :: IOFuncsIoFreeFieldCallbackC -> IO (FunPtr IOFuncsIoFreeFieldCallbackC)

noIOFuncsIoFreeFieldCallback :: Maybe IOFuncsIoFreeFieldCallback

IOFuncsIoGetFlagsFieldCallback

type IOFuncsIoGetFlagsFieldCallback = IOChannel -> IO [IOFlags]

type IOFuncsIoGetFlagsFieldCallbackC = Ptr IOChannel -> IO CUInt

iOFuncsIoGetFlagsFieldCallbackClosure :: IOFuncsIoGetFlagsFieldCallback -> IO Closure

iOFuncsIoGetFlagsFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoGetFlagsFieldCallbackC)) -> IOFuncsIoGetFlagsFieldCallback -> Ptr IOChannel -> IO CUInt

mkIOFuncsIoGetFlagsFieldCallback :: IOFuncsIoGetFlagsFieldCallbackC -> IO (FunPtr IOFuncsIoGetFlagsFieldCallbackC)

noIOFuncsIoGetFlagsFieldCallback :: Maybe IOFuncsIoGetFlagsFieldCallback

IOFuncsIoReadFieldCallback

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

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

iOFuncsIoReadFieldCallbackClosure :: IOFuncsIoReadFieldCallback -> IO Closure

iOFuncsIoReadFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoReadFieldCallbackC)) -> IOFuncsIoReadFieldCallback -> Ptr IOChannel -> CString -> Word64 -> Word64 -> IO CUInt

mkIOFuncsIoReadFieldCallback :: IOFuncsIoReadFieldCallbackC -> IO (FunPtr IOFuncsIoReadFieldCallbackC)

noIOFuncsIoReadFieldCallback :: Maybe IOFuncsIoReadFieldCallback

IOFuncsIoSeekFieldCallback

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

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

iOFuncsIoSeekFieldCallbackClosure :: IOFuncsIoSeekFieldCallback -> IO Closure

iOFuncsIoSeekFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoSeekFieldCallbackC)) -> IOFuncsIoSeekFieldCallback -> Ptr IOChannel -> Int64 -> CUInt -> IO CUInt

mkIOFuncsIoSeekFieldCallback :: IOFuncsIoSeekFieldCallbackC -> IO (FunPtr IOFuncsIoSeekFieldCallbackC)

noIOFuncsIoSeekFieldCallback :: Maybe IOFuncsIoSeekFieldCallback

IOFuncsIoSetFlagsFieldCallback

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

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

iOFuncsIoSetFlagsFieldCallbackClosure :: IOFuncsIoSetFlagsFieldCallback -> IO Closure

iOFuncsIoSetFlagsFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoSetFlagsFieldCallbackC)) -> IOFuncsIoSetFlagsFieldCallback -> Ptr IOChannel -> CUInt -> IO CUInt

mkIOFuncsIoSetFlagsFieldCallback :: IOFuncsIoSetFlagsFieldCallbackC -> IO (FunPtr IOFuncsIoSetFlagsFieldCallbackC)

noIOFuncsIoSetFlagsFieldCallback :: Maybe IOFuncsIoSetFlagsFieldCallback

IOFuncsIoWriteFieldCallback

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

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

iOFuncsIoWriteFieldCallbackClosure :: IOFuncsIoWriteFieldCallback -> IO Closure

iOFuncsIoWriteFieldCallbackWrapper :: Maybe (Ptr (FunPtr IOFuncsIoWriteFieldCallbackC)) -> IOFuncsIoWriteFieldCallback -> Ptr IOChannel -> CString -> Word64 -> Word64 -> IO CUInt

mkIOFuncsIoWriteFieldCallback :: IOFuncsIoWriteFieldCallbackC -> IO (FunPtr IOFuncsIoWriteFieldCallbackC)

noIOFuncsIoWriteFieldCallback :: Maybe IOFuncsIoWriteFieldCallback

LogFunc

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

type LogFuncC = CString -> CUInt -> CString -> Ptr () -> IO ()

logFuncClosure :: LogFunc -> IO Closure

logFuncWrapper :: Maybe (Ptr (FunPtr LogFuncC)) -> LogFunc -> CString -> CUInt -> CString -> Ptr () -> IO ()

mkLogFunc :: LogFuncC -> IO (FunPtr LogFuncC)

noLogFunc :: Maybe LogFunc

MarkupParserEndElementFieldCallback

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

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

markupParserEndElementFieldCallbackClosure :: MarkupParserEndElementFieldCallback -> IO Closure

markupParserEndElementFieldCallbackWrapper :: Maybe (Ptr (FunPtr MarkupParserEndElementFieldCallbackC)) -> MarkupParserEndElementFieldCallback -> Ptr MarkupParseContext -> CString -> Ptr () -> IO ()

mkMarkupParserEndElementFieldCallback :: MarkupParserEndElementFieldCallbackC -> IO (FunPtr MarkupParserEndElementFieldCallbackC)

noMarkupParserEndElementFieldCallback :: Maybe MarkupParserEndElementFieldCallback

MarkupParserErrorFieldCallback

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

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

markupParserErrorFieldCallbackClosure :: MarkupParserErrorFieldCallback -> IO Closure

markupParserErrorFieldCallbackWrapper :: Maybe (Ptr (FunPtr MarkupParserErrorFieldCallbackC)) -> MarkupParserErrorFieldCallback -> Ptr MarkupParseContext -> Ptr GError -> Ptr () -> IO ()

mkMarkupParserErrorFieldCallback :: MarkupParserErrorFieldCallbackC -> IO (FunPtr MarkupParserErrorFieldCallbackC)

noMarkupParserErrorFieldCallback :: Maybe MarkupParserErrorFieldCallback

MarkupParserPassthroughFieldCallback

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

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

markupParserPassthroughFieldCallbackClosure :: MarkupParserPassthroughFieldCallback -> IO Closure

markupParserPassthroughFieldCallbackWrapper :: Maybe (Ptr (FunPtr MarkupParserPassthroughFieldCallbackC)) -> MarkupParserPassthroughFieldCallback -> Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> IO ()

mkMarkupParserPassthroughFieldCallback :: MarkupParserPassthroughFieldCallbackC -> IO (FunPtr MarkupParserPassthroughFieldCallbackC)

noMarkupParserPassthroughFieldCallback :: Maybe MarkupParserPassthroughFieldCallback

MarkupParserStartElementFieldCallback

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

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

markupParserStartElementFieldCallbackClosure :: MarkupParserStartElementFieldCallback -> IO Closure

markupParserStartElementFieldCallbackWrapper :: Maybe (Ptr (FunPtr MarkupParserStartElementFieldCallbackC)) -> MarkupParserStartElementFieldCallback -> Ptr MarkupParseContext -> CString -> CString -> CString -> Ptr () -> IO ()

mkMarkupParserStartElementFieldCallback :: MarkupParserStartElementFieldCallbackC -> IO (FunPtr MarkupParserStartElementFieldCallbackC)

noMarkupParserStartElementFieldCallback :: Maybe MarkupParserStartElementFieldCallback

MarkupParserTextFieldCallback

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

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

markupParserTextFieldCallbackClosure :: MarkupParserTextFieldCallback -> IO Closure

markupParserTextFieldCallbackWrapper :: Maybe (Ptr (FunPtr MarkupParserTextFieldCallbackC)) -> MarkupParserTextFieldCallback -> Ptr MarkupParseContext -> CString -> Word64 -> Ptr () -> IO ()

mkMarkupParserTextFieldCallback :: MarkupParserTextFieldCallbackC -> IO (FunPtr MarkupParserTextFieldCallbackC)

noMarkupParserTextFieldCallback :: Maybe MarkupParserTextFieldCallback

MemVTableCallocFieldCallback

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

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

memVTableCallocFieldCallbackClosure :: MemVTableCallocFieldCallback -> IO Closure

memVTableCallocFieldCallbackWrapper :: Maybe (Ptr (FunPtr MemVTableCallocFieldCallbackC)) -> MemVTableCallocFieldCallback -> Word64 -> Word64 -> IO (Ptr ())

mkMemVTableCallocFieldCallback :: MemVTableCallocFieldCallbackC -> IO (FunPtr MemVTableCallocFieldCallbackC)

noMemVTableCallocFieldCallback :: Maybe MemVTableCallocFieldCallback

MemVTableFreeFieldCallback

type MemVTableFreeFieldCallback = Ptr () -> IO ()

type MemVTableFreeFieldCallbackC = Ptr () -> IO ()

memVTableFreeFieldCallbackClosure :: MemVTableFreeFieldCallback -> IO Closure

memVTableFreeFieldCallbackWrapper :: Maybe (Ptr (FunPtr MemVTableFreeFieldCallbackC)) -> MemVTableFreeFieldCallback -> Ptr () -> IO ()

mkMemVTableFreeFieldCallback :: MemVTableFreeFieldCallbackC -> IO (FunPtr MemVTableFreeFieldCallbackC)

noMemVTableFreeFieldCallback :: Maybe MemVTableFreeFieldCallback

MemVTableMallocFieldCallback

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

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

memVTableMallocFieldCallbackClosure :: MemVTableMallocFieldCallback -> IO Closure

memVTableMallocFieldCallbackWrapper :: Maybe (Ptr (FunPtr MemVTableMallocFieldCallbackC)) -> MemVTableMallocFieldCallback -> Word64 -> IO (Ptr ())

mkMemVTableMallocFieldCallback :: MemVTableMallocFieldCallbackC -> IO (FunPtr MemVTableMallocFieldCallbackC)

noMemVTableMallocFieldCallback :: Maybe MemVTableMallocFieldCallback

MemVTableReallocFieldCallback

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

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

memVTableReallocFieldCallbackClosure :: MemVTableReallocFieldCallback -> IO Closure

memVTableReallocFieldCallbackWrapper :: Maybe (Ptr (FunPtr MemVTableReallocFieldCallbackC)) -> MemVTableReallocFieldCallback -> Ptr () -> Word64 -> IO (Ptr ())

mkMemVTableReallocFieldCallback :: MemVTableReallocFieldCallbackC -> IO (FunPtr MemVTableReallocFieldCallbackC)

noMemVTableReallocFieldCallback :: Maybe MemVTableReallocFieldCallback

MemVTableTryMallocFieldCallback

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

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

memVTableTryMallocFieldCallbackClosure :: MemVTableTryMallocFieldCallback -> IO Closure

memVTableTryMallocFieldCallbackWrapper :: Maybe (Ptr (FunPtr MemVTableTryMallocFieldCallbackC)) -> MemVTableTryMallocFieldCallback -> Word64 -> IO (Ptr ())

mkMemVTableTryMallocFieldCallback :: MemVTableTryMallocFieldCallbackC -> IO (FunPtr MemVTableTryMallocFieldCallbackC)

noMemVTableTryMallocFieldCallback :: Maybe MemVTableTryMallocFieldCallback

MemVTableTryReallocFieldCallback

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

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

memVTableTryReallocFieldCallbackClosure :: MemVTableTryReallocFieldCallback -> IO Closure

memVTableTryReallocFieldCallbackWrapper :: Maybe (Ptr (FunPtr MemVTableTryReallocFieldCallbackC)) -> MemVTableTryReallocFieldCallback -> Ptr () -> Word64 -> IO (Ptr ())

mkMemVTableTryReallocFieldCallback :: MemVTableTryReallocFieldCallbackC -> IO (FunPtr MemVTableTryReallocFieldCallbackC)

noMemVTableTryReallocFieldCallback :: Maybe MemVTableTryReallocFieldCallback

NodeForeachFunc

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

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

mkNodeForeachFunc :: NodeForeachFuncC -> IO (FunPtr NodeForeachFuncC)

noNodeForeachFunc :: Maybe NodeForeachFunc

nodeForeachFuncClosure :: NodeForeachFunc -> IO Closure

nodeForeachFuncWrapper :: Maybe (Ptr (FunPtr NodeForeachFuncC)) -> NodeForeachFunc -> Ptr Node -> Ptr () -> IO ()

NodeTraverseFunc

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

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

mkNodeTraverseFunc :: NodeTraverseFuncC -> IO (FunPtr NodeTraverseFuncC)

noNodeTraverseFunc :: Maybe NodeTraverseFunc

nodeTraverseFuncClosure :: NodeTraverseFunc -> IO Closure

nodeTraverseFuncWrapper :: Maybe (Ptr (FunPtr NodeTraverseFuncC)) -> NodeTraverseFunc -> Ptr Node -> Ptr () -> IO CInt

OptionArgFunc

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

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

mkOptionArgFunc :: OptionArgFuncC -> IO (FunPtr OptionArgFuncC)

noOptionArgFunc :: Maybe OptionArgFunc

optionArgFuncClosure :: OptionArgFunc -> IO Closure

optionArgFuncWrapper :: Maybe (Ptr (FunPtr OptionArgFuncC)) -> OptionArgFunc -> CString -> CString -> Ptr () -> IO CInt

OptionErrorFunc

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

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

mkOptionErrorFunc :: OptionErrorFuncC -> IO (FunPtr OptionErrorFuncC)

noOptionErrorFunc :: Maybe OptionErrorFunc

optionErrorFuncClosure :: OptionErrorFunc -> IO Closure

optionErrorFuncWrapper :: Maybe (Ptr (FunPtr OptionErrorFuncC)) -> OptionErrorFunc -> Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> IO ()

OptionParseFunc

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

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

mkOptionParseFunc :: OptionParseFuncC -> IO (FunPtr OptionParseFuncC)

noOptionParseFunc :: Maybe OptionParseFunc

optionParseFuncClosure :: OptionParseFunc -> IO Closure

optionParseFuncWrapper :: Maybe (Ptr (FunPtr OptionParseFuncC)) -> OptionParseFunc -> Ptr OptionContext -> Ptr OptionGroup -> Ptr () -> IO CInt

PollFunc

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

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

mkPollFunc :: PollFuncC -> IO (FunPtr PollFuncC)

noPollFunc :: Maybe PollFunc

pollFuncClosure :: PollFunc -> IO Closure

pollFuncWrapper :: Maybe (Ptr (FunPtr PollFuncC)) -> PollFunc -> Ptr PollFD -> Word32 -> Int32 -> IO Int32

PrintFunc

type PrintFunc = Text -> IO ()

type PrintFuncC = CString -> IO ()

mkPrintFunc :: PrintFuncC -> IO (FunPtr PrintFuncC)

noPrintFunc :: Maybe PrintFunc

printFuncClosure :: PrintFunc -> IO Closure

printFuncWrapper :: Maybe (Ptr (FunPtr PrintFuncC)) -> PrintFunc -> CString -> IO ()

RegexEvalCallback

type RegexEvalCallback = MatchInfo -> String -> IO Bool

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

mkRegexEvalCallback :: RegexEvalCallbackC -> IO (FunPtr RegexEvalCallbackC)

noRegexEvalCallback :: Maybe RegexEvalCallback

regexEvalCallbackClosure :: RegexEvalCallback -> IO Closure

regexEvalCallbackWrapper :: Maybe (Ptr (FunPtr RegexEvalCallbackC)) -> RegexEvalCallback -> Ptr MatchInfo -> Ptr String -> Ptr () -> IO CInt

ScannerMsgFunc

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

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

mkScannerMsgFunc :: ScannerMsgFuncC -> IO (FunPtr ScannerMsgFuncC)

noScannerMsgFunc :: Maybe ScannerMsgFunc

scannerMsgFuncClosure :: ScannerMsgFunc -> IO Closure

scannerMsgFuncWrapper :: Maybe (Ptr (FunPtr ScannerMsgFuncC)) -> ScannerMsgFunc -> Ptr Scanner -> CString -> CInt -> IO ()

SequenceIterCompareFunc

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

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

mkSequenceIterCompareFunc :: SequenceIterCompareFuncC -> IO (FunPtr SequenceIterCompareFuncC)

noSequenceIterCompareFunc :: Maybe SequenceIterCompareFunc

sequenceIterCompareFuncClosure :: SequenceIterCompareFunc -> IO Closure

sequenceIterCompareFuncWrapper :: Maybe (Ptr (FunPtr SequenceIterCompareFuncC)) -> SequenceIterCompareFunc -> Ptr SequenceIter -> Ptr SequenceIter -> Ptr () -> IO Int32

SourceCallbackFuncsRefFieldCallback

type SourceCallbackFuncsRefFieldCallback = Ptr () -> IO ()

type SourceCallbackFuncsRefFieldCallbackC = Ptr () -> IO ()

mkSourceCallbackFuncsRefFieldCallback :: SourceCallbackFuncsRefFieldCallbackC -> IO (FunPtr SourceCallbackFuncsRefFieldCallbackC)

noSourceCallbackFuncsRefFieldCallback :: Maybe SourceCallbackFuncsRefFieldCallback

sourceCallbackFuncsRefFieldCallbackClosure :: SourceCallbackFuncsRefFieldCallback -> IO Closure

sourceCallbackFuncsRefFieldCallbackWrapper :: Maybe (Ptr (FunPtr SourceCallbackFuncsRefFieldCallbackC)) -> SourceCallbackFuncsRefFieldCallback -> Ptr () -> IO ()

SourceCallbackFuncsUnrefFieldCallback

type SourceCallbackFuncsUnrefFieldCallback = Ptr () -> IO ()

type SourceCallbackFuncsUnrefFieldCallbackC = Ptr () -> IO ()

mkSourceCallbackFuncsUnrefFieldCallback :: SourceCallbackFuncsUnrefFieldCallbackC -> IO (FunPtr SourceCallbackFuncsUnrefFieldCallbackC)

noSourceCallbackFuncsUnrefFieldCallback :: Maybe SourceCallbackFuncsUnrefFieldCallback

sourceCallbackFuncsUnrefFieldCallbackClosure :: SourceCallbackFuncsUnrefFieldCallback -> IO Closure

sourceCallbackFuncsUnrefFieldCallbackWrapper :: Maybe (Ptr (FunPtr SourceCallbackFuncsUnrefFieldCallbackC)) -> SourceCallbackFuncsUnrefFieldCallback -> Ptr () -> IO ()

SourceDummyMarshal

type SourceDummyMarshal = IO ()

type SourceDummyMarshalC = IO ()

mkSourceDummyMarshal :: SourceDummyMarshalC -> IO (FunPtr SourceDummyMarshalC)

noSourceDummyMarshal :: Maybe SourceDummyMarshal

sourceDummyMarshalClosure :: SourceDummyMarshal -> IO Closure

sourceDummyMarshalWrapper :: Maybe (Ptr (FunPtr SourceDummyMarshalC)) -> SourceDummyMarshal -> IO ()

SourceFunc

type SourceFunc = IO Bool

type SourceFuncC = Ptr () -> IO CInt

mkSourceFunc :: SourceFuncC -> IO (FunPtr SourceFuncC)

noSourceFunc :: Maybe SourceFunc

sourceFuncClosure :: SourceFunc -> IO Closure

sourceFuncWrapper :: Maybe (Ptr (FunPtr SourceFuncC)) -> SourceFunc -> Ptr () -> IO CInt

SourceFuncsCheckFieldCallback

type SourceFuncsCheckFieldCallback = Source -> IO Bool

type SourceFuncsCheckFieldCallbackC = Ptr Source -> IO CInt

mkSourceFuncsCheckFieldCallback :: SourceFuncsCheckFieldCallbackC -> IO (FunPtr SourceFuncsCheckFieldCallbackC)

noSourceFuncsCheckFieldCallback :: Maybe SourceFuncsCheckFieldCallback

sourceFuncsCheckFieldCallbackClosure :: SourceFuncsCheckFieldCallback -> IO Closure

sourceFuncsCheckFieldCallbackWrapper :: Maybe (Ptr (FunPtr SourceFuncsCheckFieldCallbackC)) -> SourceFuncsCheckFieldCallback -> Ptr Source -> IO CInt

SourceFuncsFinalizeFieldCallback

type SourceFuncsFinalizeFieldCallback = Source -> IO ()

type SourceFuncsFinalizeFieldCallbackC = Ptr Source -> IO ()

mkSourceFuncsFinalizeFieldCallback :: SourceFuncsFinalizeFieldCallbackC -> IO (FunPtr SourceFuncsFinalizeFieldCallbackC)

noSourceFuncsFinalizeFieldCallback :: Maybe SourceFuncsFinalizeFieldCallback

sourceFuncsFinalizeFieldCallbackClosure :: SourceFuncsFinalizeFieldCallback -> IO Closure

sourceFuncsFinalizeFieldCallbackWrapper :: Maybe (Ptr (FunPtr SourceFuncsFinalizeFieldCallbackC)) -> SourceFuncsFinalizeFieldCallback -> Ptr Source -> IO ()

SourceFuncsPrepareFieldCallback

type SourceFuncsPrepareFieldCallback = Source -> Int32 -> IO Bool

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

mkSourceFuncsPrepareFieldCallback :: SourceFuncsPrepareFieldCallbackC -> IO (FunPtr SourceFuncsPrepareFieldCallbackC)

noSourceFuncsPrepareFieldCallback :: Maybe SourceFuncsPrepareFieldCallback

sourceFuncsPrepareFieldCallbackClosure :: SourceFuncsPrepareFieldCallback -> IO Closure

sourceFuncsPrepareFieldCallbackWrapper :: Maybe (Ptr (FunPtr SourceFuncsPrepareFieldCallbackC)) -> SourceFuncsPrepareFieldCallback -> Ptr Source -> Int32 -> IO CInt

SpawnChildSetupFunc

type SpawnChildSetupFunc = IO ()

type SpawnChildSetupFuncC = Ptr () -> IO ()

mkSpawnChildSetupFunc :: SpawnChildSetupFuncC -> IO (FunPtr SpawnChildSetupFuncC)

noSpawnChildSetupFunc :: Maybe SpawnChildSetupFunc

spawnChildSetupFuncClosure :: SpawnChildSetupFunc -> IO Closure

spawnChildSetupFuncWrapper :: Maybe (Ptr (FunPtr SpawnChildSetupFuncC)) -> SpawnChildSetupFunc -> Ptr () -> IO ()

TestDataFunc

type TestDataFunc = IO ()

type TestDataFuncC = Ptr () -> IO ()

mkTestDataFunc :: TestDataFuncC -> IO (FunPtr TestDataFuncC)

noTestDataFunc :: Maybe TestDataFunc

testDataFuncClosure :: TestDataFunc -> IO Closure

testDataFuncWrapper :: Maybe (Ptr (FunPtr TestDataFuncC)) -> TestDataFunc -> Ptr () -> IO ()

TestFixtureFunc

type TestFixtureFunc = Ptr () -> IO ()

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

mkTestFixtureFunc :: TestFixtureFuncC -> IO (FunPtr TestFixtureFuncC)

noTestFixtureFunc :: Maybe TestFixtureFunc

testFixtureFuncClosure :: TestFixtureFunc -> IO Closure

testFixtureFuncWrapper :: Maybe (Ptr (FunPtr TestFixtureFuncC)) -> TestFixtureFunc -> Ptr () -> Ptr () -> IO ()

TestFunc

type TestFunc = IO ()

type TestFuncC = IO ()

mkTestFunc :: TestFuncC -> IO (FunPtr TestFuncC)

noTestFunc :: Maybe TestFunc

testFuncClosure :: TestFunc -> IO Closure

testFuncWrapper :: Maybe (Ptr (FunPtr TestFuncC)) -> TestFunc -> IO ()

TestLogFatalFunc

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

type TestLogFatalFuncC = CString -> CUInt -> CString -> Ptr () -> IO CInt

mkTestLogFatalFunc :: TestLogFatalFuncC -> IO (FunPtr TestLogFatalFuncC)

noTestLogFatalFunc :: Maybe TestLogFatalFunc

testLogFatalFuncClosure :: TestLogFatalFunc -> IO Closure

testLogFatalFuncWrapper :: Maybe (Ptr (FunPtr TestLogFatalFuncC)) -> TestLogFatalFunc -> CString -> CUInt -> CString -> Ptr () -> IO CInt

ThreadFunc

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

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

mkThreadFunc :: ThreadFuncC -> IO (FunPtr ThreadFuncC)

noThreadFunc :: Maybe ThreadFunc

threadFuncClosure :: ThreadFunc -> IO Closure

threadFuncWrapper :: Maybe (Ptr (FunPtr ThreadFuncC)) -> ThreadFunc -> Ptr () -> IO (Ptr ())

TranslateFunc

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

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

mkTranslateFunc :: TranslateFuncC -> IO (FunPtr TranslateFuncC)

noTranslateFunc :: Maybe TranslateFunc

translateFuncClosure :: TranslateFunc -> IO Closure

translateFuncWrapper :: Maybe (Ptr (FunPtr TranslateFuncC)) -> TranslateFunc -> CString -> Ptr () -> IO CString

TraverseFunc

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

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

mkTraverseFunc :: TraverseFuncC -> IO (FunPtr TraverseFuncC)

noTraverseFunc :: Maybe TraverseFunc

traverseFuncClosure :: TraverseFunc -> IO Closure

traverseFuncWrapper :: Maybe (Ptr (FunPtr TraverseFuncC)) -> TraverseFunc -> Ptr () -> Ptr () -> Ptr () -> IO CInt

UnixFDSourceFunc

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

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

mkUnixFDSourceFunc :: UnixFDSourceFuncC -> IO (FunPtr UnixFDSourceFuncC)

noUnixFDSourceFunc :: Maybe UnixFDSourceFunc

unixFDSourceFuncClosure :: UnixFDSourceFunc -> IO Closure

unixFDSourceFuncWrapper :: Maybe (Ptr (FunPtr UnixFDSourceFuncC)) -> UnixFDSourceFunc -> Int32 -> CUInt -> Ptr () -> IO CInt

VoidFunc

type VoidFunc = IO ()

type VoidFuncC = IO ()

mkVoidFunc :: VoidFuncC -> IO (FunPtr VoidFuncC)

noVoidFunc :: Maybe VoidFunc

voidFuncClosure :: VoidFunc -> IO Closure

voidFuncWrapper :: Maybe (Ptr (FunPtr VoidFuncC)) -> VoidFunc -> IO ()