GI.Gst.Callbacks

Signals

BufferForeachMetaFunc

type BufferForeachMetaFunc = Buffer -> IO (Bool, Maybe Meta)

type BufferForeachMetaFunc_WithClosures = Buffer -> Ptr () -> IO (Bool, Maybe Meta)

type C_BufferForeachMetaFunc = Ptr Buffer -> Ptr (Ptr Meta) -> Ptr () -> IO CInt

drop_closures_BufferForeachMetaFunc :: BufferForeachMetaFunc -> BufferForeachMetaFunc_WithClosures

dynamic_BufferForeachMetaFunc :: MonadIO m => FunPtr C_BufferForeachMetaFunc -> Buffer -> Ptr () -> m (Bool, Maybe Meta)

genClosure_BufferForeachMetaFunc :: BufferForeachMetaFunc -> IO Closure

mk_BufferForeachMetaFunc :: C_BufferForeachMetaFunc -> IO (FunPtr C_BufferForeachMetaFunc)

noBufferForeachMetaFunc :: Maybe BufferForeachMetaFunc

noBufferForeachMetaFunc_WithClosures :: Maybe BufferForeachMetaFunc_WithClosures

wrap_BufferForeachMetaFunc :: Maybe (Ptr (FunPtr C_BufferForeachMetaFunc)) -> BufferForeachMetaFunc_WithClosures -> Ptr Buffer -> Ptr (Ptr Meta) -> Ptr () -> IO CInt

BufferListFunc

type BufferListFunc = Word32 -> IO (Bool, Maybe Buffer)

type BufferListFunc_WithClosures = Word32 -> Ptr () -> IO (Bool, Maybe Buffer)

type C_BufferListFunc = Ptr (Ptr Buffer) -> Word32 -> Ptr () -> IO CInt

drop_closures_BufferListFunc :: BufferListFunc -> BufferListFunc_WithClosures

dynamic_BufferListFunc :: MonadIO m => FunPtr C_BufferListFunc -> Word32 -> Ptr () -> m (Bool, Maybe Buffer)

genClosure_BufferListFunc :: BufferListFunc -> IO Closure

mk_BufferListFunc :: C_BufferListFunc -> IO (FunPtr C_BufferListFunc)

noBufferListFunc :: Maybe BufferListFunc

noBufferListFunc_WithClosures :: Maybe BufferListFunc_WithClosures

wrap_BufferListFunc :: Maybe (Ptr (FunPtr C_BufferListFunc)) -> BufferListFunc_WithClosures -> Ptr (Ptr Buffer) -> Word32 -> Ptr () -> IO CInt

BusFunc

type BusFunc = Bus -> Message -> IO Bool

type BusFunc_WithClosures = Bus -> Message -> Ptr () -> IO Bool

type C_BusFunc = Ptr Bus -> Ptr Message -> Ptr () -> IO CInt

drop_closures_BusFunc :: BusFunc -> BusFunc_WithClosures

dynamic_BusFunc :: (MonadIO m, IsBus a) => FunPtr C_BusFunc -> a -> Message -> Ptr () -> m Bool

genClosure_BusFunc :: BusFunc -> IO Closure

mk_BusFunc :: C_BusFunc -> IO (FunPtr C_BusFunc)

noBusFunc :: Maybe BusFunc

noBusFunc_WithClosures :: Maybe BusFunc_WithClosures

wrap_BusFunc :: Maybe (Ptr (FunPtr C_BusFunc)) -> BusFunc_WithClosures -> Ptr Bus -> Ptr Message -> Ptr () -> IO CInt

BusSyncHandler

type BusSyncHandler = Bus -> Message -> IO BusSyncReply

type BusSyncHandler_WithClosures = Bus -> Message -> Ptr () -> IO BusSyncReply

type C_BusSyncHandler = Ptr Bus -> Ptr Message -> Ptr () -> IO CUInt

drop_closures_BusSyncHandler :: BusSyncHandler -> BusSyncHandler_WithClosures

dynamic_BusSyncHandler :: (MonadIO m, IsBus a) => FunPtr C_BusSyncHandler -> a -> Message -> Ptr () -> m BusSyncReply

genClosure_BusSyncHandler :: BusSyncHandler -> IO Closure

mk_BusSyncHandler :: C_BusSyncHandler -> IO (FunPtr C_BusSyncHandler)

noBusSyncHandler :: Maybe BusSyncHandler

noBusSyncHandler_WithClosures :: Maybe BusSyncHandler_WithClosures

wrap_BusSyncHandler :: Maybe (Ptr (FunPtr C_BusSyncHandler)) -> BusSyncHandler_WithClosures -> Ptr Bus -> Ptr Message -> Ptr () -> IO CUInt

CapsFilterMapFunc

type C_CapsFilterMapFunc = Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

type CapsFilterMapFunc = CapsFeatures -> Structure -> IO Bool

type CapsFilterMapFunc_WithClosures = CapsFeatures -> Structure -> Ptr () -> IO Bool

drop_closures_CapsFilterMapFunc :: CapsFilterMapFunc -> CapsFilterMapFunc_WithClosures

dynamic_CapsFilterMapFunc :: MonadIO m => FunPtr C_CapsFilterMapFunc -> CapsFeatures -> Structure -> Ptr () -> m Bool

genClosure_CapsFilterMapFunc :: CapsFilterMapFunc -> IO Closure

mk_CapsFilterMapFunc :: C_CapsFilterMapFunc -> IO (FunPtr C_CapsFilterMapFunc)

noCapsFilterMapFunc :: Maybe CapsFilterMapFunc

noCapsFilterMapFunc_WithClosures :: Maybe CapsFilterMapFunc_WithClosures

wrap_CapsFilterMapFunc :: Maybe (Ptr (FunPtr C_CapsFilterMapFunc)) -> CapsFilterMapFunc_WithClosures -> Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

CapsForeachFunc

type C_CapsForeachFunc = Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

type CapsForeachFunc = CapsFeatures -> Structure -> IO Bool

type CapsForeachFunc_WithClosures = CapsFeatures -> Structure -> Ptr () -> IO Bool

drop_closures_CapsForeachFunc :: CapsForeachFunc -> CapsForeachFunc_WithClosures

dynamic_CapsForeachFunc :: MonadIO m => FunPtr C_CapsForeachFunc -> CapsFeatures -> Structure -> Ptr () -> m Bool

genClosure_CapsForeachFunc :: CapsForeachFunc -> IO Closure

mk_CapsForeachFunc :: C_CapsForeachFunc -> IO (FunPtr C_CapsForeachFunc)

noCapsForeachFunc :: Maybe CapsForeachFunc

noCapsForeachFunc_WithClosures :: Maybe CapsForeachFunc_WithClosures

wrap_CapsForeachFunc :: Maybe (Ptr (FunPtr C_CapsForeachFunc)) -> CapsForeachFunc_WithClosures -> Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

CapsMapFunc

type C_CapsMapFunc = Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

type CapsMapFunc = CapsFeatures -> Structure -> IO Bool

type CapsMapFunc_WithClosures = CapsFeatures -> Structure -> Ptr () -> IO Bool

drop_closures_CapsMapFunc :: CapsMapFunc -> CapsMapFunc_WithClosures

dynamic_CapsMapFunc :: MonadIO m => FunPtr C_CapsMapFunc -> CapsFeatures -> Structure -> Ptr () -> m Bool

genClosure_CapsMapFunc :: CapsMapFunc -> IO Closure

mk_CapsMapFunc :: C_CapsMapFunc -> IO (FunPtr C_CapsMapFunc)

noCapsMapFunc :: Maybe CapsMapFunc

noCapsMapFunc_WithClosures :: Maybe CapsMapFunc_WithClosures

wrap_CapsMapFunc :: Maybe (Ptr (FunPtr C_CapsMapFunc)) -> CapsMapFunc_WithClosures -> Ptr CapsFeatures -> Ptr Structure -> Ptr () -> IO CInt

