gi-gst-0.1.6.13: GI/Gst/Callbacks.hs
{- |
Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}
module GI.Gst.Callbacks
(
-- * Signals
-- ** BufferForeachMetaFunc
BufferForeachMetaFunc ,
BufferForeachMetaFuncC ,
bufferForeachMetaFuncClosure ,
bufferForeachMetaFuncWrapper ,
mkBufferForeachMetaFunc ,
noBufferForeachMetaFunc ,
-- ** BufferListFunc
BufferListFunc ,
BufferListFuncC ,
bufferListFuncClosure ,
bufferListFuncWrapper ,
mkBufferListFunc ,
noBufferListFunc ,
-- ** BusFunc
BusFunc ,
BusFuncC ,
busFuncClosure ,
busFuncWrapper ,
mkBusFunc ,
noBusFunc ,
-- ** BusSyncHandler
BusSyncHandler ,
BusSyncHandlerC ,
busSyncHandlerClosure ,
busSyncHandlerWrapper ,
mkBusSyncHandler ,
noBusSyncHandler ,
-- ** CapsFilterMapFunc
CapsFilterMapFunc ,
CapsFilterMapFuncC ,
capsFilterMapFuncClosure ,
capsFilterMapFuncWrapper ,
mkCapsFilterMapFunc ,
noCapsFilterMapFunc ,
-- ** CapsForeachFunc
CapsForeachFunc ,
CapsForeachFuncC ,
capsForeachFuncClosure ,
capsForeachFuncWrapper ,
mkCapsForeachFunc ,
noCapsForeachFunc ,
-- ** CapsMapFunc
CapsMapFunc ,
CapsMapFuncC ,
capsMapFuncClosure ,
capsMapFuncWrapper ,
mkCapsMapFunc ,
noCapsMapFunc ,
-- ** ClockCallback
ClockCallback ,
ClockCallbackC ,
clockCallbackClosure ,
clockCallbackWrapper ,
mkClockCallback ,
noClockCallback ,
-- ** ControlBindingConvert
ControlBindingConvert ,
ControlBindingConvertC ,
controlBindingConvertClosure ,
controlBindingConvertWrapper ,
mkControlBindingConvert ,
noControlBindingConvert ,
-- ** ControlSourceGetValue
ControlSourceGetValue ,
ControlSourceGetValueC ,
controlSourceGetValueClosure ,
controlSourceGetValueWrapper ,
mkControlSourceGetValue ,
noControlSourceGetValue ,
-- ** ControlSourceGetValueArray
ControlSourceGetValueArray ,
ControlSourceGetValueArrayC ,
controlSourceGetValueArrayClosure ,
controlSourceGetValueArrayWrapper ,
mkControlSourceGetValueArray ,
noControlSourceGetValueArray ,
-- ** DebugFuncPtr
DebugFuncPtr ,
DebugFuncPtrC ,
debugFuncPtrClosure ,
debugFuncPtrWrapper ,
mkDebugFuncPtr ,
noDebugFuncPtr ,
-- ** IteratorCopyFunction
IteratorCopyFunction ,
IteratorCopyFunctionC ,
iteratorCopyFunctionClosure ,
iteratorCopyFunctionWrapper ,
mkIteratorCopyFunction ,
noIteratorCopyFunction ,
-- ** IteratorFoldFunction
IteratorFoldFunction ,
IteratorFoldFunctionC ,
iteratorFoldFunctionClosure ,
iteratorFoldFunctionWrapper ,
mkIteratorFoldFunction ,
noIteratorFoldFunction ,
-- ** IteratorForeachFunction
IteratorForeachFunction ,
IteratorForeachFunctionC ,
iteratorForeachFunctionClosure ,
iteratorForeachFunctionWrapper ,
mkIteratorForeachFunction ,
noIteratorForeachFunction ,
-- ** IteratorFreeFunction
IteratorFreeFunction ,
IteratorFreeFunctionC ,
iteratorFreeFunctionClosure ,
iteratorFreeFunctionWrapper ,
mkIteratorFreeFunction ,
noIteratorFreeFunction ,
-- ** IteratorItemFunction
IteratorItemFunction ,
IteratorItemFunctionC ,
iteratorItemFunctionClosure ,
iteratorItemFunctionWrapper ,
mkIteratorItemFunction ,
noIteratorItemFunction ,
-- ** IteratorNextFunction
IteratorNextFunction ,
IteratorNextFunctionC ,
iteratorNextFunctionClosure ,
iteratorNextFunctionWrapper ,
mkIteratorNextFunction ,
noIteratorNextFunction ,
-- ** IteratorResyncFunction
IteratorResyncFunction ,
IteratorResyncFunctionC ,
iteratorResyncFunctionClosure ,
iteratorResyncFunctionWrapper ,
mkIteratorResyncFunction ,
noIteratorResyncFunction ,
-- ** LogFunction
LogFunction ,
LogFunctionC ,
logFunctionClosure ,
logFunctionWrapper ,
mkLogFunction ,
noLogFunction ,
-- ** MemoryCopyFunction
MemoryCopyFunction ,
MemoryCopyFunctionC ,
memoryCopyFunctionClosure ,
memoryCopyFunctionWrapper ,
mkMemoryCopyFunction ,
noMemoryCopyFunction ,
-- ** MemoryIsSpanFunction
MemoryIsSpanFunction ,
MemoryIsSpanFunctionC ,
memoryIsSpanFunctionClosure ,
memoryIsSpanFunctionWrapper ,
mkMemoryIsSpanFunction ,
noMemoryIsSpanFunction ,
-- ** MemoryShareFunction
MemoryShareFunction ,
MemoryShareFunctionC ,
memoryShareFunctionClosure ,
memoryShareFunctionWrapper ,
mkMemoryShareFunction ,
noMemoryShareFunction ,
-- ** MemoryUnmapFullFunction
MemoryUnmapFullFunction ,
MemoryUnmapFullFunctionC ,
memoryUnmapFullFunctionClosure ,
memoryUnmapFullFunctionWrapper ,
mkMemoryUnmapFullFunction ,
noMemoryUnmapFullFunction ,
-- ** MemoryUnmapFunction
MemoryUnmapFunction ,
MemoryUnmapFunctionC ,
memoryUnmapFunctionClosure ,
memoryUnmapFunctionWrapper ,
mkMemoryUnmapFunction ,
noMemoryUnmapFunction ,
-- ** MetaFreeFunction
MetaFreeFunction ,
MetaFreeFunctionC ,
metaFreeFunctionClosure ,
metaFreeFunctionWrapper ,
mkMetaFreeFunction ,
noMetaFreeFunction ,
-- ** MetaInitFunction
MetaInitFunction ,
MetaInitFunctionC ,
metaInitFunctionClosure ,
metaInitFunctionWrapper ,
mkMetaInitFunction ,
noMetaInitFunction ,
-- ** MetaTransformFunction
MetaTransformFunction ,
MetaTransformFunctionC ,
metaTransformFunctionClosure ,
metaTransformFunctionWrapper ,
mkMetaTransformFunction ,
noMetaTransformFunction ,
-- ** MiniObjectDisposeFunction
MiniObjectDisposeFunction ,
MiniObjectDisposeFunctionC ,
miniObjectDisposeFunctionClosure ,
miniObjectDisposeFunctionWrapper ,
mkMiniObjectDisposeFunction ,
noMiniObjectDisposeFunction ,
-- ** MiniObjectFreeFunction
MiniObjectFreeFunction ,
MiniObjectFreeFunctionC ,
miniObjectFreeFunctionClosure ,
miniObjectFreeFunctionWrapper ,
mkMiniObjectFreeFunction ,
noMiniObjectFreeFunction ,
-- ** MiniObjectNotify
MiniObjectNotify ,
MiniObjectNotifyC ,
miniObjectNotifyClosure ,
miniObjectNotifyWrapper ,
mkMiniObjectNotify ,
noMiniObjectNotify ,
-- ** PadActivateFunction
PadActivateFunction ,
PadActivateFunctionC ,
mkPadActivateFunction ,
noPadActivateFunction ,
padActivateFunctionClosure ,
padActivateFunctionWrapper ,
-- ** PadActivateModeFunction
PadActivateModeFunction ,
PadActivateModeFunctionC ,
mkPadActivateModeFunction ,
noPadActivateModeFunction ,
padActivateModeFunctionClosure ,
padActivateModeFunctionWrapper ,
-- ** PadChainFunction
PadChainFunction ,
PadChainFunctionC ,
mkPadChainFunction ,
noPadChainFunction ,
padChainFunctionClosure ,
padChainFunctionWrapper ,
-- ** PadChainListFunction
PadChainListFunction ,
PadChainListFunctionC ,
mkPadChainListFunction ,
noPadChainListFunction ,
padChainListFunctionClosure ,
padChainListFunctionWrapper ,
-- ** PadEventFunction
PadEventFunction ,
PadEventFunctionC ,
mkPadEventFunction ,
noPadEventFunction ,
padEventFunctionClosure ,
padEventFunctionWrapper ,
-- ** PadForwardFunction
PadForwardFunction ,
PadForwardFunctionC ,
mkPadForwardFunction ,
noPadForwardFunction ,
padForwardFunctionClosure ,
padForwardFunctionWrapper ,
-- ** PadGetRangeFunction
PadGetRangeFunction ,
PadGetRangeFunctionC ,
mkPadGetRangeFunction ,
noPadGetRangeFunction ,
padGetRangeFunctionClosure ,
padGetRangeFunctionWrapper ,
-- ** PadIterIntLinkFunction
PadIterIntLinkFunction ,
PadIterIntLinkFunctionC ,
mkPadIterIntLinkFunction ,
noPadIterIntLinkFunction ,
padIterIntLinkFunctionClosure ,
padIterIntLinkFunctionWrapper ,
-- ** PadLinkFunction
PadLinkFunction ,
PadLinkFunctionC ,
mkPadLinkFunction ,
noPadLinkFunction ,
padLinkFunctionClosure ,
padLinkFunctionWrapper ,
-- ** PadProbeCallback
PadProbeCallback ,
PadProbeCallbackC ,
mkPadProbeCallback ,
noPadProbeCallback ,
padProbeCallbackClosure ,
padProbeCallbackWrapper ,
-- ** PadQueryFunction
PadQueryFunction ,
PadQueryFunctionC ,
mkPadQueryFunction ,
noPadQueryFunction ,
padQueryFunctionClosure ,
padQueryFunctionWrapper ,
-- ** PadStickyEventsForeachFunction
PadStickyEventsForeachFunction ,
PadStickyEventsForeachFunctionC ,
mkPadStickyEventsForeachFunction ,
noPadStickyEventsForeachFunction ,
padStickyEventsForeachFunctionClosure ,
padStickyEventsForeachFunctionWrapper ,
-- ** PadUnlinkFunction
PadUnlinkFunction ,
PadUnlinkFunctionC ,
mkPadUnlinkFunction ,
noPadUnlinkFunction ,
padUnlinkFunctionClosure ,
padUnlinkFunctionWrapper ,
-- ** PluginFeatureFilter
PluginFeatureFilter ,
PluginFeatureFilterC ,
mkPluginFeatureFilter ,
noPluginFeatureFilter ,
pluginFeatureFilterClosure ,
pluginFeatureFilterWrapper ,
-- ** PluginFilter
PluginFilter ,
PluginFilterC ,
mkPluginFilter ,
noPluginFilter ,
pluginFilterClosure ,
pluginFilterWrapper ,
-- ** PluginInitFullFunc
PluginInitFullFunc ,
PluginInitFullFuncC ,
mkPluginInitFullFunc ,
noPluginInitFullFunc ,
pluginInitFullFuncClosure ,
pluginInitFullFuncWrapper ,
-- ** PluginInitFunc
PluginInitFunc ,
PluginInitFuncC ,
mkPluginInitFunc ,
noPluginInitFunc ,
pluginInitFuncClosure ,
pluginInitFuncWrapper ,
-- ** StructureFilterMapFunc
StructureFilterMapFunc ,
StructureFilterMapFuncC ,
mkStructureFilterMapFunc ,
noStructureFilterMapFunc ,
structureFilterMapFuncClosure ,
structureFilterMapFuncWrapper ,
-- ** StructureForeachFunc
StructureForeachFunc ,
StructureForeachFuncC ,
mkStructureForeachFunc ,
noStructureForeachFunc ,
structureForeachFuncClosure ,
structureForeachFuncWrapper ,
-- ** StructureMapFunc
StructureMapFunc ,
StructureMapFuncC ,
mkStructureMapFunc ,
noStructureMapFunc ,
structureMapFuncClosure ,
structureMapFuncWrapper ,
-- ** TagForeachFunc
TagForeachFunc ,
TagForeachFuncC ,
mkTagForeachFunc ,
noTagForeachFunc ,
tagForeachFuncClosure ,
tagForeachFuncWrapper ,
-- ** TagMergeFunc
TagMergeFunc ,
TagMergeFuncC ,
mkTagMergeFunc ,
noTagMergeFunc ,
tagMergeFuncClosure ,
tagMergeFuncWrapper ,
-- ** TaskFunction
TaskFunction ,
TaskFunctionC ,
mkTaskFunction ,
noTaskFunction ,
taskFunctionClosure ,
taskFunctionWrapper ,
-- ** TaskPoolFunction
TaskPoolFunction ,
TaskPoolFunctionC ,
mkTaskPoolFunction ,
noTaskPoolFunction ,
taskPoolFunctionClosure ,
taskPoolFunctionWrapper ,
-- ** TaskThreadFunc
TaskThreadFunc ,
TaskThreadFuncC ,
mkTaskThreadFunc ,
noTaskThreadFunc ,
taskThreadFuncClosure ,
taskThreadFuncWrapper ,
-- ** TypeFindFunction
TypeFindFunction ,
TypeFindFunctionC ,
mkTypeFindFunction ,
noTypeFindFunction ,
typeFindFunctionClosure ,
typeFindFunctionWrapper ,
-- ** TypeFindGetLengthFieldCallback
TypeFindGetLengthFieldCallback ,
TypeFindGetLengthFieldCallbackC ,
mkTypeFindGetLengthFieldCallback ,
noTypeFindGetLengthFieldCallback ,
typeFindGetLengthFieldCallbackClosure ,
typeFindGetLengthFieldCallbackWrapper ,
-- ** TypeFindPeekFieldCallback
TypeFindPeekFieldCallback ,
TypeFindPeekFieldCallbackC ,
mkTypeFindPeekFieldCallback ,
noTypeFindPeekFieldCallback ,
typeFindPeekFieldCallbackClosure ,
typeFindPeekFieldCallbackWrapper ,
-- ** TypeFindSuggestFieldCallback
TypeFindSuggestFieldCallback ,
TypeFindSuggestFieldCallbackC ,
mkTypeFindSuggestFieldCallback ,
noTypeFindSuggestFieldCallback ,
typeFindSuggestFieldCallbackClosure ,
typeFindSuggestFieldCallbackWrapper ,
-- ** ValueCompareFunc
ValueCompareFunc ,
ValueCompareFuncC ,
mkValueCompareFunc ,
noValueCompareFunc ,
valueCompareFuncClosure ,
valueCompareFuncWrapper ,
-- ** ValueDeserializeFunc
ValueDeserializeFunc ,
ValueDeserializeFuncC ,
mkValueDeserializeFunc ,
noValueDeserializeFunc ,
valueDeserializeFuncClosure ,
valueDeserializeFuncWrapper ,
-- ** ValueSerializeFunc
ValueSerializeFunc ,
ValueSerializeFuncC ,
mkValueSerializeFunc ,
noValueSerializeFunc ,
valueSerializeFuncClosure ,
valueSerializeFuncWrapper ,
) where
import Prelude ()
import Data.GI.Base.ShortPrelude
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import GI.Gst.Types
import qualified GI.GLib as GLib
import qualified GI.GObject as GObject
-- callback ValueSerializeFunc
valueSerializeFuncClosure :: ValueSerializeFunc -> IO Closure
valueSerializeFuncClosure cb = newCClosure =<< mkValueSerializeFunc wrapped
where wrapped = valueSerializeFuncWrapper Nothing cb
type ValueSerializeFuncC =
Ptr GValue ->
IO CString
foreign import ccall "wrapper"
mkValueSerializeFunc :: ValueSerializeFuncC -> IO (FunPtr ValueSerializeFuncC)
type ValueSerializeFunc =
GValue ->
IO T.Text
noValueSerializeFunc :: Maybe ValueSerializeFunc
noValueSerializeFunc = Nothing
valueSerializeFuncWrapper ::
Maybe (Ptr (FunPtr (ValueSerializeFuncC))) ->
ValueSerializeFunc ->
Ptr GValue ->
IO CString
valueSerializeFuncWrapper funptrptr _cb value1 = do
value1' <- (newBoxed GValue) value1
result <- _cb value1'
maybeReleaseFunPtr funptrptr
result' <- textToCString result
return result'
-- callback ValueDeserializeFunc
valueDeserializeFuncClosure :: ValueDeserializeFunc -> IO Closure
valueDeserializeFuncClosure cb = newCClosure =<< mkValueDeserializeFunc wrapped
where wrapped = valueDeserializeFuncWrapper Nothing cb
type ValueDeserializeFuncC =
Ptr GValue ->
CString ->
IO CInt
foreign import ccall "wrapper"
mkValueDeserializeFunc :: ValueDeserializeFuncC -> IO (FunPtr ValueDeserializeFuncC)
type ValueDeserializeFunc =
GValue ->
T.Text ->
IO Bool
noValueDeserializeFunc :: Maybe ValueDeserializeFunc
noValueDeserializeFunc = Nothing
valueDeserializeFuncWrapper ::
Maybe (Ptr (FunPtr (ValueDeserializeFuncC))) ->
ValueDeserializeFunc ->
Ptr GValue ->
CString ->
IO CInt
valueDeserializeFuncWrapper funptrptr _cb dest s = do
dest' <- (newBoxed GValue) dest
s' <- cstringToText s
result <- _cb dest' s'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback ValueCompareFunc
valueCompareFuncClosure :: ValueCompareFunc -> IO Closure
valueCompareFuncClosure cb = newCClosure =<< mkValueCompareFunc wrapped
where wrapped = valueCompareFuncWrapper Nothing cb
type ValueCompareFuncC =
Ptr GValue ->
Ptr GValue ->
IO Int32
foreign import ccall "wrapper"
mkValueCompareFunc :: ValueCompareFuncC -> IO (FunPtr ValueCompareFuncC)
type ValueCompareFunc =
GValue ->
GValue ->
IO Int32
noValueCompareFunc :: Maybe ValueCompareFunc
noValueCompareFunc = Nothing
valueCompareFuncWrapper ::
Maybe (Ptr (FunPtr (ValueCompareFuncC))) ->
ValueCompareFunc ->
Ptr GValue ->
Ptr GValue ->
IO Int32
valueCompareFuncWrapper funptrptr _cb value1 value2 = do
value1' <- (newBoxed GValue) value1
value2' <- (newBoxed GValue) value2
result <- _cb value1' value2'
maybeReleaseFunPtr funptrptr
return result
-- callback TypeFindSuggestFieldCallback
typeFindSuggestFieldCallbackClosure :: TypeFindSuggestFieldCallback -> IO Closure
typeFindSuggestFieldCallbackClosure cb = newCClosure =<< mkTypeFindSuggestFieldCallback wrapped
where wrapped = typeFindSuggestFieldCallbackWrapper Nothing cb
type TypeFindSuggestFieldCallbackC =
Ptr () ->
Word32 ->
Ptr Caps ->
IO ()
foreign import ccall "wrapper"
mkTypeFindSuggestFieldCallback :: TypeFindSuggestFieldCallbackC -> IO (FunPtr TypeFindSuggestFieldCallbackC)
type TypeFindSuggestFieldCallback =
Ptr () ->
Word32 ->
Caps ->
IO ()
noTypeFindSuggestFieldCallback :: Maybe TypeFindSuggestFieldCallback
noTypeFindSuggestFieldCallback = Nothing
typeFindSuggestFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeFindSuggestFieldCallbackC))) ->
TypeFindSuggestFieldCallback ->
Ptr () ->
Word32 ->
Ptr Caps ->
IO ()
typeFindSuggestFieldCallbackWrapper funptrptr _cb data_ probability caps = do
caps' <- (newBoxed Caps) caps
_cb data_ probability caps'
maybeReleaseFunPtr funptrptr
-- callback TypeFindPeekFieldCallback
typeFindPeekFieldCallbackClosure :: TypeFindPeekFieldCallback -> IO Closure
typeFindPeekFieldCallbackClosure cb = newCClosure =<< mkTypeFindPeekFieldCallback wrapped
where wrapped = typeFindPeekFieldCallbackWrapper Nothing cb
type TypeFindPeekFieldCallbackC =
Ptr () ->
Int64 ->
Word32 ->
IO Word8
foreign import ccall "wrapper"
mkTypeFindPeekFieldCallback :: TypeFindPeekFieldCallbackC -> IO (FunPtr TypeFindPeekFieldCallbackC)
type TypeFindPeekFieldCallback =
Ptr () ->
Int64 ->
Word32 ->
IO Word8
noTypeFindPeekFieldCallback :: Maybe TypeFindPeekFieldCallback
noTypeFindPeekFieldCallback = Nothing
typeFindPeekFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeFindPeekFieldCallbackC))) ->
TypeFindPeekFieldCallback ->
Ptr () ->
Int64 ->
Word32 ->
IO Word8
typeFindPeekFieldCallbackWrapper funptrptr _cb data_ offset size = do
result <- _cb data_ offset size
maybeReleaseFunPtr funptrptr
return result
-- callback TypeFindGetLengthFieldCallback
typeFindGetLengthFieldCallbackClosure :: TypeFindGetLengthFieldCallback -> IO Closure
typeFindGetLengthFieldCallbackClosure cb = newCClosure =<< mkTypeFindGetLengthFieldCallback wrapped
where wrapped = typeFindGetLengthFieldCallbackWrapper Nothing cb
type TypeFindGetLengthFieldCallbackC =
Ptr () ->
IO Word64
foreign import ccall "wrapper"
mkTypeFindGetLengthFieldCallback :: TypeFindGetLengthFieldCallbackC -> IO (FunPtr TypeFindGetLengthFieldCallbackC)
type TypeFindGetLengthFieldCallback =
Ptr () ->
IO Word64
noTypeFindGetLengthFieldCallback :: Maybe TypeFindGetLengthFieldCallback
noTypeFindGetLengthFieldCallback = Nothing
typeFindGetLengthFieldCallbackWrapper ::
Maybe (Ptr (FunPtr (TypeFindGetLengthFieldCallbackC))) ->
TypeFindGetLengthFieldCallback ->
Ptr () ->
IO Word64
typeFindGetLengthFieldCallbackWrapper funptrptr _cb data_ = do
result <- _cb data_
maybeReleaseFunPtr funptrptr
return result
-- callback TypeFindFunction
typeFindFunctionClosure :: TypeFindFunction -> IO Closure
typeFindFunctionClosure cb = newCClosure =<< mkTypeFindFunction wrapped
where wrapped = typeFindFunctionWrapper Nothing cb
type TypeFindFunctionC =
Ptr TypeFind ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkTypeFindFunction :: TypeFindFunctionC -> IO (FunPtr TypeFindFunctionC)
type TypeFindFunction =
TypeFind ->
IO ()
noTypeFindFunction :: Maybe TypeFindFunction
noTypeFindFunction = Nothing
typeFindFunctionWrapper ::
Maybe (Ptr (FunPtr (TypeFindFunctionC))) ->
TypeFindFunction ->
Ptr TypeFind ->
Ptr () ->
IO ()
typeFindFunctionWrapper funptrptr _cb find _ = do
find' <- (newPtr 64 TypeFind) find
_cb find'
maybeReleaseFunPtr funptrptr
-- callback TaskThreadFunc
taskThreadFuncClosure :: TaskThreadFunc -> IO Closure
taskThreadFuncClosure cb = newCClosure =<< mkTaskThreadFunc wrapped
where wrapped = taskThreadFuncWrapper Nothing cb
type TaskThreadFuncC =
Ptr Task ->
Ptr GLib.Thread ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkTaskThreadFunc :: TaskThreadFuncC -> IO (FunPtr TaskThreadFuncC)
type TaskThreadFunc =
Task ->
GLib.Thread ->
IO ()
noTaskThreadFunc :: Maybe TaskThreadFunc
noTaskThreadFunc = Nothing
taskThreadFuncWrapper ::
Maybe (Ptr (FunPtr (TaskThreadFuncC))) ->
TaskThreadFunc ->
Ptr Task ->
Ptr GLib.Thread ->
Ptr () ->
IO ()
taskThreadFuncWrapper funptrptr _cb task thread _ = do
task' <- (newObject Task) task
thread' <- (newBoxed GLib.Thread) thread
_cb task' thread'
maybeReleaseFunPtr funptrptr
-- callback TaskPoolFunction
taskPoolFunctionClosure :: TaskPoolFunction -> IO Closure
taskPoolFunctionClosure cb = newCClosure =<< mkTaskPoolFunction wrapped
where wrapped = taskPoolFunctionWrapper Nothing cb
type TaskPoolFunctionC =
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkTaskPoolFunction :: TaskPoolFunctionC -> IO (FunPtr TaskPoolFunctionC)
type TaskPoolFunction =
IO ()
noTaskPoolFunction :: Maybe TaskPoolFunction
noTaskPoolFunction = Nothing
taskPoolFunctionWrapper ::
Maybe (Ptr (FunPtr (TaskPoolFunctionC))) ->
TaskPoolFunction ->
Ptr () ->
IO ()
taskPoolFunctionWrapper funptrptr _cb _ = do
_cb
maybeReleaseFunPtr funptrptr
-- callback TaskFunction
taskFunctionClosure :: TaskFunction -> IO Closure
taskFunctionClosure cb = newCClosure =<< mkTaskFunction wrapped
where wrapped = taskFunctionWrapper Nothing cb
type TaskFunctionC =
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkTaskFunction :: TaskFunctionC -> IO (FunPtr TaskFunctionC)
type TaskFunction =
IO ()
noTaskFunction :: Maybe TaskFunction
noTaskFunction = Nothing
taskFunctionWrapper ::
Maybe (Ptr (FunPtr (TaskFunctionC))) ->
TaskFunction ->
Ptr () ->
IO ()
taskFunctionWrapper funptrptr _cb _ = do
_cb
maybeReleaseFunPtr funptrptr
-- callback TagMergeFunc
tagMergeFuncClosure :: TagMergeFunc -> IO Closure
tagMergeFuncClosure cb = newCClosure =<< mkTagMergeFunc wrapped
where wrapped = tagMergeFuncWrapper Nothing cb
type TagMergeFuncC =
Ptr GValue ->
Ptr GValue ->
IO ()
foreign import ccall "wrapper"
mkTagMergeFunc :: TagMergeFuncC -> IO (FunPtr TagMergeFuncC)
type TagMergeFunc =
GValue ->
GValue ->
IO ()
noTagMergeFunc :: Maybe TagMergeFunc
noTagMergeFunc = Nothing
tagMergeFuncWrapper ::
Maybe (Ptr (FunPtr (TagMergeFuncC))) ->
TagMergeFunc ->
Ptr GValue ->
Ptr GValue ->
IO ()
tagMergeFuncWrapper funptrptr _cb dest src = do
dest' <- (newBoxed GValue) dest
src' <- (newBoxed GValue) src
_cb dest' src'
maybeReleaseFunPtr funptrptr
-- callback TagForeachFunc
tagForeachFuncClosure :: TagForeachFunc -> IO Closure
tagForeachFuncClosure cb = newCClosure =<< mkTagForeachFunc wrapped
where wrapped = tagForeachFuncWrapper Nothing cb
type TagForeachFuncC =
Ptr TagList ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkTagForeachFunc :: TagForeachFuncC -> IO (FunPtr TagForeachFuncC)
type TagForeachFunc =
TagList ->
T.Text ->
IO ()
noTagForeachFunc :: Maybe TagForeachFunc
noTagForeachFunc = Nothing
tagForeachFuncWrapper ::
Maybe (Ptr (FunPtr (TagForeachFuncC))) ->
TagForeachFunc ->
Ptr TagList ->
CString ->
Ptr () ->
IO ()
tagForeachFuncWrapper funptrptr _cb list tag _ = do
list' <- (newBoxed TagList) list
tag' <- cstringToText tag
_cb list' tag'
maybeReleaseFunPtr funptrptr
-- callback StructureMapFunc
structureMapFuncClosure :: StructureMapFunc -> IO Closure
structureMapFuncClosure cb = newCClosure =<< mkStructureMapFunc wrapped
where wrapped = structureMapFuncWrapper Nothing cb
type StructureMapFuncC =
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkStructureMapFunc :: StructureMapFuncC -> IO (FunPtr StructureMapFuncC)
type StructureMapFunc =
Word32 ->
GValue ->
IO Bool
noStructureMapFunc :: Maybe StructureMapFunc
noStructureMapFunc = Nothing
structureMapFuncWrapper ::
Maybe (Ptr (FunPtr (StructureMapFuncC))) ->
StructureMapFunc ->
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
structureMapFuncWrapper funptrptr _cb fieldId value _ = do
value' <- (newBoxed GValue) value
result <- _cb fieldId value'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback StructureForeachFunc
structureForeachFuncClosure :: StructureForeachFunc -> IO Closure
structureForeachFuncClosure cb = newCClosure =<< mkStructureForeachFunc wrapped
where wrapped = structureForeachFuncWrapper Nothing cb
type StructureForeachFuncC =
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkStructureForeachFunc :: StructureForeachFuncC -> IO (FunPtr StructureForeachFuncC)
type StructureForeachFunc =
Word32 ->
GValue ->
IO Bool
noStructureForeachFunc :: Maybe StructureForeachFunc
noStructureForeachFunc = Nothing
structureForeachFuncWrapper ::
Maybe (Ptr (FunPtr (StructureForeachFuncC))) ->
StructureForeachFunc ->
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
structureForeachFuncWrapper funptrptr _cb fieldId value _ = do
value' <- (newBoxed GValue) value
result <- _cb fieldId value'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback StructureFilterMapFunc
structureFilterMapFuncClosure :: StructureFilterMapFunc -> IO Closure
structureFilterMapFuncClosure cb = newCClosure =<< mkStructureFilterMapFunc wrapped
where wrapped = structureFilterMapFuncWrapper Nothing cb
type StructureFilterMapFuncC =
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkStructureFilterMapFunc :: StructureFilterMapFuncC -> IO (FunPtr StructureFilterMapFuncC)
type StructureFilterMapFunc =
Word32 ->
GValue ->
IO Bool
noStructureFilterMapFunc :: Maybe StructureFilterMapFunc
noStructureFilterMapFunc = Nothing
structureFilterMapFuncWrapper ::
Maybe (Ptr (FunPtr (StructureFilterMapFuncC))) ->
StructureFilterMapFunc ->
Word32 ->
Ptr GValue ->
Ptr () ->
IO CInt
structureFilterMapFuncWrapper funptrptr _cb fieldId value _ = do
value' <- (newBoxed GValue) value
result <- _cb fieldId value'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PluginInitFunc
pluginInitFuncClosure :: PluginInitFunc -> IO Closure
pluginInitFuncClosure cb = newCClosure =<< mkPluginInitFunc wrapped
where wrapped = pluginInitFuncWrapper Nothing cb
type PluginInitFuncC =
Ptr Plugin ->
IO CInt
foreign import ccall "wrapper"
mkPluginInitFunc :: PluginInitFuncC -> IO (FunPtr PluginInitFuncC)
type PluginInitFunc =
Plugin ->
IO Bool
noPluginInitFunc :: Maybe PluginInitFunc
noPluginInitFunc = Nothing
pluginInitFuncWrapper ::
Maybe (Ptr (FunPtr (PluginInitFuncC))) ->
PluginInitFunc ->
Ptr Plugin ->
IO CInt
pluginInitFuncWrapper funptrptr _cb plugin = do
plugin' <- (newObject Plugin) plugin
result <- _cb plugin'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PluginInitFullFunc
pluginInitFullFuncClosure :: PluginInitFullFunc -> IO Closure
pluginInitFullFuncClosure cb = newCClosure =<< mkPluginInitFullFunc wrapped
where wrapped = pluginInitFullFuncWrapper Nothing cb
type PluginInitFullFuncC =
Ptr Plugin ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkPluginInitFullFunc :: PluginInitFullFuncC -> IO (FunPtr PluginInitFullFuncC)
type PluginInitFullFunc =
Plugin ->
IO Bool
noPluginInitFullFunc :: Maybe PluginInitFullFunc
noPluginInitFullFunc = Nothing
pluginInitFullFuncWrapper ::
Maybe (Ptr (FunPtr (PluginInitFullFuncC))) ->
PluginInitFullFunc ->
Ptr Plugin ->
Ptr () ->
IO CInt
pluginInitFullFuncWrapper funptrptr _cb plugin _ = do
plugin' <- (newObject Plugin) plugin
result <- _cb plugin'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PluginFilter
pluginFilterClosure :: PluginFilter -> IO Closure
pluginFilterClosure cb = newCClosure =<< mkPluginFilter wrapped
where wrapped = pluginFilterWrapper Nothing cb
type PluginFilterC =
Ptr Plugin ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkPluginFilter :: PluginFilterC -> IO (FunPtr PluginFilterC)
type PluginFilter =
Plugin ->
IO Bool
noPluginFilter :: Maybe PluginFilter
noPluginFilter = Nothing
pluginFilterWrapper ::
Maybe (Ptr (FunPtr (PluginFilterC))) ->
PluginFilter ->
Ptr Plugin ->
Ptr () ->
IO CInt
pluginFilterWrapper funptrptr _cb plugin _ = do
plugin' <- (newObject Plugin) plugin
result <- _cb plugin'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PluginFeatureFilter
pluginFeatureFilterClosure :: PluginFeatureFilter -> IO Closure
pluginFeatureFilterClosure cb = newCClosure =<< mkPluginFeatureFilter wrapped
where wrapped = pluginFeatureFilterWrapper Nothing cb
type PluginFeatureFilterC =
Ptr PluginFeature ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkPluginFeatureFilter :: PluginFeatureFilterC -> IO (FunPtr PluginFeatureFilterC)
type PluginFeatureFilter =
PluginFeature ->
IO Bool
noPluginFeatureFilter :: Maybe PluginFeatureFilter
noPluginFeatureFilter = Nothing
pluginFeatureFilterWrapper ::
Maybe (Ptr (FunPtr (PluginFeatureFilterC))) ->
PluginFeatureFilter ->
Ptr PluginFeature ->
Ptr () ->
IO CInt
pluginFeatureFilterWrapper funptrptr _cb feature _ = do
feature' <- (newObject PluginFeature) feature
result <- _cb feature'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadUnlinkFunction
padUnlinkFunctionClosure :: PadUnlinkFunction -> IO Closure
padUnlinkFunctionClosure cb = newCClosure =<< mkPadUnlinkFunction wrapped
where wrapped = padUnlinkFunctionWrapper Nothing cb
type PadUnlinkFunctionC =
Ptr Pad ->
Ptr Object ->
IO ()
foreign import ccall "wrapper"
mkPadUnlinkFunction :: PadUnlinkFunctionC -> IO (FunPtr PadUnlinkFunctionC)
type PadUnlinkFunction =
Pad ->
Maybe Object ->
IO ()
noPadUnlinkFunction :: Maybe PadUnlinkFunction
noPadUnlinkFunction = Nothing
padUnlinkFunctionWrapper ::
Maybe (Ptr (FunPtr (PadUnlinkFunctionC))) ->
PadUnlinkFunction ->
Ptr Pad ->
Ptr Object ->
IO ()
padUnlinkFunctionWrapper funptrptr _cb pad parent = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
_cb pad' maybeParent
maybeReleaseFunPtr funptrptr
-- callback PadStickyEventsForeachFunction
padStickyEventsForeachFunctionClosure :: PadStickyEventsForeachFunction -> IO Closure
padStickyEventsForeachFunctionClosure cb = newCClosure =<< mkPadStickyEventsForeachFunction wrapped
where wrapped = padStickyEventsForeachFunctionWrapper Nothing cb
type PadStickyEventsForeachFunctionC =
Ptr Pad ->
Ptr Event ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkPadStickyEventsForeachFunction :: PadStickyEventsForeachFunctionC -> IO (FunPtr PadStickyEventsForeachFunctionC)
type PadStickyEventsForeachFunction =
Pad ->
Maybe Event ->
IO Bool
noPadStickyEventsForeachFunction :: Maybe PadStickyEventsForeachFunction
noPadStickyEventsForeachFunction = Nothing
padStickyEventsForeachFunctionWrapper ::
Maybe (Ptr (FunPtr (PadStickyEventsForeachFunctionC))) ->
PadStickyEventsForeachFunction ->
Ptr Pad ->
Ptr Event ->
Ptr () ->
IO CInt
padStickyEventsForeachFunctionWrapper funptrptr _cb pad event _ = do
pad' <- (newObject Pad) pad
maybeEvent <-
if event == nullPtr
then return Nothing
else do
event' <- (newBoxed Event) event
return $ Just event'
result <- _cb pad' maybeEvent
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadQueryFunction
padQueryFunctionClosure :: PadQueryFunction -> IO Closure
padQueryFunctionClosure cb = newCClosure =<< mkPadQueryFunction wrapped
where wrapped = padQueryFunctionWrapper Nothing cb
type PadQueryFunctionC =
Ptr Pad ->
Ptr Object ->
Ptr Query ->
IO CInt
foreign import ccall "wrapper"
mkPadQueryFunction :: PadQueryFunctionC -> IO (FunPtr PadQueryFunctionC)
type PadQueryFunction =
Pad ->
Maybe Object ->
Query ->
IO Bool
noPadQueryFunction :: Maybe PadQueryFunction
noPadQueryFunction = Nothing
padQueryFunctionWrapper ::
Maybe (Ptr (FunPtr (PadQueryFunctionC))) ->
PadQueryFunction ->
Ptr Pad ->
Ptr Object ->
Ptr Query ->
IO CInt
padQueryFunctionWrapper funptrptr _cb pad parent query = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
query' <- (newBoxed Query) query
result <- _cb pad' maybeParent query'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadProbeCallback
padProbeCallbackClosure :: PadProbeCallback -> IO Closure
padProbeCallbackClosure cb = newCClosure =<< mkPadProbeCallback wrapped
where wrapped = padProbeCallbackWrapper Nothing cb
type PadProbeCallbackC =
Ptr Pad ->
Ptr PadProbeInfo ->
Ptr () ->
IO CUInt
foreign import ccall "wrapper"
mkPadProbeCallback :: PadProbeCallbackC -> IO (FunPtr PadProbeCallbackC)
type PadProbeCallback =
Pad ->
PadProbeInfo ->
IO PadProbeReturn
noPadProbeCallback :: Maybe PadProbeCallback
noPadProbeCallback = Nothing
padProbeCallbackWrapper ::
Maybe (Ptr (FunPtr (PadProbeCallbackC))) ->
PadProbeCallback ->
Ptr Pad ->
Ptr PadProbeInfo ->
Ptr () ->
IO CUInt
padProbeCallbackWrapper funptrptr _cb pad info _ = do
pad' <- (newObject Pad) pad
info' <- (newPtr 40 PadProbeInfo) info
result <- _cb pad' info'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadLinkFunction
padLinkFunctionClosure :: PadLinkFunction -> IO Closure
padLinkFunctionClosure cb = newCClosure =<< mkPadLinkFunction wrapped
where wrapped = padLinkFunctionWrapper Nothing cb
type PadLinkFunctionC =
Ptr Pad ->
Ptr Object ->
Ptr Pad ->
IO CUInt
foreign import ccall "wrapper"
mkPadLinkFunction :: PadLinkFunctionC -> IO (FunPtr PadLinkFunctionC)
type PadLinkFunction =
Pad ->
Maybe Object ->
Pad ->
IO PadLinkReturn
noPadLinkFunction :: Maybe PadLinkFunction
noPadLinkFunction = Nothing
padLinkFunctionWrapper ::
Maybe (Ptr (FunPtr (PadLinkFunctionC))) ->
PadLinkFunction ->
Ptr Pad ->
Ptr Object ->
Ptr Pad ->
IO CUInt
padLinkFunctionWrapper funptrptr _cb pad parent peer = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
peer' <- (newObject Pad) peer
result <- _cb pad' maybeParent peer'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadIterIntLinkFunction
padIterIntLinkFunctionClosure :: PadIterIntLinkFunction -> IO Closure
padIterIntLinkFunctionClosure cb = newCClosure =<< mkPadIterIntLinkFunction wrapped
where wrapped = padIterIntLinkFunctionWrapper Nothing cb
type PadIterIntLinkFunctionC =
Ptr Pad ->
Ptr Object ->
IO (Ptr Iterator)
foreign import ccall "wrapper"
mkPadIterIntLinkFunction :: PadIterIntLinkFunctionC -> IO (FunPtr PadIterIntLinkFunctionC)
type PadIterIntLinkFunction =
Pad ->
Maybe Object ->
IO Iterator
noPadIterIntLinkFunction :: Maybe PadIterIntLinkFunction
noPadIterIntLinkFunction = Nothing
padIterIntLinkFunctionWrapper ::
Maybe (Ptr (FunPtr (PadIterIntLinkFunctionC))) ->
PadIterIntLinkFunction ->
Ptr Pad ->
Ptr Object ->
IO (Ptr Iterator)
padIterIntLinkFunctionWrapper funptrptr _cb pad parent = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
result <- _cb pad' maybeParent
maybeReleaseFunPtr funptrptr
result' <- copyBoxed result
return result'
-- callback PadGetRangeFunction
padGetRangeFunctionClosure :: PadGetRangeFunction -> IO Closure
padGetRangeFunctionClosure cb = newCClosure =<< mkPadGetRangeFunction wrapped
where wrapped = padGetRangeFunctionWrapper Nothing cb
type PadGetRangeFunctionC =
Ptr Pad ->
Ptr Object ->
Word64 ->
Word32 ->
Ptr Buffer ->
IO CUInt
foreign import ccall "wrapper"
mkPadGetRangeFunction :: PadGetRangeFunctionC -> IO (FunPtr PadGetRangeFunctionC)
type PadGetRangeFunction =
Pad ->
Maybe Object ->
Word64 ->
Word32 ->
Buffer ->
IO FlowReturn
noPadGetRangeFunction :: Maybe PadGetRangeFunction
noPadGetRangeFunction = Nothing
padGetRangeFunctionWrapper ::
Maybe (Ptr (FunPtr (PadGetRangeFunctionC))) ->
PadGetRangeFunction ->
Ptr Pad ->
Ptr Object ->
Word64 ->
Word32 ->
Ptr Buffer ->
IO CUInt
padGetRangeFunctionWrapper funptrptr _cb pad parent offset length_ buffer = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
buffer' <- (newBoxed Buffer) buffer
result <- _cb pad' maybeParent offset length_ buffer'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadForwardFunction
padForwardFunctionClosure :: PadForwardFunction -> IO Closure
padForwardFunctionClosure cb = newCClosure =<< mkPadForwardFunction wrapped
where wrapped = padForwardFunctionWrapper Nothing cb
type PadForwardFunctionC =
Ptr Pad ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkPadForwardFunction :: PadForwardFunctionC -> IO (FunPtr PadForwardFunctionC)
type PadForwardFunction =
Pad ->
IO Bool
noPadForwardFunction :: Maybe PadForwardFunction
noPadForwardFunction = Nothing
padForwardFunctionWrapper ::
Maybe (Ptr (FunPtr (PadForwardFunctionC))) ->
PadForwardFunction ->
Ptr Pad ->
Ptr () ->
IO CInt
padForwardFunctionWrapper funptrptr _cb pad _ = do
pad' <- (newObject Pad) pad
result <- _cb pad'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadEventFunction
padEventFunctionClosure :: PadEventFunction -> IO Closure
padEventFunctionClosure cb = newCClosure =<< mkPadEventFunction wrapped
where wrapped = padEventFunctionWrapper Nothing cb
type PadEventFunctionC =
Ptr Pad ->
Ptr Object ->
Ptr Event ->
IO CInt
foreign import ccall "wrapper"
mkPadEventFunction :: PadEventFunctionC -> IO (FunPtr PadEventFunctionC)
type PadEventFunction =
Pad ->
Maybe Object ->
Event ->
IO Bool
noPadEventFunction :: Maybe PadEventFunction
noPadEventFunction = Nothing
padEventFunctionWrapper ::
Maybe (Ptr (FunPtr (PadEventFunctionC))) ->
PadEventFunction ->
Ptr Pad ->
Ptr Object ->
Ptr Event ->
IO CInt
padEventFunctionWrapper funptrptr _cb pad parent event = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
event' <- (wrapBoxed Event) event
result <- _cb pad' maybeParent event'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadChainListFunction
padChainListFunctionClosure :: PadChainListFunction -> IO Closure
padChainListFunctionClosure cb = newCClosure =<< mkPadChainListFunction wrapped
where wrapped = padChainListFunctionWrapper Nothing cb
type PadChainListFunctionC =
Ptr Pad ->
Ptr Object ->
Ptr BufferList ->
IO CUInt
foreign import ccall "wrapper"
mkPadChainListFunction :: PadChainListFunctionC -> IO (FunPtr PadChainListFunctionC)
type PadChainListFunction =
Pad ->
Maybe Object ->
BufferList ->
IO FlowReturn
noPadChainListFunction :: Maybe PadChainListFunction
noPadChainListFunction = Nothing
padChainListFunctionWrapper ::
Maybe (Ptr (FunPtr (PadChainListFunctionC))) ->
PadChainListFunction ->
Ptr Pad ->
Ptr Object ->
Ptr BufferList ->
IO CUInt
padChainListFunctionWrapper funptrptr _cb pad parent list = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
list' <- (wrapBoxed BufferList) list
result <- _cb pad' maybeParent list'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadChainFunction
padChainFunctionClosure :: PadChainFunction -> IO Closure
padChainFunctionClosure cb = newCClosure =<< mkPadChainFunction wrapped
where wrapped = padChainFunctionWrapper Nothing cb
type PadChainFunctionC =
Ptr Pad ->
Ptr Object ->
Ptr Buffer ->
IO CUInt
foreign import ccall "wrapper"
mkPadChainFunction :: PadChainFunctionC -> IO (FunPtr PadChainFunctionC)
type PadChainFunction =
Pad ->
Maybe Object ->
Buffer ->
IO FlowReturn
noPadChainFunction :: Maybe PadChainFunction
noPadChainFunction = Nothing
padChainFunctionWrapper ::
Maybe (Ptr (FunPtr (PadChainFunctionC))) ->
PadChainFunction ->
Ptr Pad ->
Ptr Object ->
Ptr Buffer ->
IO CUInt
padChainFunctionWrapper funptrptr _cb pad parent buffer = do
pad' <- (newObject Pad) pad
maybeParent <-
if parent == nullPtr
then return Nothing
else do
parent' <- (newObject Object) parent
return $ Just parent'
buffer' <- (wrapBoxed Buffer) buffer
result <- _cb pad' maybeParent buffer'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadActivateModeFunction
padActivateModeFunctionClosure :: PadActivateModeFunction -> IO Closure
padActivateModeFunctionClosure cb = newCClosure =<< mkPadActivateModeFunction wrapped
where wrapped = padActivateModeFunctionWrapper Nothing cb
type PadActivateModeFunctionC =
Ptr Pad ->
Ptr Object ->
CUInt ->
CInt ->
IO CInt
foreign import ccall "wrapper"
mkPadActivateModeFunction :: PadActivateModeFunctionC -> IO (FunPtr PadActivateModeFunctionC)
type PadActivateModeFunction =
Pad ->
Object ->
PadMode ->
Bool ->
IO Bool
noPadActivateModeFunction :: Maybe PadActivateModeFunction
noPadActivateModeFunction = Nothing
padActivateModeFunctionWrapper ::
Maybe (Ptr (FunPtr (PadActivateModeFunctionC))) ->
PadActivateModeFunction ->
Ptr Pad ->
Ptr Object ->
CUInt ->
CInt ->
IO CInt
padActivateModeFunctionWrapper funptrptr _cb pad parent mode active = do
pad' <- (newObject Pad) pad
parent' <- (newObject Object) parent
let mode' = (toEnum . fromIntegral) mode
let active' = (/= 0) active
result <- _cb pad' parent' mode' active'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback PadActivateFunction
padActivateFunctionClosure :: PadActivateFunction -> IO Closure
padActivateFunctionClosure cb = newCClosure =<< mkPadActivateFunction wrapped
where wrapped = padActivateFunctionWrapper Nothing cb
type PadActivateFunctionC =
Ptr Pad ->
Ptr Object ->
IO CInt
foreign import ccall "wrapper"
mkPadActivateFunction :: PadActivateFunctionC -> IO (FunPtr PadActivateFunctionC)
type PadActivateFunction =
Pad ->
Object ->
IO Bool
noPadActivateFunction :: Maybe PadActivateFunction
noPadActivateFunction = Nothing
padActivateFunctionWrapper ::
Maybe (Ptr (FunPtr (PadActivateFunctionC))) ->
PadActivateFunction ->
Ptr Pad ->
Ptr Object ->
IO CInt
padActivateFunctionWrapper funptrptr _cb pad parent = do
pad' <- (newObject Pad) pad
parent' <- (newObject Object) parent
result <- _cb pad' parent'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback MiniObjectNotify
miniObjectNotifyClosure :: MiniObjectNotify -> IO Closure
miniObjectNotifyClosure cb = newCClosure =<< mkMiniObjectNotify wrapped
where wrapped = miniObjectNotifyWrapper Nothing cb
type MiniObjectNotifyC =
Ptr () ->
Ptr MiniObject ->
IO ()
foreign import ccall "wrapper"
mkMiniObjectNotify :: MiniObjectNotifyC -> IO (FunPtr MiniObjectNotifyC)
type MiniObjectNotify =
MiniObject ->
IO ()
noMiniObjectNotify :: Maybe MiniObjectNotify
noMiniObjectNotify = Nothing
miniObjectNotifyWrapper ::
Maybe (Ptr (FunPtr (MiniObjectNotifyC))) ->
MiniObjectNotify ->
Ptr () ->
Ptr MiniObject ->
IO ()
miniObjectNotifyWrapper funptrptr _cb _ obj = do
obj' <- (newPtr 64 MiniObject) obj
_cb obj'
maybeReleaseFunPtr funptrptr
-- callback MiniObjectFreeFunction
miniObjectFreeFunctionClosure :: MiniObjectFreeFunction -> IO Closure
miniObjectFreeFunctionClosure cb = newCClosure =<< mkMiniObjectFreeFunction wrapped
where wrapped = miniObjectFreeFunctionWrapper Nothing cb
type MiniObjectFreeFunctionC =
Ptr MiniObject ->
IO ()
foreign import ccall "wrapper"
mkMiniObjectFreeFunction :: MiniObjectFreeFunctionC -> IO (FunPtr MiniObjectFreeFunctionC)
type MiniObjectFreeFunction =
MiniObject ->
IO ()
noMiniObjectFreeFunction :: Maybe MiniObjectFreeFunction
noMiniObjectFreeFunction = Nothing
miniObjectFreeFunctionWrapper ::
Maybe (Ptr (FunPtr (MiniObjectFreeFunctionC))) ->
MiniObjectFreeFunction ->
Ptr MiniObject ->
IO ()
miniObjectFreeFunctionWrapper funptrptr _cb obj = do
obj' <- (newPtr 64 MiniObject) obj
_cb obj'
maybeReleaseFunPtr funptrptr
-- callback MiniObjectDisposeFunction
miniObjectDisposeFunctionClosure :: MiniObjectDisposeFunction -> IO Closure
miniObjectDisposeFunctionClosure cb = newCClosure =<< mkMiniObjectDisposeFunction wrapped
where wrapped = miniObjectDisposeFunctionWrapper Nothing cb
type MiniObjectDisposeFunctionC =
Ptr MiniObject ->
IO CInt
foreign import ccall "wrapper"
mkMiniObjectDisposeFunction :: MiniObjectDisposeFunctionC -> IO (FunPtr MiniObjectDisposeFunctionC)
type MiniObjectDisposeFunction =
MiniObject ->
IO Bool
noMiniObjectDisposeFunction :: Maybe MiniObjectDisposeFunction
noMiniObjectDisposeFunction = Nothing
miniObjectDisposeFunctionWrapper ::
Maybe (Ptr (FunPtr (MiniObjectDisposeFunctionC))) ->
MiniObjectDisposeFunction ->
Ptr MiniObject ->
IO CInt
miniObjectDisposeFunctionWrapper funptrptr _cb obj = do
obj' <- (newPtr 64 MiniObject) obj
result <- _cb obj'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback MetaTransformFunction
metaTransformFunctionClosure :: MetaTransformFunction -> IO Closure
metaTransformFunctionClosure cb = newCClosure =<< mkMetaTransformFunction wrapped
where wrapped = metaTransformFunctionWrapper Nothing cb
type MetaTransformFunctionC =
Ptr Buffer ->
Ptr Meta ->
Ptr Buffer ->
Word32 ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkMetaTransformFunction :: MetaTransformFunctionC -> IO (FunPtr MetaTransformFunctionC)
type MetaTransformFunction =
Buffer ->
Meta ->
Buffer ->
Word32 ->
Ptr () ->
IO Bool
noMetaTransformFunction :: Maybe MetaTransformFunction
noMetaTransformFunction = Nothing
metaTransformFunctionWrapper ::
Maybe (Ptr (FunPtr (MetaTransformFunctionC))) ->
MetaTransformFunction ->
Ptr Buffer ->
Ptr Meta ->
Ptr Buffer ->
Word32 ->
Ptr () ->
IO CInt
metaTransformFunctionWrapper funptrptr _cb transbuf meta buffer type_ data_ = do
transbuf' <- (newBoxed Buffer) transbuf
meta' <- (newPtr 16 Meta) meta
buffer' <- (newBoxed Buffer) buffer
result <- _cb transbuf' meta' buffer' type_ data_
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback MetaInitFunction
metaInitFunctionClosure :: MetaInitFunction -> IO Closure
metaInitFunctionClosure cb = newCClosure =<< mkMetaInitFunction wrapped
where wrapped = metaInitFunctionWrapper Nothing cb
type MetaInitFunctionC =
Ptr Meta ->
Ptr () ->
Ptr Buffer ->
IO CInt
foreign import ccall "wrapper"
mkMetaInitFunction :: MetaInitFunctionC -> IO (FunPtr MetaInitFunctionC)
type MetaInitFunction =
Meta ->
Ptr () ->
Buffer ->
IO Bool
noMetaInitFunction :: Maybe MetaInitFunction
noMetaInitFunction = Nothing
metaInitFunctionWrapper ::
Maybe (Ptr (FunPtr (MetaInitFunctionC))) ->
MetaInitFunction ->
Ptr Meta ->
Ptr () ->
Ptr Buffer ->
IO CInt
metaInitFunctionWrapper funptrptr _cb meta params buffer = do
meta' <- (newPtr 16 Meta) meta
buffer' <- (newBoxed Buffer) buffer
result <- _cb meta' params buffer'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback MetaFreeFunction
metaFreeFunctionClosure :: MetaFreeFunction -> IO Closure
metaFreeFunctionClosure cb = newCClosure =<< mkMetaFreeFunction wrapped
where wrapped = metaFreeFunctionWrapper Nothing cb
type MetaFreeFunctionC =
Ptr Meta ->
Ptr Buffer ->
IO ()
foreign import ccall "wrapper"
mkMetaFreeFunction :: MetaFreeFunctionC -> IO (FunPtr MetaFreeFunctionC)
type MetaFreeFunction =
Meta ->
Buffer ->
IO ()
noMetaFreeFunction :: Maybe MetaFreeFunction
noMetaFreeFunction = Nothing
metaFreeFunctionWrapper ::
Maybe (Ptr (FunPtr (MetaFreeFunctionC))) ->
MetaFreeFunction ->
Ptr Meta ->
Ptr Buffer ->
IO ()
metaFreeFunctionWrapper funptrptr _cb meta buffer = do
meta' <- (newPtr 16 Meta) meta
buffer' <- (newBoxed Buffer) buffer
_cb meta' buffer'
maybeReleaseFunPtr funptrptr
-- callback MemoryUnmapFunction
memoryUnmapFunctionClosure :: MemoryUnmapFunction -> IO Closure
memoryUnmapFunctionClosure cb = newCClosure =<< mkMemoryUnmapFunction wrapped
where wrapped = memoryUnmapFunctionWrapper Nothing cb
type MemoryUnmapFunctionC =
Ptr Memory ->
IO ()
foreign import ccall "wrapper"
mkMemoryUnmapFunction :: MemoryUnmapFunctionC -> IO (FunPtr MemoryUnmapFunctionC)
type MemoryUnmapFunction =
Memory ->
IO ()
noMemoryUnmapFunction :: Maybe MemoryUnmapFunction
noMemoryUnmapFunction = Nothing
memoryUnmapFunctionWrapper ::
Maybe (Ptr (FunPtr (MemoryUnmapFunctionC))) ->
MemoryUnmapFunction ->
Ptr Memory ->
IO ()
memoryUnmapFunctionWrapper funptrptr _cb mem = do
mem' <- (newBoxed Memory) mem
_cb mem'
maybeReleaseFunPtr funptrptr
-- callback MemoryUnmapFullFunction
memoryUnmapFullFunctionClosure :: MemoryUnmapFullFunction -> IO Closure
memoryUnmapFullFunctionClosure cb = newCClosure =<< mkMemoryUnmapFullFunction wrapped
where wrapped = memoryUnmapFullFunctionWrapper Nothing cb
type MemoryUnmapFullFunctionC =
Ptr Memory ->
Ptr MapInfo ->
IO ()
foreign import ccall "wrapper"
mkMemoryUnmapFullFunction :: MemoryUnmapFullFunctionC -> IO (FunPtr MemoryUnmapFullFunctionC)
type MemoryUnmapFullFunction =
Memory ->
MapInfo ->
IO ()
noMemoryUnmapFullFunction :: Maybe MemoryUnmapFullFunction
noMemoryUnmapFullFunction = Nothing
memoryUnmapFullFunctionWrapper ::
Maybe (Ptr (FunPtr (MemoryUnmapFullFunctionC))) ->
MemoryUnmapFullFunction ->
Ptr Memory ->
Ptr MapInfo ->
IO ()
memoryUnmapFullFunctionWrapper funptrptr _cb mem info = do
mem' <- (newBoxed Memory) mem
info' <- (newPtr 104 MapInfo) info
_cb mem' info'
maybeReleaseFunPtr funptrptr
-- callback MemoryShareFunction
memoryShareFunctionClosure :: MemoryShareFunction -> IO Closure
memoryShareFunctionClosure cb = newCClosure =<< mkMemoryShareFunction wrapped
where wrapped = memoryShareFunctionWrapper Nothing cb
type MemoryShareFunctionC =
Ptr Memory ->
Int64 ->
Int64 ->
IO (Ptr Memory)
foreign import ccall "wrapper"
mkMemoryShareFunction :: MemoryShareFunctionC -> IO (FunPtr MemoryShareFunctionC)
type MemoryShareFunction =
Memory ->
Int64 ->
Int64 ->
IO Memory
noMemoryShareFunction :: Maybe MemoryShareFunction
noMemoryShareFunction = Nothing
memoryShareFunctionWrapper ::
Maybe (Ptr (FunPtr (MemoryShareFunctionC))) ->
MemoryShareFunction ->
Ptr Memory ->
Int64 ->
Int64 ->
IO (Ptr Memory)
memoryShareFunctionWrapper funptrptr _cb mem offset size = do
mem' <- (newBoxed Memory) mem
result <- _cb mem' offset size
maybeReleaseFunPtr funptrptr
result' <- copyBoxed result
return result'
-- callback MemoryIsSpanFunction
memoryIsSpanFunctionClosure :: MemoryIsSpanFunction -> IO Closure
memoryIsSpanFunctionClosure cb = newCClosure =<< mkMemoryIsSpanFunction wrapped
where wrapped = memoryIsSpanFunctionWrapper Nothing cb
type MemoryIsSpanFunctionC =
Ptr Memory ->
Ptr Memory ->
Word64 ->
IO CInt
foreign import ccall "wrapper"
mkMemoryIsSpanFunction :: MemoryIsSpanFunctionC -> IO (FunPtr MemoryIsSpanFunctionC)
type MemoryIsSpanFunction =
Memory ->
Memory ->
Word64 ->
IO Bool
noMemoryIsSpanFunction :: Maybe MemoryIsSpanFunction
noMemoryIsSpanFunction = Nothing
memoryIsSpanFunctionWrapper ::
Maybe (Ptr (FunPtr (MemoryIsSpanFunctionC))) ->
MemoryIsSpanFunction ->
Ptr Memory ->
Ptr Memory ->
Word64 ->
IO CInt
memoryIsSpanFunctionWrapper funptrptr _cb mem1 mem2 offset = do
mem1' <- (newBoxed Memory) mem1
mem2' <- (newBoxed Memory) mem2
result <- _cb mem1' mem2' offset
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback MemoryCopyFunction
memoryCopyFunctionClosure :: MemoryCopyFunction -> IO Closure
memoryCopyFunctionClosure cb = newCClosure =<< mkMemoryCopyFunction wrapped
where wrapped = memoryCopyFunctionWrapper Nothing cb
type MemoryCopyFunctionC =
Ptr Memory ->
Int64 ->
Int64 ->
IO (Ptr Memory)
foreign import ccall "wrapper"
mkMemoryCopyFunction :: MemoryCopyFunctionC -> IO (FunPtr MemoryCopyFunctionC)
type MemoryCopyFunction =
Memory ->
Int64 ->
Int64 ->
IO Memory
noMemoryCopyFunction :: Maybe MemoryCopyFunction
noMemoryCopyFunction = Nothing
memoryCopyFunctionWrapper ::
Maybe (Ptr (FunPtr (MemoryCopyFunctionC))) ->
MemoryCopyFunction ->
Ptr Memory ->
Int64 ->
Int64 ->
IO (Ptr Memory)
memoryCopyFunctionWrapper funptrptr _cb mem offset size = do
mem' <- (newBoxed Memory) mem
result <- _cb mem' offset size
maybeReleaseFunPtr funptrptr
result' <- copyBoxed result
return result'
-- callback LogFunction
logFunctionClosure :: LogFunction -> IO Closure
logFunctionClosure cb = newCClosure =<< mkLogFunction wrapped
where wrapped = logFunctionWrapper Nothing cb
type LogFunctionC =
Ptr DebugCategory ->
CUInt ->
CString ->
CString ->
Int32 ->
Ptr GObject.Object ->
Ptr DebugMessage ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkLogFunction :: LogFunctionC -> IO (FunPtr LogFunctionC)
type LogFunction =
DebugCategory ->
DebugLevel ->
T.Text ->
T.Text ->
Int32 ->
GObject.Object ->
DebugMessage ->
IO ()
noLogFunction :: Maybe LogFunction
noLogFunction = Nothing
logFunctionWrapper ::
Maybe (Ptr (FunPtr (LogFunctionC))) ->
LogFunction ->
Ptr DebugCategory ->
CUInt ->
CString ->
CString ->
Int32 ->
Ptr GObject.Object ->
Ptr DebugMessage ->
Ptr () ->
IO ()
logFunctionWrapper funptrptr _cb category level file function line object message _ = do
category' <- (newPtr 24 DebugCategory) category
let level' = (toEnum . fromIntegral) level
file' <- cstringToText file
function' <- cstringToText function
object' <- (newObject GObject.Object) object
-- XXX Wrapping a foreign struct/union with no known destructor, leak?
message' <- (\x -> DebugMessage <$> newForeignPtr_ x) message
_cb category' level' file' function' line object' message'
maybeReleaseFunPtr funptrptr
-- callback IteratorResyncFunction
iteratorResyncFunctionClosure :: IteratorResyncFunction -> IO Closure
iteratorResyncFunctionClosure cb = newCClosure =<< mkIteratorResyncFunction wrapped
where wrapped = iteratorResyncFunctionWrapper Nothing cb
type IteratorResyncFunctionC =
Ptr Iterator ->
IO ()
foreign import ccall "wrapper"
mkIteratorResyncFunction :: IteratorResyncFunctionC -> IO (FunPtr IteratorResyncFunctionC)
type IteratorResyncFunction =
Iterator ->
IO ()
noIteratorResyncFunction :: Maybe IteratorResyncFunction
noIteratorResyncFunction = Nothing
iteratorResyncFunctionWrapper ::
Maybe (Ptr (FunPtr (IteratorResyncFunctionC))) ->
IteratorResyncFunction ->
Ptr Iterator ->
IO ()
iteratorResyncFunctionWrapper funptrptr _cb it = do
it' <- (newBoxed Iterator) it
_cb it'
maybeReleaseFunPtr funptrptr
-- callback IteratorNextFunction
iteratorNextFunctionClosure :: IteratorNextFunction -> IO Closure
iteratorNextFunctionClosure cb = newCClosure =<< mkIteratorNextFunction wrapped
where wrapped = iteratorNextFunctionWrapper Nothing cb
type IteratorNextFunctionC =
Ptr Iterator ->
Ptr GValue ->
IO CUInt
foreign import ccall "wrapper"
mkIteratorNextFunction :: IteratorNextFunctionC -> IO (FunPtr IteratorNextFunctionC)
type IteratorNextFunction =
Iterator ->
GValue ->
IO IteratorResult
noIteratorNextFunction :: Maybe IteratorNextFunction
noIteratorNextFunction = Nothing
iteratorNextFunctionWrapper ::
Maybe (Ptr (FunPtr (IteratorNextFunctionC))) ->
IteratorNextFunction ->
Ptr Iterator ->
Ptr GValue ->
IO CUInt
iteratorNextFunctionWrapper funptrptr _cb it result_ = do
it' <- (newBoxed Iterator) it
result_' <- (newBoxed GValue) result_
result <- _cb it' result_'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback IteratorItemFunction
iteratorItemFunctionClosure :: IteratorItemFunction -> IO Closure
iteratorItemFunctionClosure cb = newCClosure =<< mkIteratorItemFunction wrapped
where wrapped = iteratorItemFunctionWrapper Nothing cb
type IteratorItemFunctionC =
Ptr Iterator ->
Ptr GValue ->
IO CUInt
foreign import ccall "wrapper"
mkIteratorItemFunction :: IteratorItemFunctionC -> IO (FunPtr IteratorItemFunctionC)
type IteratorItemFunction =
Iterator ->
GValue ->
IO IteratorItem
noIteratorItemFunction :: Maybe IteratorItemFunction
noIteratorItemFunction = Nothing
iteratorItemFunctionWrapper ::
Maybe (Ptr (FunPtr (IteratorItemFunctionC))) ->
IteratorItemFunction ->
Ptr Iterator ->
Ptr GValue ->
IO CUInt
iteratorItemFunctionWrapper funptrptr _cb it item = do
it' <- (newBoxed Iterator) it
item' <- (newBoxed GValue) item
result <- _cb it' item'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback IteratorFreeFunction
iteratorFreeFunctionClosure :: IteratorFreeFunction -> IO Closure
iteratorFreeFunctionClosure cb = newCClosure =<< mkIteratorFreeFunction wrapped
where wrapped = iteratorFreeFunctionWrapper Nothing cb
type IteratorFreeFunctionC =
Ptr Iterator ->
IO ()
foreign import ccall "wrapper"
mkIteratorFreeFunction :: IteratorFreeFunctionC -> IO (FunPtr IteratorFreeFunctionC)
type IteratorFreeFunction =
Iterator ->
IO ()
noIteratorFreeFunction :: Maybe IteratorFreeFunction
noIteratorFreeFunction = Nothing
iteratorFreeFunctionWrapper ::
Maybe (Ptr (FunPtr (IteratorFreeFunctionC))) ->
IteratorFreeFunction ->
Ptr Iterator ->
IO ()
iteratorFreeFunctionWrapper funptrptr _cb it = do
it' <- (newBoxed Iterator) it
_cb it'
maybeReleaseFunPtr funptrptr
-- callback IteratorForeachFunction
iteratorForeachFunctionClosure :: IteratorForeachFunction -> IO Closure
iteratorForeachFunctionClosure cb = newCClosure =<< mkIteratorForeachFunction wrapped
where wrapped = iteratorForeachFunctionWrapper Nothing cb
type IteratorForeachFunctionC =
Ptr GValue ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mkIteratorForeachFunction :: IteratorForeachFunctionC -> IO (FunPtr IteratorForeachFunctionC)
type IteratorForeachFunction =
GValue ->
IO ()
noIteratorForeachFunction :: Maybe IteratorForeachFunction
noIteratorForeachFunction = Nothing
iteratorForeachFunctionWrapper ::
Maybe (Ptr (FunPtr (IteratorForeachFunctionC))) ->
IteratorForeachFunction ->
Ptr GValue ->
Ptr () ->
IO ()
iteratorForeachFunctionWrapper funptrptr _cb item _ = do
item' <- (newBoxed GValue) item
_cb item'
maybeReleaseFunPtr funptrptr
-- callback IteratorFoldFunction
iteratorFoldFunctionClosure :: IteratorFoldFunction -> IO Closure
iteratorFoldFunctionClosure cb = newCClosure =<< mkIteratorFoldFunction wrapped
where wrapped = iteratorFoldFunctionWrapper Nothing cb
type IteratorFoldFunctionC =
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkIteratorFoldFunction :: IteratorFoldFunctionC -> IO (FunPtr IteratorFoldFunctionC)
type IteratorFoldFunction =
GValue ->
GValue ->
IO Bool
noIteratorFoldFunction :: Maybe IteratorFoldFunction
noIteratorFoldFunction = Nothing
iteratorFoldFunctionWrapper ::
Maybe (Ptr (FunPtr (IteratorFoldFunctionC))) ->
IteratorFoldFunction ->
Ptr GValue ->
Ptr GValue ->
Ptr () ->
IO CInt
iteratorFoldFunctionWrapper funptrptr _cb item ret _ = do
item' <- (newBoxed GValue) item
ret' <- (newBoxed GValue) ret
result <- _cb item' ret'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback IteratorCopyFunction
iteratorCopyFunctionClosure :: IteratorCopyFunction -> IO Closure
iteratorCopyFunctionClosure cb = newCClosure =<< mkIteratorCopyFunction wrapped
where wrapped = iteratorCopyFunctionWrapper Nothing cb
type IteratorCopyFunctionC =
Ptr Iterator ->
Ptr Iterator ->
IO ()
foreign import ccall "wrapper"
mkIteratorCopyFunction :: IteratorCopyFunctionC -> IO (FunPtr IteratorCopyFunctionC)
type IteratorCopyFunction =
Iterator ->
Iterator ->
IO ()
noIteratorCopyFunction :: Maybe IteratorCopyFunction
noIteratorCopyFunction = Nothing
iteratorCopyFunctionWrapper ::
Maybe (Ptr (FunPtr (IteratorCopyFunctionC))) ->
IteratorCopyFunction ->
Ptr Iterator ->
Ptr Iterator ->
IO ()
iteratorCopyFunctionWrapper funptrptr _cb it copy = do
it' <- (newBoxed Iterator) it
copy' <- (newBoxed Iterator) copy
_cb it' copy'
maybeReleaseFunPtr funptrptr
-- callback DebugFuncPtr
debugFuncPtrClosure :: DebugFuncPtr -> IO Closure
debugFuncPtrClosure cb = newCClosure =<< mkDebugFuncPtr wrapped
where wrapped = debugFuncPtrWrapper Nothing cb
type DebugFuncPtrC =
IO ()
foreign import ccall "wrapper"
mkDebugFuncPtr :: DebugFuncPtrC -> IO (FunPtr DebugFuncPtrC)
type DebugFuncPtr =
IO ()
noDebugFuncPtr :: Maybe DebugFuncPtr
noDebugFuncPtr = Nothing
debugFuncPtrWrapper ::
Maybe (Ptr (FunPtr (DebugFuncPtrC))) ->
DebugFuncPtr ->
IO ()
debugFuncPtrWrapper funptrptr _cb = do
_cb
maybeReleaseFunPtr funptrptr
-- callback ControlSourceGetValueArray
controlSourceGetValueArrayClosure :: ControlSourceGetValueArray -> IO Closure
controlSourceGetValueArrayClosure cb = newCClosure =<< mkControlSourceGetValueArray wrapped
where wrapped = controlSourceGetValueArrayWrapper Nothing cb
type ControlSourceGetValueArrayC =
Ptr ControlSource ->
Word64 ->
Word64 ->
Word32 ->
CDouble ->
IO CInt
foreign import ccall "wrapper"
mkControlSourceGetValueArray :: ControlSourceGetValueArrayC -> IO (FunPtr ControlSourceGetValueArrayC)
type ControlSourceGetValueArray =
ControlSource ->
Word64 ->
Word64 ->
Word32 ->
Double ->
IO Bool
noControlSourceGetValueArray :: Maybe ControlSourceGetValueArray
noControlSourceGetValueArray = Nothing
controlSourceGetValueArrayWrapper ::
Maybe (Ptr (FunPtr (ControlSourceGetValueArrayC))) ->
ControlSourceGetValueArray ->
Ptr ControlSource ->
Word64 ->
Word64 ->
Word32 ->
CDouble ->
IO CInt
controlSourceGetValueArrayWrapper funptrptr _cb self timestamp interval nValues values = do
self' <- (newObject ControlSource) self
let values' = realToFrac values
result <- _cb self' timestamp interval nValues values'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback ControlSourceGetValue
controlSourceGetValueClosure :: ControlSourceGetValue -> IO Closure
controlSourceGetValueClosure cb = newCClosure =<< mkControlSourceGetValue wrapped
where wrapped = controlSourceGetValueWrapper Nothing cb
type ControlSourceGetValueC =
Ptr ControlSource ->
Word64 ->
CDouble ->
IO CInt
foreign import ccall "wrapper"
mkControlSourceGetValue :: ControlSourceGetValueC -> IO (FunPtr ControlSourceGetValueC)
type ControlSourceGetValue =
ControlSource ->
Word64 ->
Double ->
IO Bool
noControlSourceGetValue :: Maybe ControlSourceGetValue
noControlSourceGetValue = Nothing
controlSourceGetValueWrapper ::
Maybe (Ptr (FunPtr (ControlSourceGetValueC))) ->
ControlSourceGetValue ->
Ptr ControlSource ->
Word64 ->
CDouble ->
IO CInt
controlSourceGetValueWrapper funptrptr _cb self timestamp value = do
self' <- (newObject ControlSource) self
let value' = realToFrac value
result <- _cb self' timestamp value'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback ControlBindingConvert
controlBindingConvertClosure :: ControlBindingConvert -> IO Closure
controlBindingConvertClosure cb = newCClosure =<< mkControlBindingConvert wrapped
where wrapped = controlBindingConvertWrapper Nothing cb
type ControlBindingConvertC =
Ptr ControlBinding ->
CDouble ->
Ptr GValue ->
IO ()
foreign import ccall "wrapper"
mkControlBindingConvert :: ControlBindingConvertC -> IO (FunPtr ControlBindingConvertC)
type ControlBindingConvert =
ControlBinding ->
Double ->
GValue ->
IO ()
noControlBindingConvert :: Maybe ControlBindingConvert
noControlBindingConvert = Nothing
controlBindingConvertWrapper ::
Maybe (Ptr (FunPtr (ControlBindingConvertC))) ->
ControlBindingConvert ->
Ptr ControlBinding ->
CDouble ->
Ptr GValue ->
IO ()
controlBindingConvertWrapper funptrptr _cb binding srcValue destValue = do
binding' <- (newObject ControlBinding) binding
let srcValue' = realToFrac srcValue
destValue' <- (newBoxed GValue) destValue
_cb binding' srcValue' destValue'
maybeReleaseFunPtr funptrptr
-- callback ClockCallback
clockCallbackClosure :: ClockCallback -> IO Closure
clockCallbackClosure cb = newCClosure =<< mkClockCallback wrapped
where wrapped = clockCallbackWrapper Nothing cb
type ClockCallbackC =
Ptr Clock ->
Word64 ->
Ptr () ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkClockCallback :: ClockCallbackC -> IO (FunPtr ClockCallbackC)
type ClockCallback =
Clock ->
Word64 ->
Ptr () ->
IO Bool
noClockCallback :: Maybe ClockCallback
noClockCallback = Nothing
clockCallbackWrapper ::
Maybe (Ptr (FunPtr (ClockCallbackC))) ->
ClockCallback ->
Ptr Clock ->
Word64 ->
Ptr () ->
Ptr () ->
IO CInt
clockCallbackWrapper funptrptr _cb clock time id _ = do
clock' <- (newObject Clock) clock
result <- _cb clock' time id
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback CapsMapFunc
capsMapFuncClosure :: CapsMapFunc -> IO Closure
capsMapFuncClosure cb = newCClosure =<< mkCapsMapFunc wrapped
where wrapped = capsMapFuncWrapper Nothing cb
type CapsMapFuncC =
Ptr CapsFeatures ->
Ptr Structure ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkCapsMapFunc :: CapsMapFuncC -> IO (FunPtr CapsMapFuncC)
type CapsMapFunc =
CapsFeatures ->
Structure ->
IO Bool
noCapsMapFunc :: Maybe CapsMapFunc
noCapsMapFunc = Nothing
capsMapFuncWrapper ::
Maybe (Ptr (FunPtr (CapsMapFuncC))) ->
CapsMapFunc ->
Ptr CapsFeatures ->
Ptr Structure ->
Ptr () ->
IO CInt
capsMapFuncWrapper funptrptr _cb features structure _ = do
features' <- (newBoxed CapsFeatures) features
structure' <- (newBoxed Structure) structure
result <- _cb features' structure'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback CapsForeachFunc
capsForeachFuncClosure :: CapsForeachFunc -> IO Closure
capsForeachFuncClosure cb = newCClosure =<< mkCapsForeachFunc wrapped
where wrapped = capsForeachFuncWrapper Nothing cb
type CapsForeachFuncC =
Ptr CapsFeatures ->
Ptr Structure ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkCapsForeachFunc :: CapsForeachFuncC -> IO (FunPtr CapsForeachFuncC)
type CapsForeachFunc =
CapsFeatures ->
Structure ->
IO Bool
noCapsForeachFunc :: Maybe CapsForeachFunc
noCapsForeachFunc = Nothing
capsForeachFuncWrapper ::
Maybe (Ptr (FunPtr (CapsForeachFuncC))) ->
CapsForeachFunc ->
Ptr CapsFeatures ->
Ptr Structure ->
Ptr () ->
IO CInt
capsForeachFuncWrapper funptrptr _cb features structure _ = do
features' <- (newBoxed CapsFeatures) features
structure' <- (newBoxed Structure) structure
result <- _cb features' structure'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback CapsFilterMapFunc
capsFilterMapFuncClosure :: CapsFilterMapFunc -> IO Closure
capsFilterMapFuncClosure cb = newCClosure =<< mkCapsFilterMapFunc wrapped
where wrapped = capsFilterMapFuncWrapper Nothing cb
type CapsFilterMapFuncC =
Ptr CapsFeatures ->
Ptr Structure ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkCapsFilterMapFunc :: CapsFilterMapFuncC -> IO (FunPtr CapsFilterMapFuncC)
type CapsFilterMapFunc =
CapsFeatures ->
Structure ->
IO Bool
noCapsFilterMapFunc :: Maybe CapsFilterMapFunc
noCapsFilterMapFunc = Nothing
capsFilterMapFuncWrapper ::
Maybe (Ptr (FunPtr (CapsFilterMapFuncC))) ->
CapsFilterMapFunc ->
Ptr CapsFeatures ->
Ptr Structure ->
Ptr () ->
IO CInt
capsFilterMapFuncWrapper funptrptr _cb features structure _ = do
features' <- (newBoxed CapsFeatures) features
structure' <- (newBoxed Structure) structure
result <- _cb features' structure'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback BusSyncHandler
busSyncHandlerClosure :: BusSyncHandler -> IO Closure
busSyncHandlerClosure cb = newCClosure =<< mkBusSyncHandler wrapped
where wrapped = busSyncHandlerWrapper Nothing cb
type BusSyncHandlerC =
Ptr Bus ->
Ptr Message ->
Ptr () ->
IO CUInt
foreign import ccall "wrapper"
mkBusSyncHandler :: BusSyncHandlerC -> IO (FunPtr BusSyncHandlerC)
type BusSyncHandler =
Bus ->
Message ->
IO BusSyncReply
noBusSyncHandler :: Maybe BusSyncHandler
noBusSyncHandler = Nothing
busSyncHandlerWrapper ::
Maybe (Ptr (FunPtr (BusSyncHandlerC))) ->
BusSyncHandler ->
Ptr Bus ->
Ptr Message ->
Ptr () ->
IO CUInt
busSyncHandlerWrapper funptrptr _cb bus message _ = do
bus' <- (newObject Bus) bus
message' <- (newBoxed Message) message
result <- _cb bus' message'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback BusFunc
busFuncClosure :: BusFunc -> IO Closure
busFuncClosure cb = newCClosure =<< mkBusFunc wrapped
where wrapped = busFuncWrapper Nothing cb
type BusFuncC =
Ptr Bus ->
Ptr Message ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkBusFunc :: BusFuncC -> IO (FunPtr BusFuncC)
type BusFunc =
Bus ->
Message ->
IO Bool
noBusFunc :: Maybe BusFunc
noBusFunc = Nothing
busFuncWrapper ::
Maybe (Ptr (FunPtr (BusFuncC))) ->
BusFunc ->
Ptr Bus ->
Ptr Message ->
Ptr () ->
IO CInt
busFuncWrapper funptrptr _cb bus message _ = do
bus' <- (newObject Bus) bus
message' <- (newBoxed Message) message
result <- _cb bus' message'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback BufferListFunc
bufferListFuncClosure :: BufferListFunc -> IO Closure
bufferListFuncClosure cb = newCClosure =<< mkBufferListFunc wrapped
where wrapped = bufferListFuncWrapper Nothing cb
type BufferListFuncC =
Ptr (Ptr Buffer) ->
Word32 ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkBufferListFunc :: BufferListFuncC -> IO (FunPtr BufferListFuncC)
type BufferListFunc =
Word32 ->
IO (Bool,(Maybe Buffer))
noBufferListFunc :: Maybe BufferListFunc
noBufferListFunc = Nothing
bufferListFuncWrapper ::
Maybe (Ptr (FunPtr (BufferListFuncC))) ->
BufferListFunc ->
Ptr (Ptr Buffer) ->
Word32 ->
Ptr () ->
IO CInt
bufferListFuncWrapper funptrptr _cb buffer idx _ = do
(result, outbuffer) <- _cb idx
outbuffer' <- case outbuffer of
Nothing -> return nullPtr
Just outbuffer' -> do
outbuffer'' <- copyBoxed outbuffer'
return outbuffer''
poke buffer outbuffer'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'
-- callback BufferForeachMetaFunc
bufferForeachMetaFuncClosure :: BufferForeachMetaFunc -> IO Closure
bufferForeachMetaFuncClosure cb = newCClosure =<< mkBufferForeachMetaFunc wrapped
where wrapped = bufferForeachMetaFuncWrapper Nothing cb
type BufferForeachMetaFuncC =
Ptr Buffer ->
Ptr (Ptr Meta) ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mkBufferForeachMetaFunc :: BufferForeachMetaFuncC -> IO (FunPtr BufferForeachMetaFuncC)
type BufferForeachMetaFunc =
Buffer ->
IO (Bool,(Maybe Meta))
noBufferForeachMetaFunc :: Maybe BufferForeachMetaFunc
noBufferForeachMetaFunc = Nothing
bufferForeachMetaFuncWrapper ::
Maybe (Ptr (FunPtr (BufferForeachMetaFuncC))) ->
BufferForeachMetaFunc ->
Ptr Buffer ->
Ptr (Ptr Meta) ->
Ptr () ->
IO CInt
bufferForeachMetaFuncWrapper funptrptr _cb buffer meta _ = do
buffer' <- (newBoxed Buffer) buffer
(result, outmeta) <- _cb buffer'
outmeta' <- case outmeta of
Nothing -> return nullPtr
Just outmeta' -> do
let outmeta'' = unsafeManagedPtrGetPtr outmeta'
return outmeta''
poke meta outmeta'
maybeReleaseFunPtr funptrptr
let result' = (fromIntegral . fromEnum) result
return result'