ClockCallback

type C_ClockCallback = Ptr Clock -> Word64 -> Ptr () -> Ptr () -> IO CInt

type ClockCallback = Clock -> Word64 -> Ptr () -> IO Bool

type ClockCallback_WithClosures = Clock -> Word64 -> Ptr () -> Ptr () -> IO Bool

drop_closures_ClockCallback :: ClockCallback -> ClockCallback_WithClosures

dynamic_ClockCallback :: (MonadIO m, IsClock a) => FunPtr C_ClockCallback -> a -> Word64 -> Ptr () -> Ptr () -> m Bool

genClosure_ClockCallback :: ClockCallback -> IO Closure

mk_ClockCallback :: C_ClockCallback -> IO (FunPtr C_ClockCallback)

noClockCallback :: Maybe ClockCallback

noClockCallback_WithClosures :: Maybe ClockCallback_WithClosures

wrap_ClockCallback :: Maybe (Ptr (FunPtr C_ClockCallback)) -> ClockCallback_WithClosures -> Ptr Clock -> Word64 -> Ptr () -> Ptr () -> IO CInt

ControlBindingConvert

type C_ControlBindingConvert = Ptr ControlBinding -> CDouble -> Ptr GValue -> IO ()

type ControlBindingConvert = ControlBinding -> Double -> GValue -> IO ()

dynamic_ControlBindingConvert :: (MonadIO m, IsControlBinding a) => FunPtr C_ControlBindingConvert -> a -> Double -> GValue -> m ()

genClosure_ControlBindingConvert :: ControlBindingConvert -> IO Closure

mk_ControlBindingConvert :: C_ControlBindingConvert -> IO (FunPtr C_ControlBindingConvert)

noControlBindingConvert :: Maybe ControlBindingConvert

wrap_ControlBindingConvert :: Maybe (Ptr (FunPtr C_ControlBindingConvert)) -> ControlBindingConvert -> Ptr ControlBinding -> CDouble -> Ptr GValue -> IO ()

ControlSourceGetValue

type C_ControlSourceGetValue = Ptr ControlSource -> Word64 -> CDouble -> IO CInt

type ControlSourceGetValue = ControlSource -> Word64 -> Double -> IO Bool

dynamic_ControlSourceGetValue :: (MonadIO m, IsControlSource a) => FunPtr C_ControlSourceGetValue -> a -> Word64 -> Double -> m Bool

genClosure_ControlSourceGetValue :: ControlSourceGetValue -> IO Closure

mk_ControlSourceGetValue :: C_ControlSourceGetValue -> IO (FunPtr C_ControlSourceGetValue)

noControlSourceGetValue :: Maybe ControlSourceGetValue

wrap_ControlSourceGetValue :: Maybe (Ptr (FunPtr C_ControlSourceGetValue)) -> ControlSourceGetValue -> Ptr ControlSource -> Word64 -> CDouble -> IO CInt

ControlSourceGetValueArray

type C_ControlSourceGetValueArray = Ptr ControlSource -> Word64 -> Word64 -> Word32 -> CDouble -> IO CInt

type ControlSourceGetValueArray = ControlSource -> Word64 -> Word64 -> Word32 -> Double -> IO Bool

dynamic_ControlSourceGetValueArray :: (MonadIO m, IsControlSource a) => FunPtr C_ControlSourceGetValueArray -> a -> Word64 -> Word64 -> Word32 -> Double -> m Bool

genClosure_ControlSourceGetValueArray :: ControlSourceGetValueArray -> IO Closure

mk_ControlSourceGetValueArray :: C_ControlSourceGetValueArray -> IO (FunPtr C_ControlSourceGetValueArray)

noControlSourceGetValueArray :: Maybe ControlSourceGetValueArray

wrap_ControlSourceGetValueArray :: Maybe (Ptr (FunPtr C_ControlSourceGetValueArray)) -> ControlSourceGetValueArray -> Ptr ControlSource -> Word64 -> Word64 -> Word32 -> CDouble -> IO CInt

DebugFuncPtr

type C_DebugFuncPtr = IO ()

type DebugFuncPtr = IO ()

dynamic_DebugFuncPtr :: MonadIO m => FunPtr C_DebugFuncPtr -> m ()

genClosure_DebugFuncPtr :: DebugFuncPtr -> IO Closure

mk_DebugFuncPtr :: C_DebugFuncPtr -> IO (FunPtr C_DebugFuncPtr)

noDebugFuncPtr :: Maybe DebugFuncPtr

wrap_DebugFuncPtr :: Maybe (Ptr (FunPtr C_DebugFuncPtr)) -> DebugFuncPtr -> IO ()

IteratorCopyFunction

type C_IteratorCopyFunction = Ptr Iterator -> Ptr Iterator -> IO ()

type IteratorCopyFunction = Iterator -> Iterator -> IO ()

dynamic_IteratorCopyFunction :: MonadIO m => FunPtr C_IteratorCopyFunction -> Iterator -> Iterator -> m ()

genClosure_IteratorCopyFunction :: IteratorCopyFunction -> IO Closure

mk_IteratorCopyFunction :: C_IteratorCopyFunction -> IO (FunPtr C_IteratorCopyFunction)

noIteratorCopyFunction :: Maybe IteratorCopyFunction

wrap_IteratorCopyFunction :: Maybe (Ptr (FunPtr C_IteratorCopyFunction)) -> IteratorCopyFunction -> Ptr Iterator -> Ptr Iterator -> IO ()

IteratorFoldFunction

type C_IteratorFoldFunction = Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

type IteratorFoldFunction = GValue -> GValue -> IO Bool

type IteratorFoldFunction_WithClosures = GValue -> GValue -> Ptr () -> IO Bool

drop_closures_IteratorFoldFunction :: IteratorFoldFunction -> IteratorFoldFunction_WithClosures

dynamic_IteratorFoldFunction :: MonadIO m => FunPtr C_IteratorFoldFunction -> GValue -> GValue -> Ptr () -> m Bool

genClosure_IteratorFoldFunction :: IteratorFoldFunction -> IO Closure

mk_IteratorFoldFunction :: C_IteratorFoldFunction -> IO (FunPtr C_IteratorFoldFunction)

noIteratorFoldFunction :: Maybe IteratorFoldFunction

noIteratorFoldFunction_WithClosures :: Maybe IteratorFoldFunction_WithClosures

wrap_IteratorFoldFunction :: Maybe (Ptr (FunPtr C_IteratorFoldFunction)) -> IteratorFoldFunction_WithClosures -> Ptr GValue -> Ptr GValue -> Ptr () -> IO CInt

IteratorForeachFunction

type C_IteratorForeachFunction = Ptr GValue -> Ptr () -> IO ()

type IteratorForeachFunction = GValue -> IO ()

type IteratorForeachFunction_WithClosures = GValue -> Ptr () -> IO ()

drop_closures_IteratorForeachFunction :: IteratorForeachFunction -> IteratorForeachFunction_WithClosures

dynamic_IteratorForeachFunction :: MonadIO m => FunPtr C_IteratorForeachFunction -> GValue -> Ptr () -> m ()

genClosure_IteratorForeachFunction :: IteratorForeachFunction -> IO Closure

mk_IteratorForeachFunction :: C_IteratorForeachFunction -> IO (FunPtr C_IteratorForeachFunction)

noIteratorForeachFunction :: Maybe IteratorForeachFunction

noIteratorForeachFunction_WithClosures :: Maybe IteratorForeachFunction_WithClosures

wrap_IteratorForeachFunction :: Maybe (Ptr (FunPtr C_IteratorForeachFunction)) -> IteratorForeachFunction_WithClosures -> Ptr GValue -> Ptr () -> IO ()

IteratorFreeFunction

type C_IteratorFreeFunction = Ptr Iterator -> IO ()

type IteratorFreeFunction = Iterator -> IO ()

dynamic_IteratorFreeFunction :: MonadIO m => FunPtr C_IteratorFreeFunction -> Iterator -> m ()

genClosure_IteratorFreeFunction :: IteratorFreeFunction -> IO Closure

mk_IteratorFreeFunction :: C_IteratorFreeFunction -> IO (FunPtr C_IteratorFreeFunction)

noIteratorFreeFunction :: Maybe IteratorFreeFunction

wrap_IteratorFreeFunction :: Maybe (Ptr (FunPtr C_IteratorFreeFunction)) -> IteratorFreeFunction -> Ptr Iterator -> IO ()

IteratorItemFunction

type C_IteratorItemFunction = Ptr Iterator -> Ptr GValue -> IO CUInt

type IteratorItemFunction = Iterator -> GValue -> IO IteratorItem

dynamic_IteratorItemFunction :: MonadIO m => FunPtr C_IteratorItemFunction -> Iterator -> GValue -> m IteratorItem

genClosure_IteratorItemFunction :: IteratorItemFunction -> IO Closure

mk_IteratorItemFunction :: C_IteratorItemFunction -> IO (FunPtr C_IteratorItemFunction)

noIteratorItemFunction :: Maybe IteratorItemFunction

wrap_IteratorItemFunction :: Maybe (Ptr (FunPtr C_IteratorItemFunction)) -> IteratorItemFunction -> Ptr Iterator -> Ptr GValue -> IO CUInt

IteratorNextFunction

type C_IteratorNextFunction = Ptr Iterator -> Ptr GValue -> IO CUInt

type IteratorNextFunction = Iterator -> GValue -> IO IteratorResult

dynamic_IteratorNextFunction :: MonadIO m => FunPtr C_IteratorNextFunction -> Iterator -> GValue -> m IteratorResult

genClosure_IteratorNextFunction :: IteratorNextFunction -> IO Closure

mk_IteratorNextFunction :: C_IteratorNextFunction -> IO (FunPtr C_IteratorNextFunction)

noIteratorNextFunction :: Maybe IteratorNextFunction

wrap_IteratorNextFunction :: Maybe (Ptr (FunPtr C_IteratorNextFunction)) -> IteratorNextFunction -> Ptr Iterator -> Ptr GValue -> IO CUInt

IteratorResyncFunction

type C_IteratorResyncFunction = Ptr Iterator -> IO ()

type IteratorResyncFunction = Iterator -> IO ()

dynamic_IteratorResyncFunction :: MonadIO m => FunPtr C_IteratorResyncFunction -> Iterator -> m ()

genClosure_IteratorResyncFunction :: IteratorResyncFunction -> IO Closure

mk_IteratorResyncFunction :: C_IteratorResyncFunction -> IO (FunPtr C_IteratorResyncFunction)

noIteratorResyncFunction :: Maybe IteratorResyncFunction

wrap_IteratorResyncFunction :: Maybe (Ptr (FunPtr C_IteratorResyncFunction)) -> IteratorResyncFunction -> Ptr Iterator -> IO ()

LogFunction

type C_LogFunction = Ptr DebugCategory -> CUInt -> CString -> CString -> Int32 -> Ptr Object -> Ptr DebugMessage -> Ptr () -> IO ()

type LogFunction = DebugCategory -> DebugLevel -> Text -> Text -> Int32 -> Object -> DebugMessage -> IO ()

type LogFunction_WithClosures = DebugCategory -> DebugLevel -> Text -> Text -> Int32 -> Object -> DebugMessage -> Ptr () -> IO ()

drop_closures_LogFunction :: LogFunction -> LogFunction_WithClosures

dynamic_LogFunction :: (MonadIO m, IsObject a) => FunPtr C_LogFunction -> DebugCategory -> DebugLevel -> Text -> Text -> Int32 -> a -> DebugMessage -> Ptr () -> m ()

genClosure_LogFunction :: LogFunction -> IO Closure

mk_LogFunction :: C_LogFunction -> IO (FunPtr C_LogFunction)

noLogFunction :: Maybe LogFunction

noLogFunction_WithClosures :: Maybe LogFunction_WithClosures

wrap_LogFunction :: Maybe (Ptr (FunPtr C_LogFunction)) -> LogFunction_WithClosures -> Ptr DebugCategory -> CUInt -> CString -> CString -> Int32 -> Ptr Object -> Ptr DebugMessage -> Ptr () -> IO ()

MemoryCopyFunction

type C_MemoryCopyFunction = Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

type MemoryCopyFunction = Memory -> Int64 -> Int64 -> IO Memory

dynamic_MemoryCopyFunction :: MonadIO m => FunPtr C_MemoryCopyFunction -> Memory -> Int64 -> Int64 -> m Memory

genClosure_MemoryCopyFunction :: MemoryCopyFunction -> IO Closure

mk_MemoryCopyFunction :: C_MemoryCopyFunction -> IO (FunPtr C_MemoryCopyFunction)

noMemoryCopyFunction :: Maybe MemoryCopyFunction

wrap_MemoryCopyFunction :: Maybe (Ptr (FunPtr C_MemoryCopyFunction)) -> MemoryCopyFunction -> Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

MemoryIsSpanFunction

type C_MemoryIsSpanFunction = Ptr Memory -> Ptr Memory -> Word64 -> IO CInt

type MemoryIsSpanFunction = Memory -> Memory -> Word64 -> IO Bool

dynamic_MemoryIsSpanFunction :: MonadIO m => FunPtr C_MemoryIsSpanFunction -> Memory -> Memory -> Word64 -> m Bool

genClosure_MemoryIsSpanFunction :: MemoryIsSpanFunction -> IO Closure

mk_MemoryIsSpanFunction :: C_MemoryIsSpanFunction -> IO (FunPtr C_MemoryIsSpanFunction)

noMemoryIsSpanFunction :: Maybe MemoryIsSpanFunction

wrap_MemoryIsSpanFunction :: Maybe (Ptr (FunPtr C_MemoryIsSpanFunction)) -> MemoryIsSpanFunction -> Ptr Memory -> Ptr Memory -> Word64 -> IO CInt

MemoryMapFullFunction

type C_MemoryMapFullFunction = Ptr Memory -> Ptr MapInfo -> Word64 -> IO (Ptr ())

type MemoryMapFullFunction = Memory -> MapInfo -> Word64 -> IO (Ptr ())

dynamic_MemoryMapFullFunction :: MonadIO m => FunPtr C_MemoryMapFullFunction -> Memory -> MapInfo -> Word64 -> m (Ptr ())

genClosure_MemoryMapFullFunction :: MemoryMapFullFunction -> IO Closure

mk_MemoryMapFullFunction :: C_MemoryMapFullFunction -> IO (FunPtr C_MemoryMapFullFunction)

noMemoryMapFullFunction :: Maybe MemoryMapFullFunction

wrap_MemoryMapFullFunction :: Maybe (Ptr (FunPtr C_MemoryMapFullFunction)) -> MemoryMapFullFunction -> Ptr Memory -> Ptr MapInfo -> Word64 -> IO (Ptr ())

MemoryMapFunction

type C_MemoryMapFunction = Ptr Memory -> Word64 -> CUInt -> IO (Ptr ())

type MemoryMapFunction = Memory -> Word64 -> [MapFlags] -> IO (Ptr ())

dynamic_MemoryMapFunction :: MonadIO m => FunPtr C_MemoryMapFunction -> Memory -> Word64 -> [MapFlags] -> m (Ptr ())

genClosure_MemoryMapFunction :: MemoryMapFunction -> IO Closure

mk_MemoryMapFunction :: C_MemoryMapFunction -> IO (FunPtr C_MemoryMapFunction)

noMemoryMapFunction :: Maybe MemoryMapFunction

wrap_MemoryMapFunction :: Maybe (Ptr (FunPtr C_MemoryMapFunction)) -> MemoryMapFunction -> Ptr Memory -> Word64 -> CUInt -> IO (Ptr ())

MemoryShareFunction

type C_MemoryShareFunction = Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

type MemoryShareFunction = Memory -> Int64 -> Int64 -> IO Memory

dynamic_MemoryShareFunction :: MonadIO m => FunPtr C_MemoryShareFunction -> Memory -> Int64 -> Int64 -> m Memory

genClosure_MemoryShareFunction :: MemoryShareFunction -> IO Closure

mk_MemoryShareFunction :: C_MemoryShareFunction -> IO (FunPtr C_MemoryShareFunction)

noMemoryShareFunction :: Maybe MemoryShareFunction

wrap_MemoryShareFunction :: Maybe (Ptr (FunPtr C_MemoryShareFunction)) -> MemoryShareFunction -> Ptr Memory -> Int64 -> Int64 -> IO (Ptr Memory)

MemoryUnmapFullFunction

type C_MemoryUnmapFullFunction = Ptr Memory -> Ptr MapInfo -> IO ()

type MemoryUnmapFullFunction = Memory -> MapInfo -> IO ()

dynamic_MemoryUnmapFullFunction :: MonadIO m => FunPtr C_MemoryUnmapFullFunction -> Memory -> MapInfo -> m ()

genClosure_MemoryUnmapFullFunction :: MemoryUnmapFullFunction -> IO Closure

mk_MemoryUnmapFullFunction :: C_MemoryUnmapFullFunction -> IO (FunPtr C_MemoryUnmapFullFunction)

noMemoryUnmapFullFunction :: Maybe MemoryUnmapFullFunction

wrap_MemoryUnmapFullFunction :: Maybe (Ptr (FunPtr C_MemoryUnmapFullFunction)) -> MemoryUnmapFullFunction -> Ptr Memory -> Ptr MapInfo -> IO ()

MemoryUnmapFunction

type C_MemoryUnmapFunction = Ptr Memory -> IO ()

type MemoryUnmapFunction = Memory -> IO ()

dynamic_MemoryUnmapFunction :: MonadIO m => FunPtr C_MemoryUnmapFunction -> Memory -> m ()

genClosure_MemoryUnmapFunction :: MemoryUnmapFunction -> IO Closure

mk_MemoryUnmapFunction :: C_MemoryUnmapFunction -> IO (FunPtr C_MemoryUnmapFunction)

noMemoryUnmapFunction :: Maybe MemoryUnmapFunction

wrap_MemoryUnmapFunction :: Maybe (Ptr (FunPtr C_MemoryUnmapFunction)) -> MemoryUnmapFunction -> Ptr Memory -> IO ()

MetaFreeFunction

type C_MetaFreeFunction = Ptr Meta -> Ptr Buffer -> IO ()

type MetaFreeFunction = Meta -> Buffer -> IO ()

dynamic_MetaFreeFunction :: MonadIO m => FunPtr C_MetaFreeFunction -> Meta -> Buffer -> m ()

genClosure_MetaFreeFunction :: MetaFreeFunction -> IO Closure

mk_MetaFreeFunction :: C_MetaFreeFunction -> IO (FunPtr C_MetaFreeFunction)

noMetaFreeFunction :: Maybe MetaFreeFunction

wrap_MetaFreeFunction :: Maybe (Ptr (FunPtr C_MetaFreeFunction)) -> MetaFreeFunction -> Ptr Meta -> Ptr Buffer -> IO ()

MetaInitFunction

type C_MetaInitFunction = Ptr Meta -> Ptr () -> Ptr Buffer -> IO CInt

type MetaInitFunction = Meta -> Ptr () -> Buffer -> IO Bool

dynamic_MetaInitFunction :: MonadIO m => FunPtr C_MetaInitFunction -> Meta -> Ptr () -> Buffer -> m Bool

genClosure_MetaInitFunction :: MetaInitFunction -> IO Closure

mk_MetaInitFunction :: C_MetaInitFunction -> IO (FunPtr C_MetaInitFunction)

noMetaInitFunction :: Maybe MetaInitFunction

wrap_MetaInitFunction :: Maybe (Ptr (FunPtr C_MetaInitFunction)) -> MetaInitFunction -> Ptr Meta -> Ptr () -> Ptr Buffer -> IO CInt

MetaTransformFunction

type C_MetaTransformFunction = Ptr Buffer -> Ptr Meta -> Ptr Buffer -> Word32 -> Ptr () -> IO CInt

type MetaTransformFunction = Buffer -> Meta -> Buffer -> Word32 -> Ptr () -> IO Bool

dynamic_MetaTransformFunction :: MonadIO m => FunPtr C_MetaTransformFunction -> Buffer -> Meta -> Buffer -> Word32 -> Ptr () -> m Bool

genClosure_MetaTransformFunction :: MetaTransformFunction -> IO Closure

mk_MetaTransformFunction :: C_MetaTransformFunction -> IO (FunPtr C_MetaTransformFunction)

noMetaTransformFunction :: Maybe MetaTransformFunction

wrap_MetaTransformFunction :: Maybe (Ptr (FunPtr C_MetaTransformFunction)) -> MetaTransformFunction -> Ptr Buffer -> Ptr Meta -> Ptr Buffer -> Word32 -> Ptr () -> IO CInt

MiniObjectDisposeFunction

type C_MiniObjectDisposeFunction = Ptr MiniObject -> IO CInt

type MiniObjectDisposeFunction = MiniObject -> IO Bool

dynamic_MiniObjectDisposeFunction :: MonadIO m => FunPtr C_MiniObjectDisposeFunction -> MiniObject -> m Bool

genClosure_MiniObjectDisposeFunction :: MiniObjectDisposeFunction -> IO Closure

mk_MiniObjectDisposeFunction :: C_MiniObjectDisposeFunction -> IO (FunPtr C_MiniObjectDisposeFunction)

noMiniObjectDisposeFunction :: Maybe MiniObjectDisposeFunction

wrap_MiniObjectDisposeFunction :: Maybe (Ptr (FunPtr C_MiniObjectDisposeFunction)) -> MiniObjectDisposeFunction -> Ptr MiniObject -> IO CInt

MiniObjectFreeFunction

type C_MiniObjectFreeFunction = Ptr MiniObject -> IO ()

type MiniObjectFreeFunction = MiniObject -> IO ()

dynamic_MiniObjectFreeFunction :: MonadIO m => FunPtr C_MiniObjectFreeFunction -> MiniObject -> m ()

genClosure_MiniObjectFreeFunction :: MiniObjectFreeFunction -> IO Closure

mk_MiniObjectFreeFunction :: C_MiniObjectFreeFunction -> IO (FunPtr C_MiniObjectFreeFunction)

noMiniObjectFreeFunction :: Maybe MiniObjectFreeFunction

wrap_MiniObjectFreeFunction :: Maybe (Ptr (FunPtr C_MiniObjectFreeFunction)) -> MiniObjectFreeFunction -> Ptr MiniObject -> IO ()

MiniObjectNotify

type C_MiniObjectNotify = Ptr () -> Ptr MiniObject -> IO ()

type MiniObjectNotify = MiniObject -> IO ()

type MiniObjectNotify_WithClosures = Ptr () -> MiniObject -> IO ()

drop_closures_MiniObjectNotify :: MiniObjectNotify -> MiniObjectNotify_WithClosures

dynamic_MiniObjectNotify :: MonadIO m => FunPtr C_MiniObjectNotify -> Ptr () -> MiniObject -> m ()

genClosure_MiniObjectNotify :: MiniObjectNotify -> IO Closure

mk_MiniObjectNotify :: C_MiniObjectNotify -> IO (FunPtr C_MiniObjectNotify)

noMiniObjectNotify :: Maybe MiniObjectNotify

noMiniObjectNotify_WithClosures :: Maybe MiniObjectNotify_WithClosures

wrap_MiniObjectNotify :: Maybe (Ptr (FunPtr C_MiniObjectNotify)) -> MiniObjectNotify_WithClosures -> Ptr () -> Ptr MiniObject -> IO ()

PadActivateFunction

type C_PadActivateFunction = Ptr Pad -> Ptr Object -> IO CInt

type PadActivateFunction = Pad -> Object -> IO Bool

dynamic_PadActivateFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadActivateFunction -> a -> b -> m Bool

genClosure_PadActivateFunction :: PadActivateFunction -> IO Closure

mk_PadActivateFunction :: C_PadActivateFunction -> IO (FunPtr C_PadActivateFunction)

noPadActivateFunction :: Maybe PadActivateFunction

wrap_PadActivateFunction :: Maybe (Ptr (FunPtr C_PadActivateFunction)) -> PadActivateFunction -> Ptr Pad -> Ptr Object -> IO CInt

PadActivateModeFunction

type C_PadActivateModeFunction = Ptr Pad -> Ptr Object -> CUInt -> CInt -> IO CInt

type PadActivateModeFunction = Pad -> Object -> PadMode -> Bool -> IO Bool

dynamic_PadActivateModeFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadActivateModeFunction -> a -> b -> PadMode -> Bool -> m Bool

genClosure_PadActivateModeFunction :: PadActivateModeFunction -> IO Closure

mk_PadActivateModeFunction :: C_PadActivateModeFunction -> IO (FunPtr C_PadActivateModeFunction)

noPadActivateModeFunction :: Maybe PadActivateModeFunction

wrap_PadActivateModeFunction :: Maybe (Ptr (FunPtr C_PadActivateModeFunction)) -> PadActivateModeFunction -> Ptr Pad -> Ptr Object -> CUInt -> CInt -> IO CInt

PadChainFunction

type C_PadChainFunction = Ptr Pad -> Ptr Object -> Ptr Buffer -> IO CUInt

type PadChainFunction = Pad -> Maybe Object -> Buffer -> IO FlowReturn

dynamic_PadChainFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadChainFunction -> a -> Maybe b -> Buffer -> m FlowReturn

genClosure_PadChainFunction :: PadChainFunction -> IO Closure

mk_PadChainFunction :: C_PadChainFunction -> IO (FunPtr C_PadChainFunction)

noPadChainFunction :: Maybe PadChainFunction

wrap_PadChainFunction :: Maybe (Ptr (FunPtr C_PadChainFunction)) -> PadChainFunction -> Ptr Pad -> Ptr Object -> Ptr Buffer -> IO CUInt

PadChainListFunction

type C_PadChainListFunction = Ptr Pad -> Ptr Object -> Ptr BufferList -> IO CUInt

type PadChainListFunction = Pad -> Maybe Object -> BufferList -> IO FlowReturn

dynamic_PadChainListFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadChainListFunction -> a -> Maybe b -> BufferList -> m FlowReturn

genClosure_PadChainListFunction :: PadChainListFunction -> IO Closure

mk_PadChainListFunction :: C_PadChainListFunction -> IO (FunPtr C_PadChainListFunction)

noPadChainListFunction :: Maybe PadChainListFunction

wrap_PadChainListFunction :: Maybe (Ptr (FunPtr C_PadChainListFunction)) -> PadChainListFunction -> Ptr Pad -> Ptr Object -> Ptr BufferList -> IO CUInt

PadEventFullFunction

type C_PadEventFullFunction = Ptr Pad -> Ptr Object -> Ptr Event -> IO CUInt

type PadEventFullFunction = Pad -> Maybe Object -> Event -> IO FlowReturn

dynamic_PadEventFullFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadEventFullFunction -> a -> Maybe b -> Event -> m FlowReturn

genClosure_PadEventFullFunction :: PadEventFullFunction -> IO Closure

mk_PadEventFullFunction :: C_PadEventFullFunction -> IO (FunPtr C_PadEventFullFunction)

noPadEventFullFunction :: Maybe PadEventFullFunction

wrap_PadEventFullFunction :: Maybe (Ptr (FunPtr C_PadEventFullFunction)) -> PadEventFullFunction -> Ptr Pad -> Ptr Object -> Ptr Event -> IO CUInt

PadEventFunction

type C_PadEventFunction = Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt

type PadEventFunction = Pad -> Maybe Object -> Event -> IO Bool

dynamic_PadEventFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadEventFunction -> a -> Maybe b -> Event -> m Bool

genClosure_PadEventFunction :: PadEventFunction -> IO Closure

mk_PadEventFunction :: C_PadEventFunction -> IO (FunPtr C_PadEventFunction)

noPadEventFunction :: Maybe PadEventFunction

wrap_PadEventFunction :: Maybe (Ptr (FunPtr C_PadEventFunction)) -> PadEventFunction -> Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt

PadForwardFunction

type C_PadForwardFunction = Ptr Pad -> Ptr () -> IO CInt

type PadForwardFunction = Pad -> IO Bool

type PadForwardFunction_WithClosures = Pad -> Ptr () -> IO Bool

drop_closures_PadForwardFunction :: PadForwardFunction -> PadForwardFunction_WithClosures

dynamic_PadForwardFunction :: (MonadIO m, IsPad a) => FunPtr C_PadForwardFunction -> a -> Ptr () -> m Bool

genClosure_PadForwardFunction :: PadForwardFunction -> IO Closure

mk_PadForwardFunction :: C_PadForwardFunction -> IO (FunPtr C_PadForwardFunction)

noPadForwardFunction :: Maybe PadForwardFunction

noPadForwardFunction_WithClosures :: Maybe PadForwardFunction_WithClosures

wrap_PadForwardFunction :: Maybe (Ptr (FunPtr C_PadForwardFunction)) -> PadForwardFunction_WithClosures -> Ptr Pad -> Ptr () -> IO CInt

PadGetRangeFunction

type C_PadGetRangeFunction = Ptr Pad -> Ptr Object -> Word64 -> Word32 -> Ptr Buffer -> IO CUInt

type PadGetRangeFunction = Pad -> Maybe Object -> Word64 -> Word32 -> Buffer -> IO FlowReturn

dynamic_PadGetRangeFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadGetRangeFunction -> a -> Maybe b -> Word64 -> Word32 -> Buffer -> m FlowReturn

genClosure_PadGetRangeFunction :: PadGetRangeFunction -> IO Closure

mk_PadGetRangeFunction :: C_PadGetRangeFunction -> IO (FunPtr C_PadGetRangeFunction)

noPadGetRangeFunction :: Maybe PadGetRangeFunction

wrap_PadGetRangeFunction :: Maybe (Ptr (FunPtr C_PadGetRangeFunction)) -> PadGetRangeFunction -> Ptr Pad -> Ptr Object -> Word64 -> Word32 -> Ptr Buffer -> IO CUInt

PadIterIntLinkFunction

type C_PadIterIntLinkFunction = Ptr Pad -> Ptr Object -> IO (Ptr Iterator)

type PadIterIntLinkFunction = Pad -> Maybe Object -> IO Iterator

dynamic_PadIterIntLinkFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadIterIntLinkFunction -> a -> Maybe b -> m Iterator

genClosure_PadIterIntLinkFunction :: PadIterIntLinkFunction -> IO Closure

mk_PadIterIntLinkFunction :: C_PadIterIntLinkFunction -> IO (FunPtr C_PadIterIntLinkFunction)

noPadIterIntLinkFunction :: Maybe PadIterIntLinkFunction

wrap_PadIterIntLinkFunction :: Maybe (Ptr (FunPtr C_PadIterIntLinkFunction)) -> PadIterIntLinkFunction -> Ptr Pad -> Ptr Object -> IO (Ptr Iterator)

PadLinkFunction

type C_PadLinkFunction = Ptr Pad -> Ptr Object -> Ptr Pad -> IO CUInt

type PadLinkFunction = Pad -> Maybe Object -> Pad -> IO PadLinkReturn

dynamic_PadLinkFunction :: (MonadIO m, IsPad a, IsObject b, IsPad c) => FunPtr C_PadLinkFunction -> a -> Maybe b -> c -> m PadLinkReturn

genClosure_PadLinkFunction :: PadLinkFunction -> IO Closure

mk_PadLinkFunction :: C_PadLinkFunction -> IO (FunPtr C_PadLinkFunction)

noPadLinkFunction :: Maybe PadLinkFunction

wrap_PadLinkFunction :: Maybe (Ptr (FunPtr C_PadLinkFunction)) -> PadLinkFunction -> Ptr Pad -> Ptr Object -> Ptr Pad -> IO CUInt

PadProbeCallback

type C_PadProbeCallback = Ptr Pad -> Ptr PadProbeInfo -> Ptr () -> IO CUInt

type PadProbeCallback = Pad -> PadProbeInfo -> IO PadProbeReturn

type PadProbeCallback_WithClosures = Pad -> PadProbeInfo -> Ptr () -> IO PadProbeReturn

drop_closures_PadProbeCallback :: PadProbeCallback -> PadProbeCallback_WithClosures

dynamic_PadProbeCallback :: (MonadIO m, IsPad a) => FunPtr C_PadProbeCallback -> a -> PadProbeInfo -> Ptr () -> m PadProbeReturn

genClosure_PadProbeCallback :: PadProbeCallback -> IO Closure

mk_PadProbeCallback :: C_PadProbeCallback -> IO (FunPtr C_PadProbeCallback)

noPadProbeCallback :: Maybe PadProbeCallback

noPadProbeCallback_WithClosures :: Maybe PadProbeCallback_WithClosures

wrap_PadProbeCallback :: Maybe (Ptr (FunPtr C_PadProbeCallback)) -> PadProbeCallback_WithClosures -> Ptr Pad -> Ptr PadProbeInfo -> Ptr () -> IO CUInt

PadQueryFunction

type C_PadQueryFunction = Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt

type PadQueryFunction = Pad -> Maybe Object -> Query -> IO Bool

dynamic_PadQueryFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadQueryFunction -> a -> Maybe b -> Query -> m Bool

genClosure_PadQueryFunction :: PadQueryFunction -> IO Closure

mk_PadQueryFunction :: C_PadQueryFunction -> IO (FunPtr C_PadQueryFunction)

noPadQueryFunction :: Maybe PadQueryFunction

wrap_PadQueryFunction :: Maybe (Ptr (FunPtr C_PadQueryFunction)) -> PadQueryFunction -> Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt

PadStickyEventsForeachFunction

type C_PadStickyEventsForeachFunction = Ptr Pad -> Ptr Event -> Ptr () -> IO CInt

type PadStickyEventsForeachFunction = Pad -> Maybe Event -> IO Bool

type PadStickyEventsForeachFunction_WithClosures = Pad -> Maybe Event -> Ptr () -> IO Bool

drop_closures_PadStickyEventsForeachFunction :: PadStickyEventsForeachFunction -> PadStickyEventsForeachFunction_WithClosures

dynamic_PadStickyEventsForeachFunction :: (MonadIO m, IsPad a) => FunPtr C_PadStickyEventsForeachFunction -> a -> Maybe Event -> Ptr () -> m Bool

genClosure_PadStickyEventsForeachFunction :: PadStickyEventsForeachFunction -> IO Closure

mk_PadStickyEventsForeachFunction :: C_PadStickyEventsForeachFunction -> IO (FunPtr C_PadStickyEventsForeachFunction)

noPadStickyEventsForeachFunction :: Maybe PadStickyEventsForeachFunction

noPadStickyEventsForeachFunction_WithClosures :: Maybe PadStickyEventsForeachFunction_WithClosures

wrap_PadStickyEventsForeachFunction :: Maybe (Ptr (FunPtr C_PadStickyEventsForeachFunction)) -> PadStickyEventsForeachFunction_WithClosures -> Ptr Pad -> Ptr Event -> Ptr () -> IO CInt

PadUnlinkFunction

type C_PadUnlinkFunction = Ptr Pad -> Ptr Object -> IO ()

type PadUnlinkFunction = Pad -> Maybe Object -> IO ()

dynamic_PadUnlinkFunction :: (MonadIO m, IsPad a, IsObject b) => FunPtr C_PadUnlinkFunction -> a -> Maybe b -> m ()

genClosure_PadUnlinkFunction :: PadUnlinkFunction -> IO Closure

mk_PadUnlinkFunction :: C_PadUnlinkFunction -> IO (FunPtr C_PadUnlinkFunction)

noPadUnlinkFunction :: Maybe PadUnlinkFunction

wrap_PadUnlinkFunction :: Maybe (Ptr (FunPtr C_PadUnlinkFunction)) -> PadUnlinkFunction -> Ptr Pad -> Ptr Object -> IO ()

PluginFeatureFilter

type C_PluginFeatureFilter = Ptr PluginFeature -> Ptr () -> IO CInt

type PluginFeatureFilter = PluginFeature -> IO Bool

type PluginFeatureFilter_WithClosures = PluginFeature -> Ptr () -> IO Bool

drop_closures_PluginFeatureFilter :: PluginFeatureFilter -> PluginFeatureFilter_WithClosures

dynamic_PluginFeatureFilter :: (MonadIO m, IsPluginFeature a) => FunPtr C_PluginFeatureFilter -> a -> Ptr () -> m Bool

genClosure_PluginFeatureFilter :: PluginFeatureFilter -> IO Closure

mk_PluginFeatureFilter :: C_PluginFeatureFilter -> IO (FunPtr C_PluginFeatureFilter)

noPluginFeatureFilter :: Maybe PluginFeatureFilter

noPluginFeatureFilter_WithClosures :: Maybe PluginFeatureFilter_WithClosures

wrap_PluginFeatureFilter :: Maybe (Ptr (FunPtr C_PluginFeatureFilter)) -> PluginFeatureFilter_WithClosures -> Ptr PluginFeature -> Ptr () -> IO CInt

PluginFilter

type C_PluginFilter = Ptr Plugin -> Ptr () -> IO CInt

type PluginFilter = Plugin -> IO Bool

type PluginFilter_WithClosures = Plugin -> Ptr () -> IO Bool

drop_closures_PluginFilter :: PluginFilter -> PluginFilter_WithClosures

dynamic_PluginFilter :: (MonadIO m, IsPlugin a) => FunPtr C_PluginFilter -> a -> Ptr () -> m Bool

genClosure_PluginFilter :: PluginFilter -> IO Closure

mk_PluginFilter :: C_PluginFilter -> IO (FunPtr C_PluginFilter)

noPluginFilter :: Maybe PluginFilter

noPluginFilter_WithClosures :: Maybe PluginFilter_WithClosures

wrap_PluginFilter :: Maybe (Ptr (FunPtr C_PluginFilter)) -> PluginFilter_WithClosures -> Ptr Plugin -> Ptr () -> IO CInt

PluginInitFullFunc

type C_PluginInitFullFunc = Ptr Plugin -> Ptr () -> IO CInt

type PluginInitFullFunc = Plugin -> IO Bool

type PluginInitFullFunc_WithClosures = Plugin -> Ptr () -> IO Bool

drop_closures_PluginInitFullFunc :: PluginInitFullFunc -> PluginInitFullFunc_WithClosures

dynamic_PluginInitFullFunc :: (MonadIO m, IsPlugin a) => FunPtr C_PluginInitFullFunc -> a -> Ptr () -> m Bool

genClosure_PluginInitFullFunc :: PluginInitFullFunc -> IO Closure

mk_PluginInitFullFunc :: C_PluginInitFullFunc -> IO (FunPtr C_PluginInitFullFunc)

noPluginInitFullFunc :: Maybe PluginInitFullFunc

noPluginInitFullFunc_WithClosures :: Maybe PluginInitFullFunc_WithClosures

wrap_PluginInitFullFunc :: Maybe (Ptr (FunPtr C_PluginInitFullFunc)) -> PluginInitFullFunc_WithClosures -> Ptr Plugin -> Ptr () -> IO CInt

PluginInitFunc

type C_PluginInitFunc = Ptr Plugin -> IO CInt

type PluginInitFunc = Plugin -> IO Bool

dynamic_PluginInitFunc :: (MonadIO m, IsPlugin a) => FunPtr C_PluginInitFunc -> a -> m Bool

genClosure_PluginInitFunc :: PluginInitFunc -> IO Closure

mk_PluginInitFunc :: C_PluginInitFunc -> IO (FunPtr C_PluginInitFunc)

noPluginInitFunc :: Maybe PluginInitFunc

wrap_PluginInitFunc :: Maybe (Ptr (FunPtr C_PluginInitFunc)) -> PluginInitFunc -> Ptr Plugin -> IO CInt

StructureFilterMapFunc

type C_StructureFilterMapFunc = Word32 -> Ptr GValue -> Ptr () -> IO CInt

type StructureFilterMapFunc = Word32 -> GValue -> IO Bool

type StructureFilterMapFunc_WithClosures = Word32 -> GValue -> Ptr () -> IO Bool

drop_closures_StructureFilterMapFunc :: StructureFilterMapFunc -> StructureFilterMapFunc_WithClosures

dynamic_StructureFilterMapFunc :: MonadIO m => FunPtr C_StructureFilterMapFunc -> Word32 -> GValue -> Ptr () -> m Bool

genClosure_StructureFilterMapFunc :: StructureFilterMapFunc -> IO Closure

mk_StructureFilterMapFunc :: C_StructureFilterMapFunc -> IO (FunPtr C_StructureFilterMapFunc)

noStructureFilterMapFunc :: Maybe StructureFilterMapFunc

noStructureFilterMapFunc_WithClosures :: Maybe StructureFilterMapFunc_WithClosures

wrap_StructureFilterMapFunc :: Maybe (Ptr (FunPtr C_StructureFilterMapFunc)) -> StructureFilterMapFunc_WithClosures -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

StructureForeachFunc

type C_StructureForeachFunc = Word32 -> Ptr GValue -> Ptr () -> IO CInt

type StructureForeachFunc = Word32 -> GValue -> IO Bool

type StructureForeachFunc_WithClosures = Word32 -> GValue -> Ptr () -> IO Bool

drop_closures_StructureForeachFunc :: StructureForeachFunc -> StructureForeachFunc_WithClosures

dynamic_StructureForeachFunc :: MonadIO m => FunPtr C_StructureForeachFunc -> Word32 -> GValue -> Ptr () -> m Bool

genClosure_StructureForeachFunc :: StructureForeachFunc -> IO Closure

mk_StructureForeachFunc :: C_StructureForeachFunc -> IO (FunPtr C_StructureForeachFunc)

noStructureForeachFunc :: Maybe StructureForeachFunc

noStructureForeachFunc_WithClosures :: Maybe StructureForeachFunc_WithClosures

wrap_StructureForeachFunc :: Maybe (Ptr (FunPtr C_StructureForeachFunc)) -> StructureForeachFunc_WithClosures -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

StructureMapFunc

type C_StructureMapFunc = Word32 -> Ptr GValue -> Ptr () -> IO CInt

type StructureMapFunc = Word32 -> GValue -> IO Bool

type StructureMapFunc_WithClosures = Word32 -> GValue -> Ptr () -> IO Bool

drop_closures_StructureMapFunc :: StructureMapFunc -> StructureMapFunc_WithClosures

dynamic_StructureMapFunc :: MonadIO m => FunPtr C_StructureMapFunc -> Word32 -> GValue -> Ptr () -> m Bool

genClosure_StructureMapFunc :: StructureMapFunc -> IO Closure

mk_StructureMapFunc :: C_StructureMapFunc -> IO (FunPtr C_StructureMapFunc)

noStructureMapFunc :: Maybe StructureMapFunc

noStructureMapFunc_WithClosures :: Maybe StructureMapFunc_WithClosures

wrap_StructureMapFunc :: Maybe (Ptr (FunPtr C_StructureMapFunc)) -> StructureMapFunc_WithClosures -> Word32 -> Ptr GValue -> Ptr () -> IO CInt

TagForeachFunc

type C_TagForeachFunc = Ptr TagList -> CString -> Ptr () -> IO ()

type TagForeachFunc = TagList -> Text -> IO ()

type TagForeachFunc_WithClosures = TagList -> Text -> Ptr () -> IO ()

drop_closures_TagForeachFunc :: TagForeachFunc -> TagForeachFunc_WithClosures

dynamic_TagForeachFunc :: MonadIO m => FunPtr C_TagForeachFunc -> TagList -> Text -> Ptr () -> m ()

genClosure_TagForeachFunc :: TagForeachFunc -> IO Closure

mk_TagForeachFunc :: C_TagForeachFunc -> IO (FunPtr C_TagForeachFunc)

noTagForeachFunc :: Maybe TagForeachFunc

noTagForeachFunc_WithClosures :: Maybe TagForeachFunc_WithClosures

wrap_TagForeachFunc :: Maybe (Ptr (FunPtr C_TagForeachFunc)) -> TagForeachFunc_WithClosures -> Ptr TagList -> CString -> Ptr () -> IO ()

TagMergeFunc

type C_TagMergeFunc = Ptr GValue -> Ptr GValue -> IO ()

type TagMergeFunc = GValue -> GValue -> IO ()

dynamic_TagMergeFunc :: MonadIO m => FunPtr C_TagMergeFunc -> GValue -> GValue -> m ()

genClosure_TagMergeFunc :: TagMergeFunc -> IO Closure

mk_TagMergeFunc :: C_TagMergeFunc -> IO (FunPtr C_TagMergeFunc)

noTagMergeFunc :: Maybe TagMergeFunc

wrap_TagMergeFunc :: Maybe (Ptr (FunPtr C_TagMergeFunc)) -> TagMergeFunc -> Ptr GValue -> Ptr GValue -> IO ()

TaskFunction

type C_TaskFunction = Ptr () -> IO ()

type TaskFunction = IO ()

type TaskFunction_WithClosures = Ptr () -> IO ()

drop_closures_TaskFunction :: TaskFunction -> TaskFunction_WithClosures

dynamic_TaskFunction :: MonadIO m => FunPtr C_TaskFunction -> Ptr () -> m ()

genClosure_TaskFunction :: TaskFunction -> IO Closure

mk_TaskFunction :: C_TaskFunction -> IO (FunPtr C_TaskFunction)

noTaskFunction :: Maybe TaskFunction

noTaskFunction_WithClosures :: Maybe TaskFunction_WithClosures

wrap_TaskFunction :: Maybe (Ptr (FunPtr C_TaskFunction)) -> TaskFunction_WithClosures -> Ptr () -> IO ()

TaskPoolFunction

type C_TaskPoolFunction = Ptr () -> IO ()

type TaskPoolFunction = IO ()

type TaskPoolFunction_WithClosures = Ptr () -> IO ()

drop_closures_TaskPoolFunction :: TaskPoolFunction -> TaskPoolFunction_WithClosures

dynamic_TaskPoolFunction :: MonadIO m => FunPtr C_TaskPoolFunction -> Ptr () -> m ()

genClosure_TaskPoolFunction :: TaskPoolFunction -> IO Closure

mk_TaskPoolFunction :: C_TaskPoolFunction -> IO (FunPtr C_TaskPoolFunction)

noTaskPoolFunction :: Maybe TaskPoolFunction

noTaskPoolFunction_WithClosures :: Maybe TaskPoolFunction_WithClosures

wrap_TaskPoolFunction :: Maybe (Ptr (FunPtr C_TaskPoolFunction)) -> TaskPoolFunction_WithClosures -> Ptr () -> IO ()

TaskThreadFunc

type C_TaskThreadFunc = Ptr Task -> Ptr Thread -> Ptr () -> IO ()

type TaskThreadFunc = Task -> Thread -> IO ()

type TaskThreadFunc_WithClosures = Task -> Thread -> Ptr () -> IO ()

drop_closures_TaskThreadFunc :: TaskThreadFunc -> TaskThreadFunc_WithClosures

dynamic_TaskThreadFunc :: (MonadIO m, IsTask a) => FunPtr C_TaskThreadFunc -> a -> Thread -> Ptr () -> m ()

genClosure_TaskThreadFunc :: TaskThreadFunc -> IO Closure

mk_TaskThreadFunc :: C_TaskThreadFunc -> IO (FunPtr C_TaskThreadFunc)

noTaskThreadFunc :: Maybe TaskThreadFunc

noTaskThreadFunc_WithClosures :: Maybe TaskThreadFunc_WithClosures

wrap_TaskThreadFunc :: Maybe (Ptr (FunPtr C_TaskThreadFunc)) -> TaskThreadFunc_WithClosures -> Ptr Task -> Ptr Thread -> Ptr () -> IO ()

TypeFindFunction

type C_TypeFindFunction = Ptr TypeFind -> Ptr () -> IO ()

type TypeFindFunction = TypeFind -> IO ()

type TypeFindFunction_WithClosures = TypeFind -> Ptr () -> IO ()

drop_closures_TypeFindFunction :: TypeFindFunction -> TypeFindFunction_WithClosures

dynamic_TypeFindFunction :: MonadIO m => FunPtr C_TypeFindFunction -> TypeFind -> Ptr () -> m ()

genClosure_TypeFindFunction :: TypeFindFunction -> IO Closure

mk_TypeFindFunction :: C_TypeFindFunction -> IO (FunPtr C_TypeFindFunction)

noTypeFindFunction :: Maybe TypeFindFunction

noTypeFindFunction_WithClosures :: Maybe TypeFindFunction_WithClosures

wrap_TypeFindFunction :: Maybe (Ptr (FunPtr C_TypeFindFunction)) -> TypeFindFunction_WithClosures -> Ptr TypeFind -> Ptr () -> IO ()

TypeFindGetLengthFieldCallback

type C_TypeFindGetLengthFieldCallback = Ptr () -> IO Word64

type TypeFindGetLengthFieldCallback = Ptr () -> IO Word64

dynamic_TypeFindGetLengthFieldCallback :: MonadIO m => FunPtr C_TypeFindGetLengthFieldCallback -> Ptr () -> m Word64

genClosure_TypeFindGetLengthFieldCallback :: TypeFindGetLengthFieldCallback -> IO Closure

mk_TypeFindGetLengthFieldCallback :: C_TypeFindGetLengthFieldCallback -> IO (FunPtr C_TypeFindGetLengthFieldCallback)

noTypeFindGetLengthFieldCallback :: Maybe TypeFindGetLengthFieldCallback

wrap_TypeFindGetLengthFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindGetLengthFieldCallback)) -> TypeFindGetLengthFieldCallback -> Ptr () -> IO Word64

TypeFindPeekFieldCallback

type C_TypeFindPeekFieldCallback = Ptr () -> Int64 -> Word32 -> IO Word8

type TypeFindPeekFieldCallback = Ptr () -> Int64 -> Word32 -> IO Word8

dynamic_TypeFindPeekFieldCallback :: MonadIO m => FunPtr C_TypeFindPeekFieldCallback -> Ptr () -> Int64 -> Word32 -> m Word8

genClosure_TypeFindPeekFieldCallback :: TypeFindPeekFieldCallback -> IO Closure

mk_TypeFindPeekFieldCallback :: C_TypeFindPeekFieldCallback -> IO (FunPtr C_TypeFindPeekFieldCallback)

noTypeFindPeekFieldCallback :: Maybe TypeFindPeekFieldCallback

wrap_TypeFindPeekFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindPeekFieldCallback)) -> TypeFindPeekFieldCallback -> Ptr () -> Int64 -> Word32 -> IO Word8

TypeFindSuggestFieldCallback

type C_TypeFindSuggestFieldCallback = Ptr () -> Word32 -> Ptr Caps -> IO ()

type TypeFindSuggestFieldCallback = Ptr () -> Word32 -> Caps -> IO ()

dynamic_TypeFindSuggestFieldCallback :: MonadIO m => FunPtr C_TypeFindSuggestFieldCallback -> Ptr () -> Word32 -> Caps -> m ()

genClosure_TypeFindSuggestFieldCallback :: TypeFindSuggestFieldCallback -> IO Closure

mk_TypeFindSuggestFieldCallback :: C_TypeFindSuggestFieldCallback -> IO (FunPtr C_TypeFindSuggestFieldCallback)

noTypeFindSuggestFieldCallback :: Maybe TypeFindSuggestFieldCallback

wrap_TypeFindSuggestFieldCallback :: Maybe (Ptr (FunPtr C_TypeFindSuggestFieldCallback)) -> TypeFindSuggestFieldCallback -> Ptr () -> Word32 -> Ptr Caps -> IO ()

ValueCompareFunc

type C_ValueCompareFunc = Ptr GValue -> Ptr GValue -> IO Int32

type ValueCompareFunc = GValue -> GValue -> IO Int32

dynamic_ValueCompareFunc :: MonadIO m => FunPtr C_ValueCompareFunc -> GValue -> GValue -> m Int32

genClosure_ValueCompareFunc :: ValueCompareFunc -> IO Closure

mk_ValueCompareFunc :: C_ValueCompareFunc -> IO (FunPtr C_ValueCompareFunc)

noValueCompareFunc :: Maybe ValueCompareFunc

wrap_ValueCompareFunc :: Maybe (Ptr (FunPtr C_ValueCompareFunc)) -> ValueCompareFunc -> Ptr GValue -> Ptr GValue -> IO Int32

ValueDeserializeFunc

type C_ValueDeserializeFunc = Ptr GValue -> CString -> IO CInt

type ValueDeserializeFunc = GValue -> Text -> IO Bool

dynamic_ValueDeserializeFunc :: MonadIO m => FunPtr C_ValueDeserializeFunc -> GValue -> Text -> m Bool

genClosure_ValueDeserializeFunc :: ValueDeserializeFunc -> IO Closure

mk_ValueDeserializeFunc :: C_ValueDeserializeFunc -> IO (FunPtr C_ValueDeserializeFunc)

noValueDeserializeFunc :: Maybe ValueDeserializeFunc

wrap_ValueDeserializeFunc :: Maybe (Ptr (FunPtr C_ValueDeserializeFunc)) -> ValueDeserializeFunc -> Ptr GValue -> CString -> IO CInt

ValueSerializeFunc

type C_ValueSerializeFunc = Ptr GValue -> IO CString

type ValueSerializeFunc = GValue -> IO Text

dynamic_ValueSerializeFunc :: MonadIO m => FunPtr C_ValueSerializeFunc -> GValue -> m Text

genClosure_ValueSerializeFunc :: ValueSerializeFunc -> IO Closure

mk_ValueSerializeFunc :: C_ValueSerializeFunc -> IO (FunPtr C_ValueSerializeFunc)

noValueSerializeFunc :: Maybe ValueSerializeFunc

wrap_ValueSerializeFunc :: Maybe (Ptr (FunPtr C_ValueSerializeFunc)) -> ValueSerializeFunc -> Ptr GValue -> IO CString