packages feed

gi-gst (empty) → 0.1.6.13

raw patch · 161 files changed

+63447/−0 lines, 161 filesdep +basedep +bytestringdep +containerssetup-changed

Dependencies added: base, bytestring, containers, gi-glib, gi-gobject, haskell-gi-base, text, transformers

Files

+ GI/Gst.hs view
@@ -0,0 +1,56 @@+++{- |+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+    (     module GI.Gst.Callbacks                 ,+    module GI.Gst.Constants                 ,+    module GI.Gst.Enums                     ,+    module GI.Gst.Flags                     ,+    module GI.Gst.Functions                 ,+    module GI.Gst.Interfaces                ,+    module GI.Gst.Objects                   ,+    module GI.Gst.Structs                   ,++++    module Data.GI.Base                     ,+++    ) where++import GI.Gst.Callbacks+import GI.Gst.Constants+import GI.Gst.Enums+import GI.Gst.Flags+import GI.Gst.Functions+import GI.Gst.Interfaces+import GI.Gst.Objects+import GI.Gst.Structs++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 GI.Gst.Callbacks++import Data.GI.Base+-- APIObject "Bitmask" does not descend from GObject, it will be ignored.+-- APIObject "DoubleRange" does not descend from GObject, it will be ignored.+-- APIObject "FlagSet" does not descend from GObject, it will be ignored.+-- APIObject "Fraction" does not descend from GObject, it will be ignored.+-- APIObject "FractionRange" does not descend from GObject, it will be ignored.+-- APIObject "Int64Range" does not descend from GObject, it will be ignored.+-- APIObject "IntRange" does not descend from GObject, it will be ignored.+-- APIObject "ParamFraction" does not descend from GObject, it will be ignored.+-- APIObject "ValueArray" does not descend from GObject, it will be ignored.+-- APIObject "ValueList" does not descend from GObject, it will be ignored.+
+ GI/Gst/Callbacks.hs view
@@ -0,0 +1,2873 @@+++{- |+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'++
+ GI/Gst/Constants.hs view
@@ -0,0 +1,734 @@+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}+++{- |+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.Constants+    ( +    pattern VERSION_NANO                    ,+    pattern VERSION_MINOR                   ,+    pattern VERSION_MICRO                   ,+    pattern VERSION_MAJOR                   ,+    pattern VALUE_UNORDERED                 ,+    pattern VALUE_LESS_THAN                 ,+    pattern VALUE_GREATER_THAN              ,+    pattern VALUE_EQUAL                     ,+    pattern USECOND                         ,+    pattern URI_NO_PORT                     ,+    pattern TOC_REPEAT_COUNT_INFINITE       ,+    pattern TIME_FORMAT                     ,+    pattern TAG_VIDEO_CODEC                 ,+    pattern TAG_VERSION                     ,+    pattern TAG_USER_RATING                 ,+    pattern TAG_TRACK_PEAK                  ,+    pattern TAG_TRACK_NUMBER                ,+    pattern TAG_TRACK_GAIN                  ,+    pattern TAG_TRACK_COUNT                 ,+    pattern TAG_TITLE_SORTNAME              ,+    pattern TAG_TITLE                       ,+    pattern TAG_SUBTITLE_CODEC              ,+    pattern TAG_SHOW_SORTNAME               ,+    pattern TAG_SHOW_SEASON_NUMBER          ,+    pattern TAG_SHOW_NAME                   ,+    pattern TAG_SHOW_EPISODE_NUMBER         ,+    pattern TAG_SERIAL                      ,+    pattern TAG_REFERENCE_LEVEL             ,+    pattern TAG_PUBLISHER                   ,+    pattern TAG_PREVIEW_IMAGE               ,+    pattern TAG_PERFORMER                   ,+    pattern TAG_ORGANIZATION                ,+    pattern TAG_NOMINAL_BITRATE             ,+    pattern TAG_MINIMUM_BITRATE             ,+    pattern TAG_MIDI_BASE_NOTE              ,+    pattern TAG_MAXIMUM_BITRATE             ,+    pattern TAG_LYRICS                      ,+    pattern TAG_LOCATION                    ,+    pattern TAG_LICENSE_URI                 ,+    pattern TAG_LICENSE                     ,+    pattern TAG_LANGUAGE_NAME               ,+    pattern TAG_LANGUAGE_CODE               ,+    pattern TAG_KEYWORDS                    ,+    pattern TAG_ISRC                        ,+    pattern TAG_INTERPRETED_BY              ,+    pattern TAG_IMAGE_ORIENTATION           ,+    pattern TAG_IMAGE                       ,+    pattern TAG_HOMEPAGE                    ,+    pattern TAG_GROUPING                    ,+    pattern TAG_GEO_LOCATION_SUBLOCATION    ,+    pattern TAG_GEO_LOCATION_NAME           ,+    pattern TAG_GEO_LOCATION_MOVEMENT_SPEED ,+    pattern TAG_GEO_LOCATION_MOVEMENT_DIRECTION,+    pattern TAG_GEO_LOCATION_LONGITUDE      ,+    pattern TAG_GEO_LOCATION_LATITUDE       ,+    pattern TAG_GEO_LOCATION_HORIZONTAL_ERROR,+    pattern TAG_GEO_LOCATION_ELEVATION      ,+    pattern TAG_GEO_LOCATION_COUNTRY        ,+    pattern TAG_GEO_LOCATION_CITY           ,+    pattern TAG_GEO_LOCATION_CAPTURE_DIRECTION,+    pattern TAG_GENRE                       ,+    pattern TAG_EXTENDED_COMMENT            ,+    pattern TAG_ENCODER_VERSION             ,+    pattern TAG_ENCODER                     ,+    pattern TAG_ENCODED_BY                  ,+    pattern TAG_DURATION                    ,+    pattern TAG_DEVICE_MODEL                ,+    pattern TAG_DEVICE_MANUFACTURER         ,+    pattern TAG_DESCRIPTION                 ,+    pattern TAG_DATE_TIME                   ,+    pattern TAG_DATE                        ,+    pattern TAG_COPYRIGHT_URI               ,+    pattern TAG_COPYRIGHT                   ,+    pattern TAG_CONTAINER_FORMAT            ,+    pattern TAG_CONTACT                     ,+    pattern TAG_COMPOSER_SORTNAME           ,+    pattern TAG_COMPOSER                    ,+    pattern TAG_COMMENT                     ,+    pattern TAG_CODEC                       ,+    pattern TAG_BITRATE                     ,+    pattern TAG_BEATS_PER_MINUTE            ,+    pattern TAG_AUDIO_CODEC                 ,+    pattern TAG_ATTACHMENT                  ,+    pattern TAG_ARTIST_SORTNAME             ,+    pattern TAG_ARTIST                      ,+    pattern TAG_APPLICATION_NAME            ,+    pattern TAG_APPLICATION_DATA            ,+    pattern TAG_ALBUM_VOLUME_NUMBER         ,+    pattern TAG_ALBUM_VOLUME_COUNT          ,+    pattern TAG_ALBUM_SORTNAME              ,+    pattern TAG_ALBUM_PEAK                  ,+    pattern TAG_ALBUM_GAIN                  ,+    pattern TAG_ALBUM_ARTIST_SORTNAME       ,+    pattern TAG_ALBUM_ARTIST                ,+    pattern TAG_ALBUM                       ,+    pattern STIME_FORMAT                    ,+    pattern SEGMENT_FORMAT                  ,+    pattern SECOND                          ,+    pattern QUERY_TYPE_BOTH                 ,+    pattern QUERY_NUM_SHIFT                 ,+    pattern PTR_FORMAT                      ,+    pattern PROTECTION_SYSTEM_ID_CAPS_FIELD ,+    pattern PARAM_USER_SHIFT                ,+    pattern PARAM_MUTABLE_READY             ,+    pattern PARAM_MUTABLE_PLAYING           ,+    pattern PARAM_MUTABLE_PAUSED            ,+    pattern PARAM_CONTROLLABLE              ,+    pattern NSECOND                         ,+    pattern MSECOND                         ,+    pattern META_TAG_MEMORY_STR             ,+    pattern MAP_READWRITE                   ,+    pattern LOCK_FLAG_READWRITE             ,+    pattern LICENSE_UNKNOWN                 ,+    pattern FOURCC_FORMAT                   ,+    pattern FORMAT_PERCENT_SCALE            ,+    pattern FORMAT_PERCENT_MAX              ,+    pattern FLAG_SET_MASK_EXACT             ,+    pattern EVENT_TYPE_BOTH                 ,+    pattern EVENT_NUM_SHIFT                 ,+    pattern ERROR_SYSTEM                    ,+    pattern ELEMENT_METADATA_LONGNAME       ,+    pattern ELEMENT_METADATA_KLASS          ,+    pattern ELEMENT_METADATA_ICON_NAME      ,+    pattern ELEMENT_METADATA_DOC_URI        ,+    pattern ELEMENT_METADATA_DESCRIPTION    ,+    pattern ELEMENT_METADATA_AUTHOR         ,+    pattern ELEMENT_FACTORY_TYPE_VIDEO_ENCODER,+    pattern ELEMENT_FACTORY_TYPE_SRC        ,+    pattern ELEMENT_FACTORY_TYPE_SINK       ,+    pattern ELEMENT_FACTORY_TYPE_PAYLOADER  ,+    pattern ELEMENT_FACTORY_TYPE_PARSER     ,+    pattern ELEMENT_FACTORY_TYPE_MUXER      ,+    pattern ELEMENT_FACTORY_TYPE_MEDIA_VIDEO,+    pattern ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE,+    pattern ELEMENT_FACTORY_TYPE_MEDIA_METADATA,+    pattern ELEMENT_FACTORY_TYPE_MEDIA_IMAGE,+    pattern ELEMENT_FACTORY_TYPE_MEDIA_AUDIO,+    pattern ELEMENT_FACTORY_TYPE_MEDIA_ANY  ,+    pattern ELEMENT_FACTORY_TYPE_MAX_ELEMENTS,+    pattern ELEMENT_FACTORY_TYPE_FORMATTER  ,+    pattern ELEMENT_FACTORY_TYPE_ENCRYPTOR  ,+    pattern ELEMENT_FACTORY_TYPE_ENCODER    ,+    pattern ELEMENT_FACTORY_TYPE_DEPAYLOADER,+    pattern ELEMENT_FACTORY_TYPE_DEMUXER    ,+    pattern ELEMENT_FACTORY_TYPE_DECRYPTOR  ,+    pattern ELEMENT_FACTORY_TYPE_DECODER    ,+    pattern ELEMENT_FACTORY_TYPE_DECODABLE  ,+    pattern ELEMENT_FACTORY_TYPE_AUDIO_ENCODER,+    pattern ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS,+    pattern ELEMENT_FACTORY_TYPE_ANY        ,+    pattern ELEMENT_FACTORY_KLASS_SRC       ,+    pattern ELEMENT_FACTORY_KLASS_SINK      ,+    pattern ELEMENT_FACTORY_KLASS_PAYLOADER ,+    pattern ELEMENT_FACTORY_KLASS_PARSER    ,+    pattern ELEMENT_FACTORY_KLASS_MUXER     ,+    pattern ELEMENT_FACTORY_KLASS_MEDIA_VIDEO,+    pattern ELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE,+    pattern ELEMENT_FACTORY_KLASS_MEDIA_METADATA,+    pattern ELEMENT_FACTORY_KLASS_MEDIA_IMAGE,+    pattern ELEMENT_FACTORY_KLASS_MEDIA_AUDIO,+    pattern ELEMENT_FACTORY_KLASS_FORMATTER ,+    pattern ELEMENT_FACTORY_KLASS_ENCRYPTOR ,+    pattern ELEMENT_FACTORY_KLASS_ENCODER   ,+    pattern ELEMENT_FACTORY_KLASS_DEPAYLOADER,+    pattern ELEMENT_FACTORY_KLASS_DEMUXER   ,+    pattern ELEMENT_FACTORY_KLASS_DECRYPTOR ,+    pattern ELEMENT_FACTORY_KLASS_DECODER   ,+    pattern DEBUG_FORMAT_MASK               ,+    pattern DEBUG_FG_MASK                   ,+    pattern DEBUG_BG_MASK                   ,+    pattern CLOCK_TIME_NONE                 ,+    pattern CAPS_FEATURE_MEMORY_SYSTEM_MEMORY,+    pattern CAN_INLINE                      ,+    pattern BUFFER_OFFSET_NONE              ,+    pattern BUFFER_COPY_METADATA            ,+    pattern BUFFER_COPY_ALL                 ,+    pattern ALLOCATOR_SYSMEM                ,++    ) 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 GI.Gst.Callbacks+++pattern VERSION_NANO = 0 :: Int32+++pattern VERSION_MINOR = 6 :: Int32+++pattern VERSION_MICRO = 3 :: Int32+++pattern VERSION_MAJOR = 1 :: Int32+++pattern VALUE_UNORDERED = 2 :: Int32+++pattern VALUE_LESS_THAN = -1 :: Int32+++pattern VALUE_GREATER_THAN = 1 :: Int32+++pattern VALUE_EQUAL = 0 :: Int32+++pattern USECOND = 1000 :: Int32+++pattern URI_NO_PORT = 0 :: Int32+++pattern TOC_REPEAT_COUNT_INFINITE = -1 :: Int32+++pattern TIME_FORMAT = "u:%02u:%02u.%09u" :: T.Text+++pattern TAG_VIDEO_CODEC = "video-codec" :: T.Text+++pattern TAG_VERSION = "version" :: T.Text+++pattern TAG_USER_RATING = "user-rating" :: T.Text+++pattern TAG_TRACK_PEAK = "replaygain-track-peak" :: T.Text+++pattern TAG_TRACK_NUMBER = "track-number" :: T.Text+++pattern TAG_TRACK_GAIN = "replaygain-track-gain" :: T.Text+++pattern TAG_TRACK_COUNT = "track-count" :: T.Text+++pattern TAG_TITLE_SORTNAME = "title-sortname" :: T.Text+++pattern TAG_TITLE = "title" :: T.Text+++pattern TAG_SUBTITLE_CODEC = "subtitle-codec" :: T.Text+++pattern TAG_SHOW_SORTNAME = "show-sortname" :: T.Text+++pattern TAG_SHOW_SEASON_NUMBER = "show-season-number" :: T.Text+++pattern TAG_SHOW_NAME = "show-name" :: T.Text+++pattern TAG_SHOW_EPISODE_NUMBER = "show-episode-number" :: T.Text+++pattern TAG_SERIAL = "serial" :: T.Text+++pattern TAG_REFERENCE_LEVEL = "replaygain-reference-level" :: T.Text+++pattern TAG_PUBLISHER = "publisher" :: T.Text+++pattern TAG_PREVIEW_IMAGE = "preview-image" :: T.Text+++pattern TAG_PERFORMER = "performer" :: T.Text+++pattern TAG_ORGANIZATION = "organization" :: T.Text+++pattern TAG_NOMINAL_BITRATE = "nominal-bitrate" :: T.Text+++pattern TAG_MINIMUM_BITRATE = "minimum-bitrate" :: T.Text+++pattern TAG_MIDI_BASE_NOTE = "midi-base-note" :: T.Text+++pattern TAG_MAXIMUM_BITRATE = "maximum-bitrate" :: T.Text+++pattern TAG_LYRICS = "lyrics" :: T.Text+++pattern TAG_LOCATION = "location" :: T.Text+++pattern TAG_LICENSE_URI = "license-uri" :: T.Text+++pattern TAG_LICENSE = "license" :: T.Text+++pattern TAG_LANGUAGE_NAME = "language-name" :: T.Text+++pattern TAG_LANGUAGE_CODE = "language-code" :: T.Text+++pattern TAG_KEYWORDS = "keywords" :: T.Text+++pattern TAG_ISRC = "isrc" :: T.Text+++pattern TAG_INTERPRETED_BY = "interpreted-by" :: T.Text+++pattern TAG_IMAGE_ORIENTATION = "image-orientation" :: T.Text+++pattern TAG_IMAGE = "image" :: T.Text+++pattern TAG_HOMEPAGE = "homepage" :: T.Text+++pattern TAG_GROUPING = "grouping" :: T.Text+++pattern TAG_GEO_LOCATION_SUBLOCATION = "geo-location-sublocation" :: T.Text+++pattern TAG_GEO_LOCATION_NAME = "geo-location-name" :: T.Text+++pattern TAG_GEO_LOCATION_MOVEMENT_SPEED = "geo-location-movement-speed" :: T.Text+++pattern TAG_GEO_LOCATION_MOVEMENT_DIRECTION = "geo-location-movement-direction" :: T.Text+++pattern TAG_GEO_LOCATION_LONGITUDE = "geo-location-longitude" :: T.Text+++pattern TAG_GEO_LOCATION_LATITUDE = "geo-location-latitude" :: T.Text+++pattern TAG_GEO_LOCATION_HORIZONTAL_ERROR = "geo-location-horizontal-error" :: T.Text+++pattern TAG_GEO_LOCATION_ELEVATION = "geo-location-elevation" :: T.Text+++pattern TAG_GEO_LOCATION_COUNTRY = "geo-location-country" :: T.Text+++pattern TAG_GEO_LOCATION_CITY = "geo-location-city" :: T.Text+++pattern TAG_GEO_LOCATION_CAPTURE_DIRECTION = "geo-location-capture-direction" :: T.Text+++pattern TAG_GENRE = "genre" :: T.Text+++pattern TAG_EXTENDED_COMMENT = "extended-comment" :: T.Text+++pattern TAG_ENCODER_VERSION = "encoder-version" :: T.Text+++pattern TAG_ENCODER = "encoder" :: T.Text+++pattern TAG_ENCODED_BY = "encoded-by" :: T.Text+++pattern TAG_DURATION = "duration" :: T.Text+++pattern TAG_DEVICE_MODEL = "device-model" :: T.Text+++pattern TAG_DEVICE_MANUFACTURER = "device-manufacturer" :: T.Text+++pattern TAG_DESCRIPTION = "description" :: T.Text+++pattern TAG_DATE_TIME = "datetime" :: T.Text+++pattern TAG_DATE = "date" :: T.Text+++pattern TAG_COPYRIGHT_URI = "copyright-uri" :: T.Text+++pattern TAG_COPYRIGHT = "copyright" :: T.Text+++pattern TAG_CONTAINER_FORMAT = "container-format" :: T.Text+++pattern TAG_CONTACT = "contact" :: T.Text+++pattern TAG_COMPOSER_SORTNAME = "composer-sortname" :: T.Text+++pattern TAG_COMPOSER = "composer" :: T.Text+++pattern TAG_COMMENT = "comment" :: T.Text+++pattern TAG_CODEC = "codec" :: T.Text+++pattern TAG_BITRATE = "bitrate" :: T.Text+++pattern TAG_BEATS_PER_MINUTE = "beats-per-minute" :: T.Text+++pattern TAG_AUDIO_CODEC = "audio-codec" :: T.Text+++pattern TAG_ATTACHMENT = "attachment" :: T.Text+++pattern TAG_ARTIST_SORTNAME = "artist-sortname" :: T.Text+++pattern TAG_ARTIST = "artist" :: T.Text+++pattern TAG_APPLICATION_NAME = "application-name" :: T.Text+++pattern TAG_APPLICATION_DATA = "application-data" :: T.Text+++pattern TAG_ALBUM_VOLUME_NUMBER = "album-disc-number" :: T.Text+++pattern TAG_ALBUM_VOLUME_COUNT = "album-disc-count" :: T.Text+++pattern TAG_ALBUM_SORTNAME = "album-sortname" :: T.Text+++pattern TAG_ALBUM_PEAK = "replaygain-album-peak" :: T.Text+++pattern TAG_ALBUM_GAIN = "replaygain-album-gain" :: T.Text+++pattern TAG_ALBUM_ARTIST_SORTNAME = "album-artist-sortname" :: T.Text+++pattern TAG_ALBUM_ARTIST = "album-artist" :: T.Text+++pattern TAG_ALBUM = "album" :: T.Text+++pattern STIME_FORMAT = "c%" :: T.Text+++pattern SEGMENT_FORMAT = "paB" :: T.Text+++pattern SECOND = 1000000000 :: Int32+++pattern QUERY_TYPE_BOTH = 0 :: Int32+++pattern QUERY_NUM_SHIFT = 8 :: Int32+++pattern PTR_FORMAT = "paA" :: T.Text+++pattern PROTECTION_SYSTEM_ID_CAPS_FIELD = "protection-system" :: T.Text+++pattern PARAM_USER_SHIFT = 256 :: Int32+++pattern PARAM_MUTABLE_READY = 4 :: Int32+++pattern PARAM_MUTABLE_PLAYING = 16 :: Int32+++pattern PARAM_MUTABLE_PAUSED = 8 :: Int32+++pattern PARAM_CONTROLLABLE = 2 :: Int32+++pattern NSECOND = 1 :: Int32+++pattern MSECOND = 1000000 :: Int32+++pattern META_TAG_MEMORY_STR = "memory" :: T.Text+++pattern MAP_READWRITE = 0 :: Int32+++pattern LOCK_FLAG_READWRITE = 0 :: Int32+++pattern LICENSE_UNKNOWN = "unknown" :: T.Text+++pattern FOURCC_FORMAT = "c%c%c%c" :: T.Text+++pattern FORMAT_PERCENT_SCALE = 10000 :: Int64+++pattern FORMAT_PERCENT_MAX = 1000000 :: Int64+++pattern FLAG_SET_MASK_EXACT = -1 :: Word32+++pattern EVENT_TYPE_BOTH = 0 :: Int32+++pattern EVENT_NUM_SHIFT = 8 :: Int32+++pattern ERROR_SYSTEM = "system error: %s" :: T.Text+++pattern ELEMENT_METADATA_LONGNAME = "long-name" :: T.Text+++pattern ELEMENT_METADATA_KLASS = "klass" :: T.Text+++pattern ELEMENT_METADATA_ICON_NAME = "icon-name" :: T.Text+++pattern ELEMENT_METADATA_DOC_URI = "doc-uri" :: T.Text+++pattern ELEMENT_METADATA_DESCRIPTION = "description" :: T.Text+++pattern ELEMENT_METADATA_AUTHOR = "author" :: T.Text+++pattern ELEMENT_FACTORY_TYPE_VIDEO_ENCODER = 2814749767106562 :: Int32+++pattern ELEMENT_FACTORY_TYPE_SRC = 8 :: Int32+++pattern ELEMENT_FACTORY_TYPE_SINK = 4 :: Int32+++pattern ELEMENT_FACTORY_TYPE_PAYLOADER = 128 :: Int32+++pattern ELEMENT_FACTORY_TYPE_PARSER = 64 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MUXER = 16 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MEDIA_VIDEO = 562949953421312 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE = 4503599627370496 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MEDIA_METADATA = 9007199254740992 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MEDIA_IMAGE = 2251799813685248 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MEDIA_AUDIO = 1125899906842624 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MEDIA_ANY = 18446462598732840960 :: Int32+++pattern ELEMENT_FACTORY_TYPE_MAX_ELEMENTS = 281474976710656 :: Int32+++pattern ELEMENT_FACTORY_TYPE_FORMATTER = 512 :: Int32+++pattern ELEMENT_FACTORY_TYPE_ENCRYPTOR = 2048 :: Int32+++pattern ELEMENT_FACTORY_TYPE_ENCODER = 2 :: Int32+++pattern ELEMENT_FACTORY_TYPE_DEPAYLOADER = 256 :: Int32+++pattern ELEMENT_FACTORY_TYPE_DEMUXER = 32 :: Int32+++pattern ELEMENT_FACTORY_TYPE_DECRYPTOR = 1024 :: Int32+++pattern ELEMENT_FACTORY_TYPE_DECODER = 1 :: Int32+++pattern ELEMENT_FACTORY_TYPE_DECODABLE = 353 :: Int32+++pattern ELEMENT_FACTORY_TYPE_AUDIO_ENCODER = 1125899906842626 :: Int32+++pattern ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS = 3940649673949188 :: Int32+++pattern ELEMENT_FACTORY_TYPE_ANY = 562949953421311 :: Int32+++pattern ELEMENT_FACTORY_KLASS_SRC = "Source" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_SINK = "Sink" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_PAYLOADER = "Payloader" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_PARSER = "Parser" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_MUXER = "Muxer" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_MEDIA_VIDEO = "Video" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE = "Subtitle" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_MEDIA_METADATA = "Metadata" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_MEDIA_IMAGE = "Image" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_MEDIA_AUDIO = "Audio" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_FORMATTER = "Formatter" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_ENCRYPTOR = "Encryptor" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_ENCODER = "Encoder" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_DEPAYLOADER = "Depayloader" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_DEMUXER = "Demuxer" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_DECRYPTOR = "Decryptor" :: T.Text+++pattern ELEMENT_FACTORY_KLASS_DECODER = "Decoder" :: T.Text+++pattern DEBUG_FORMAT_MASK = 65280 :: Int32+++pattern DEBUG_FG_MASK = 15 :: Int32+++pattern DEBUG_BG_MASK = 240 :: Int32+++pattern CLOCK_TIME_NONE = 18446744073709551615 :: Word64+++pattern CAPS_FEATURE_MEMORY_SYSTEM_MEMORY = "memory:SystemMemory" :: T.Text+++pattern CAN_INLINE = 1 :: Int32+++pattern BUFFER_OFFSET_NONE = 18446744073709551615 :: Word64+++pattern BUFFER_COPY_METADATA = 0 :: Int32+++pattern BUFFER_COPY_ALL <- (gflagsToWord -> (0 :: Word64)) :: [BufferCopyFlags] where+    BUFFER_COPY_ALL = wordToGFlags (0 :: Word64) :: [BufferCopyFlags]+++pattern ALLOCATOR_SYSMEM = "SystemMemory" :: T.Text++
+ GI/Gst/Enums.hs view
@@ -0,0 +1,1855 @@+++{- |+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.Enums+    ( +    catchURIError                           ,+    handleURIError                          ,+    catchStreamError                        ,+    handleStreamError                       ,+    catchResourceError                      ,+    handleResourceError                     ,+    catchPluginError                        ,+    handlePluginError                       ,+    catchParseError                         ,+    handleParseError                        ,+    catchLibraryError                       ,+    handleLibraryError                      ,+    catchCoreError                          ,+    handleCoreError                         ,++-- * Exported types+    URIType(..)                             ,+    URIError(..)                            ,+    TypeFindProbability(..)                 ,+    TocScope(..)                            ,+    TocLoopType(..)                         ,+    TocEntryType(..)                        ,+    TaskState(..)                           ,+    TagScope(..)                            ,+    TagMergeMode(..)                        ,+    TagFlag(..)                             ,+    StructureChangeType(..)                 ,+    StreamStatusType(..)                    ,+    StreamError(..)                         ,+    StateChangeReturn(..)                   ,+    StateChange(..)                         ,+    State(..)                               ,+    SeekType(..)                            ,+    SearchMode(..)                          ,+    ResourceError(..)                       ,+    Rank(..)                                ,+    QueryType(..)                           ,+    QOSType(..)                             ,+    ProgressType(..)                        ,+    PluginError(..)                         ,+    ParseError(..)                          ,+    PadProbeReturn(..)                      ,+    PadPresence(..)                         ,+    PadMode(..)                             ,+    PadLinkReturn(..)                       ,+    PadDirection(..)                        ,+    LibraryError(..)                        ,+    IteratorResult(..)                      ,+    IteratorItem(..)                        ,+    Format(..)                              ,+    FlowReturn(..)                          ,+    EventType(..)                           ,+    DebugLevel(..)                          ,+    DebugColorMode(..)                      ,+    DebugColorFlags(..)                     ,+    CoreError(..)                           ,+    ClockType(..)                           ,+    ClockReturn(..)                         ,+    ClockEntryType(..)                      ,+    CapsIntersectMode(..)                   ,+    BusSyncReply(..)                        ,+    BufferingMode(..)                       ,+++    ) 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+++++-- Enum URIType++data URIType = +      URITypeUnknown+    | URITypeSink+    | URITypeSrc+    | AnotherURIType Int+    deriving (Show, Eq)++instance Enum URIType where+    fromEnum URITypeUnknown = 0+    fromEnum URITypeSink = 1+    fromEnum URITypeSrc = 2+    fromEnum (AnotherURIType k) = k++    toEnum 0 = URITypeUnknown+    toEnum 1 = URITypeSink+    toEnum 2 = URITypeSrc+    toEnum k = AnotherURIType k++foreign import ccall "gst_uri_type_get_type" c_gst_uri_type_get_type :: +    IO GType++instance BoxedEnum URIType where+    boxedEnumType _ = c_gst_uri_type_get_type++-- Enum URIError++data URIError = +      URIErrorUnsupportedProtocol+    | URIErrorBadUri+    | URIErrorBadState+    | URIErrorBadReference+    | AnotherURIError Int+    deriving (Show, Eq)++instance Enum URIError where+    fromEnum URIErrorUnsupportedProtocol = 0+    fromEnum URIErrorBadUri = 1+    fromEnum URIErrorBadState = 2+    fromEnum URIErrorBadReference = 3+    fromEnum (AnotherURIError k) = k++    toEnum 0 = URIErrorUnsupportedProtocol+    toEnum 1 = URIErrorBadUri+    toEnum 2 = URIErrorBadState+    toEnum 3 = URIErrorBadReference+    toEnum k = AnotherURIError k++instance GErrorClass URIError where+    gerrorClassDomain _ = "gst-uri-error-quark"++catchURIError ::+    IO a ->+    (URIError -> GErrorMessage -> IO a) ->+    IO a+catchURIError = catchGErrorJustDomain++handleURIError ::+    (URIError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleURIError = handleGErrorJustDomain++foreign import ccall "gst_uri_error_get_type" c_gst_uri_error_get_type :: +    IO GType++instance BoxedEnum URIError where+    boxedEnumType _ = c_gst_uri_error_get_type++-- Enum TypeFindProbability++data TypeFindProbability = +      TypeFindProbabilityNone+    | TypeFindProbabilityMinimum+    | TypeFindProbabilityPossible+    | TypeFindProbabilityLikely+    | TypeFindProbabilityNearlyCertain+    | TypeFindProbabilityMaximum+    | AnotherTypeFindProbability Int+    deriving (Show, Eq)++instance Enum TypeFindProbability where+    fromEnum TypeFindProbabilityNone = 0+    fromEnum TypeFindProbabilityMinimum = 1+    fromEnum TypeFindProbabilityPossible = 50+    fromEnum TypeFindProbabilityLikely = 80+    fromEnum TypeFindProbabilityNearlyCertain = 99+    fromEnum TypeFindProbabilityMaximum = 100+    fromEnum (AnotherTypeFindProbability k) = k++    toEnum 0 = TypeFindProbabilityNone+    toEnum 1 = TypeFindProbabilityMinimum+    toEnum 50 = TypeFindProbabilityPossible+    toEnum 80 = TypeFindProbabilityLikely+    toEnum 99 = TypeFindProbabilityNearlyCertain+    toEnum 100 = TypeFindProbabilityMaximum+    toEnum k = AnotherTypeFindProbability k++foreign import ccall "gst_type_find_probability_get_type" c_gst_type_find_probability_get_type :: +    IO GType++instance BoxedEnum TypeFindProbability where+    boxedEnumType _ = c_gst_type_find_probability_get_type++-- Enum TocScope++data TocScope = +      TocScopeGlobal+    | TocScopeCurrent+    | AnotherTocScope Int+    deriving (Show, Eq)++instance Enum TocScope where+    fromEnum TocScopeGlobal = 1+    fromEnum TocScopeCurrent = 2+    fromEnum (AnotherTocScope k) = k++    toEnum 1 = TocScopeGlobal+    toEnum 2 = TocScopeCurrent+    toEnum k = AnotherTocScope k++foreign import ccall "gst_toc_scope_get_type" c_gst_toc_scope_get_type :: +    IO GType++instance BoxedEnum TocScope where+    boxedEnumType _ = c_gst_toc_scope_get_type++-- Enum TocLoopType++data TocLoopType = +      TocLoopTypeNone+    | TocLoopTypeForward+    | TocLoopTypeReverse+    | TocLoopTypePingPong+    | AnotherTocLoopType Int+    deriving (Show, Eq)++instance Enum TocLoopType where+    fromEnum TocLoopTypeNone = 0+    fromEnum TocLoopTypeForward = 1+    fromEnum TocLoopTypeReverse = 2+    fromEnum TocLoopTypePingPong = 3+    fromEnum (AnotherTocLoopType k) = k++    toEnum 0 = TocLoopTypeNone+    toEnum 1 = TocLoopTypeForward+    toEnum 2 = TocLoopTypeReverse+    toEnum 3 = TocLoopTypePingPong+    toEnum k = AnotherTocLoopType k++foreign import ccall "gst_toc_loop_type_get_type" c_gst_toc_loop_type_get_type :: +    IO GType++instance BoxedEnum TocLoopType where+    boxedEnumType _ = c_gst_toc_loop_type_get_type++-- Enum TocEntryType++data TocEntryType = +      TocEntryTypeAngle+    | TocEntryTypeVersion+    | TocEntryTypeEdition+    | TocEntryTypeInvalid+    | TocEntryTypeTitle+    | TocEntryTypeTrack+    | TocEntryTypeChapter+    | AnotherTocEntryType Int+    deriving (Show, Eq)++instance Enum TocEntryType where+    fromEnum TocEntryTypeAngle = -3+    fromEnum TocEntryTypeVersion = -2+    fromEnum TocEntryTypeEdition = -1+    fromEnum TocEntryTypeInvalid = 0+    fromEnum TocEntryTypeTitle = 1+    fromEnum TocEntryTypeTrack = 2+    fromEnum TocEntryTypeChapter = 3+    fromEnum (AnotherTocEntryType k) = k++    toEnum -3 = TocEntryTypeAngle+    toEnum -2 = TocEntryTypeVersion+    toEnum -1 = TocEntryTypeEdition+    toEnum 0 = TocEntryTypeInvalid+    toEnum 1 = TocEntryTypeTitle+    toEnum 2 = TocEntryTypeTrack+    toEnum 3 = TocEntryTypeChapter+    toEnum k = AnotherTocEntryType k++foreign import ccall "gst_toc_entry_type_get_type" c_gst_toc_entry_type_get_type :: +    IO GType++instance BoxedEnum TocEntryType where+    boxedEnumType _ = c_gst_toc_entry_type_get_type++-- Enum TaskState++data TaskState = +      TaskStateStarted+    | TaskStateStopped+    | TaskStatePaused+    | AnotherTaskState Int+    deriving (Show, Eq)++instance Enum TaskState where+    fromEnum TaskStateStarted = 0+    fromEnum TaskStateStopped = 1+    fromEnum TaskStatePaused = 2+    fromEnum (AnotherTaskState k) = k++    toEnum 0 = TaskStateStarted+    toEnum 1 = TaskStateStopped+    toEnum 2 = TaskStatePaused+    toEnum k = AnotherTaskState k++foreign import ccall "gst_task_state_get_type" c_gst_task_state_get_type :: +    IO GType++instance BoxedEnum TaskState where+    boxedEnumType _ = c_gst_task_state_get_type++-- Enum TagScope++data TagScope = +      TagScopeStream+    | TagScopeGlobal+    | AnotherTagScope Int+    deriving (Show, Eq)++instance Enum TagScope where+    fromEnum TagScopeStream = 0+    fromEnum TagScopeGlobal = 1+    fromEnum (AnotherTagScope k) = k++    toEnum 0 = TagScopeStream+    toEnum 1 = TagScopeGlobal+    toEnum k = AnotherTagScope k++foreign import ccall "gst_tag_scope_get_type" c_gst_tag_scope_get_type :: +    IO GType++instance BoxedEnum TagScope where+    boxedEnumType _ = c_gst_tag_scope_get_type++-- Enum TagMergeMode++data TagMergeMode = +      TagMergeModeUndefined+    | TagMergeModeReplaceAll+    | TagMergeModeReplace+    | TagMergeModeAppend+    | TagMergeModePrepend+    | TagMergeModeKeep+    | TagMergeModeKeepAll+    | TagMergeModeCount+    | AnotherTagMergeMode Int+    deriving (Show, Eq)++instance Enum TagMergeMode where+    fromEnum TagMergeModeUndefined = 0+    fromEnum TagMergeModeReplaceAll = 1+    fromEnum TagMergeModeReplace = 2+    fromEnum TagMergeModeAppend = 3+    fromEnum TagMergeModePrepend = 4+    fromEnum TagMergeModeKeep = 5+    fromEnum TagMergeModeKeepAll = 6+    fromEnum TagMergeModeCount = 7+    fromEnum (AnotherTagMergeMode k) = k++    toEnum 0 = TagMergeModeUndefined+    toEnum 1 = TagMergeModeReplaceAll+    toEnum 2 = TagMergeModeReplace+    toEnum 3 = TagMergeModeAppend+    toEnum 4 = TagMergeModePrepend+    toEnum 5 = TagMergeModeKeep+    toEnum 6 = TagMergeModeKeepAll+    toEnum 7 = TagMergeModeCount+    toEnum k = AnotherTagMergeMode k++foreign import ccall "gst_tag_merge_mode_get_type" c_gst_tag_merge_mode_get_type :: +    IO GType++instance BoxedEnum TagMergeMode where+    boxedEnumType _ = c_gst_tag_merge_mode_get_type++-- Enum TagFlag++data TagFlag = +      TagFlagUndefined+    | TagFlagMeta+    | TagFlagEncoded+    | TagFlagDecoded+    | TagFlagCount+    | AnotherTagFlag Int+    deriving (Show, Eq)++instance Enum TagFlag where+    fromEnum TagFlagUndefined = 0+    fromEnum TagFlagMeta = 1+    fromEnum TagFlagEncoded = 2+    fromEnum TagFlagDecoded = 3+    fromEnum TagFlagCount = 4+    fromEnum (AnotherTagFlag k) = k++    toEnum 0 = TagFlagUndefined+    toEnum 1 = TagFlagMeta+    toEnum 2 = TagFlagEncoded+    toEnum 3 = TagFlagDecoded+    toEnum 4 = TagFlagCount+    toEnum k = AnotherTagFlag k++foreign import ccall "gst_tag_flag_get_type" c_gst_tag_flag_get_type :: +    IO GType++instance BoxedEnum TagFlag where+    boxedEnumType _ = c_gst_tag_flag_get_type++-- Enum StructureChangeType++data StructureChangeType = +      StructureChangeTypeLink+    | StructureChangeTypeUnlink+    | AnotherStructureChangeType Int+    deriving (Show, Eq)++instance Enum StructureChangeType where+    fromEnum StructureChangeTypeLink = 0+    fromEnum StructureChangeTypeUnlink = 1+    fromEnum (AnotherStructureChangeType k) = k++    toEnum 0 = StructureChangeTypeLink+    toEnum 1 = StructureChangeTypeUnlink+    toEnum k = AnotherStructureChangeType k++foreign import ccall "gst_structure_change_type_get_type" c_gst_structure_change_type_get_type :: +    IO GType++instance BoxedEnum StructureChangeType where+    boxedEnumType _ = c_gst_structure_change_type_get_type++-- Enum StreamStatusType++data StreamStatusType = +      StreamStatusTypeCreate+    | StreamStatusTypeEnter+    | StreamStatusTypeLeave+    | StreamStatusTypeDestroy+    | StreamStatusTypeStart+    | StreamStatusTypePause+    | StreamStatusTypeStop+    | AnotherStreamStatusType Int+    deriving (Show, Eq)++instance Enum StreamStatusType where+    fromEnum StreamStatusTypeCreate = 0+    fromEnum StreamStatusTypeEnter = 1+    fromEnum StreamStatusTypeLeave = 2+    fromEnum StreamStatusTypeDestroy = 3+    fromEnum StreamStatusTypeStart = 8+    fromEnum StreamStatusTypePause = 9+    fromEnum StreamStatusTypeStop = 10+    fromEnum (AnotherStreamStatusType k) = k++    toEnum 0 = StreamStatusTypeCreate+    toEnum 1 = StreamStatusTypeEnter+    toEnum 2 = StreamStatusTypeLeave+    toEnum 3 = StreamStatusTypeDestroy+    toEnum 8 = StreamStatusTypeStart+    toEnum 9 = StreamStatusTypePause+    toEnum 10 = StreamStatusTypeStop+    toEnum k = AnotherStreamStatusType k++foreign import ccall "gst_stream_status_type_get_type" c_gst_stream_status_type_get_type :: +    IO GType++instance BoxedEnum StreamStatusType where+    boxedEnumType _ = c_gst_stream_status_type_get_type++-- Enum StreamError++data StreamError = +      StreamErrorFailed+    | StreamErrorTooLazy+    | StreamErrorNotImplemented+    | StreamErrorTypeNotFound+    | StreamErrorWrongType+    | StreamErrorCodecNotFound+    | StreamErrorDecode+    | StreamErrorEncode+    | StreamErrorDemux+    | StreamErrorMux+    | StreamErrorFormat+    | StreamErrorDecrypt+    | StreamErrorDecryptNokey+    | StreamErrorNumErrors+    | AnotherStreamError Int+    deriving (Show, Eq)++instance Enum StreamError where+    fromEnum StreamErrorFailed = 1+    fromEnum StreamErrorTooLazy = 2+    fromEnum StreamErrorNotImplemented = 3+    fromEnum StreamErrorTypeNotFound = 4+    fromEnum StreamErrorWrongType = 5+    fromEnum StreamErrorCodecNotFound = 6+    fromEnum StreamErrorDecode = 7+    fromEnum StreamErrorEncode = 8+    fromEnum StreamErrorDemux = 9+    fromEnum StreamErrorMux = 10+    fromEnum StreamErrorFormat = 11+    fromEnum StreamErrorDecrypt = 12+    fromEnum StreamErrorDecryptNokey = 13+    fromEnum StreamErrorNumErrors = 14+    fromEnum (AnotherStreamError k) = k++    toEnum 1 = StreamErrorFailed+    toEnum 2 = StreamErrorTooLazy+    toEnum 3 = StreamErrorNotImplemented+    toEnum 4 = StreamErrorTypeNotFound+    toEnum 5 = StreamErrorWrongType+    toEnum 6 = StreamErrorCodecNotFound+    toEnum 7 = StreamErrorDecode+    toEnum 8 = StreamErrorEncode+    toEnum 9 = StreamErrorDemux+    toEnum 10 = StreamErrorMux+    toEnum 11 = StreamErrorFormat+    toEnum 12 = StreamErrorDecrypt+    toEnum 13 = StreamErrorDecryptNokey+    toEnum 14 = StreamErrorNumErrors+    toEnum k = AnotherStreamError k++instance GErrorClass StreamError where+    gerrorClassDomain _ = "gst-stream-error-quark"++catchStreamError ::+    IO a ->+    (StreamError -> GErrorMessage -> IO a) ->+    IO a+catchStreamError = catchGErrorJustDomain++handleStreamError ::+    (StreamError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleStreamError = handleGErrorJustDomain++foreign import ccall "gst_stream_error_get_type" c_gst_stream_error_get_type :: +    IO GType++instance BoxedEnum StreamError where+    boxedEnumType _ = c_gst_stream_error_get_type++-- Enum StateChangeReturn++data StateChangeReturn = +      StateChangeReturnFailure+    | StateChangeReturnSuccess+    | StateChangeReturnAsync+    | StateChangeReturnNoPreroll+    | AnotherStateChangeReturn Int+    deriving (Show, Eq)++instance Enum StateChangeReturn where+    fromEnum StateChangeReturnFailure = 0+    fromEnum StateChangeReturnSuccess = 1+    fromEnum StateChangeReturnAsync = 2+    fromEnum StateChangeReturnNoPreroll = 3+    fromEnum (AnotherStateChangeReturn k) = k++    toEnum 0 = StateChangeReturnFailure+    toEnum 1 = StateChangeReturnSuccess+    toEnum 2 = StateChangeReturnAsync+    toEnum 3 = StateChangeReturnNoPreroll+    toEnum k = AnotherStateChangeReturn k++foreign import ccall "gst_state_change_return_get_type" c_gst_state_change_return_get_type :: +    IO GType++instance BoxedEnum StateChangeReturn where+    boxedEnumType _ = c_gst_state_change_return_get_type++-- Enum StateChange++data StateChange = +      StateChangeNullToReady+    | StateChangeReadyToPaused+    | StateChangePausedToPlaying+    | StateChangePlayingToPaused+    | StateChangePausedToReady+    | StateChangeReadyToNull+    | AnotherStateChange Int+    deriving (Show, Eq)++instance Enum StateChange where+    fromEnum StateChangeNullToReady = 10+    fromEnum StateChangeReadyToPaused = 19+    fromEnum StateChangePausedToPlaying = 28+    fromEnum StateChangePlayingToPaused = 35+    fromEnum StateChangePausedToReady = 26+    fromEnum StateChangeReadyToNull = 17+    fromEnum (AnotherStateChange k) = k++    toEnum 10 = StateChangeNullToReady+    toEnum 17 = StateChangeReadyToNull+    toEnum 19 = StateChangeReadyToPaused+    toEnum 26 = StateChangePausedToReady+    toEnum 28 = StateChangePausedToPlaying+    toEnum 35 = StateChangePlayingToPaused+    toEnum k = AnotherStateChange k++foreign import ccall "gst_state_change_get_type" c_gst_state_change_get_type :: +    IO GType++instance BoxedEnum StateChange where+    boxedEnumType _ = c_gst_state_change_get_type++-- Enum State++data State = +      StateVoidPending+    | StateNull+    | StateReady+    | StatePaused+    | StatePlaying+    | AnotherState Int+    deriving (Show, Eq)++instance Enum State where+    fromEnum StateVoidPending = 0+    fromEnum StateNull = 1+    fromEnum StateReady = 2+    fromEnum StatePaused = 3+    fromEnum StatePlaying = 4+    fromEnum (AnotherState k) = k++    toEnum 0 = StateVoidPending+    toEnum 1 = StateNull+    toEnum 2 = StateReady+    toEnum 3 = StatePaused+    toEnum 4 = StatePlaying+    toEnum k = AnotherState k++foreign import ccall "gst_state_get_type" c_gst_state_get_type :: +    IO GType++instance BoxedEnum State where+    boxedEnumType _ = c_gst_state_get_type++-- Enum SeekType++data SeekType = +      SeekTypeNone+    | SeekTypeSet+    | SeekTypeEnd+    | AnotherSeekType Int+    deriving (Show, Eq)++instance Enum SeekType where+    fromEnum SeekTypeNone = 0+    fromEnum SeekTypeSet = 1+    fromEnum SeekTypeEnd = 2+    fromEnum (AnotherSeekType k) = k++    toEnum 0 = SeekTypeNone+    toEnum 1 = SeekTypeSet+    toEnum 2 = SeekTypeEnd+    toEnum k = AnotherSeekType k++foreign import ccall "gst_seek_type_get_type" c_gst_seek_type_get_type :: +    IO GType++instance BoxedEnum SeekType where+    boxedEnumType _ = c_gst_seek_type_get_type++-- Enum SearchMode++data SearchMode = +      SearchModeExact+    | SearchModeBefore+    | SearchModeAfter+    | AnotherSearchMode Int+    deriving (Show, Eq)++instance Enum SearchMode where+    fromEnum SearchModeExact = 0+    fromEnum SearchModeBefore = 1+    fromEnum SearchModeAfter = 2+    fromEnum (AnotherSearchMode k) = k++    toEnum 0 = SearchModeExact+    toEnum 1 = SearchModeBefore+    toEnum 2 = SearchModeAfter+    toEnum k = AnotherSearchMode k++foreign import ccall "gst_search_mode_get_type" c_gst_search_mode_get_type :: +    IO GType++instance BoxedEnum SearchMode where+    boxedEnumType _ = c_gst_search_mode_get_type++-- Enum ResourceError++data ResourceError = +      ResourceErrorFailed+    | ResourceErrorTooLazy+    | ResourceErrorNotFound+    | ResourceErrorBusy+    | ResourceErrorOpenRead+    | ResourceErrorOpenWrite+    | ResourceErrorOpenReadWrite+    | ResourceErrorClose+    | ResourceErrorRead+    | ResourceErrorWrite+    | ResourceErrorSeek+    | ResourceErrorSync+    | ResourceErrorSettings+    | ResourceErrorNoSpaceLeft+    | ResourceErrorNotAuthorized+    | ResourceErrorNumErrors+    | AnotherResourceError Int+    deriving (Show, Eq)++instance Enum ResourceError where+    fromEnum ResourceErrorFailed = 1+    fromEnum ResourceErrorTooLazy = 2+    fromEnum ResourceErrorNotFound = 3+    fromEnum ResourceErrorBusy = 4+    fromEnum ResourceErrorOpenRead = 5+    fromEnum ResourceErrorOpenWrite = 6+    fromEnum ResourceErrorOpenReadWrite = 7+    fromEnum ResourceErrorClose = 8+    fromEnum ResourceErrorRead = 9+    fromEnum ResourceErrorWrite = 10+    fromEnum ResourceErrorSeek = 11+    fromEnum ResourceErrorSync = 12+    fromEnum ResourceErrorSettings = 13+    fromEnum ResourceErrorNoSpaceLeft = 14+    fromEnum ResourceErrorNotAuthorized = 15+    fromEnum ResourceErrorNumErrors = 16+    fromEnum (AnotherResourceError k) = k++    toEnum 1 = ResourceErrorFailed+    toEnum 2 = ResourceErrorTooLazy+    toEnum 3 = ResourceErrorNotFound+    toEnum 4 = ResourceErrorBusy+    toEnum 5 = ResourceErrorOpenRead+    toEnum 6 = ResourceErrorOpenWrite+    toEnum 7 = ResourceErrorOpenReadWrite+    toEnum 8 = ResourceErrorClose+    toEnum 9 = ResourceErrorRead+    toEnum 10 = ResourceErrorWrite+    toEnum 11 = ResourceErrorSeek+    toEnum 12 = ResourceErrorSync+    toEnum 13 = ResourceErrorSettings+    toEnum 14 = ResourceErrorNoSpaceLeft+    toEnum 15 = ResourceErrorNotAuthorized+    toEnum 16 = ResourceErrorNumErrors+    toEnum k = AnotherResourceError k++instance GErrorClass ResourceError where+    gerrorClassDomain _ = "gst-resource-error-quark"++catchResourceError ::+    IO a ->+    (ResourceError -> GErrorMessage -> IO a) ->+    IO a+catchResourceError = catchGErrorJustDomain++handleResourceError ::+    (ResourceError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleResourceError = handleGErrorJustDomain++foreign import ccall "gst_resource_error_get_type" c_gst_resource_error_get_type :: +    IO GType++instance BoxedEnum ResourceError where+    boxedEnumType _ = c_gst_resource_error_get_type++-- Enum Rank++data Rank = +      RankNone+    | RankMarginal+    | RankSecondary+    | RankPrimary+    | AnotherRank Int+    deriving (Show, Eq)++instance Enum Rank where+    fromEnum RankNone = 0+    fromEnum RankMarginal = 64+    fromEnum RankSecondary = 128+    fromEnum RankPrimary = 256+    fromEnum (AnotherRank k) = k++    toEnum 0 = RankNone+    toEnum 64 = RankMarginal+    toEnum 128 = RankSecondary+    toEnum 256 = RankPrimary+    toEnum k = AnotherRank k++foreign import ccall "gst_rank_get_type" c_gst_rank_get_type :: +    IO GType++instance BoxedEnum Rank where+    boxedEnumType _ = c_gst_rank_get_type++-- Enum QueryType++data QueryType = +      QueryTypeUnknown+    | QueryTypePosition+    | QueryTypeDuration+    | QueryTypeLatency+    | QueryTypeJitter+    | QueryTypeRate+    | QueryTypeSeeking+    | QueryTypeSegment+    | QueryTypeConvert+    | QueryTypeFormats+    | QueryTypeBuffering+    | QueryTypeCustom+    | QueryTypeUri+    | QueryTypeAllocation+    | QueryTypeScheduling+    | QueryTypeAcceptCaps+    | QueryTypeCaps+    | QueryTypeDrain+    | QueryTypeContext+    | AnotherQueryType Int+    deriving (Show, Eq)++instance Enum QueryType where+    fromEnum QueryTypeUnknown = 0+    fromEnum QueryTypePosition = 2563+    fromEnum QueryTypeDuration = 5123+    fromEnum QueryTypeLatency = 7683+    fromEnum QueryTypeJitter = 10243+    fromEnum QueryTypeRate = 12803+    fromEnum QueryTypeSeeking = 15363+    fromEnum QueryTypeSegment = 17923+    fromEnum QueryTypeConvert = 20483+    fromEnum QueryTypeFormats = 23043+    fromEnum QueryTypeBuffering = 28163+    fromEnum QueryTypeCustom = 30723+    fromEnum QueryTypeUri = 33283+    fromEnum QueryTypeAllocation = 35846+    fromEnum QueryTypeScheduling = 38401+    fromEnum QueryTypeAcceptCaps = 40963+    fromEnum QueryTypeCaps = 43523+    fromEnum QueryTypeDrain = 46086+    fromEnum QueryTypeContext = 48643+    fromEnum (AnotherQueryType k) = k++    toEnum 0 = QueryTypeUnknown+    toEnum 2563 = QueryTypePosition+    toEnum 5123 = QueryTypeDuration+    toEnum 7683 = QueryTypeLatency+    toEnum 10243 = QueryTypeJitter+    toEnum 12803 = QueryTypeRate+    toEnum 15363 = QueryTypeSeeking+    toEnum 17923 = QueryTypeSegment+    toEnum 20483 = QueryTypeConvert+    toEnum 23043 = QueryTypeFormats+    toEnum 28163 = QueryTypeBuffering+    toEnum 30723 = QueryTypeCustom+    toEnum 33283 = QueryTypeUri+    toEnum 35846 = QueryTypeAllocation+    toEnum 38401 = QueryTypeScheduling+    toEnum 40963 = QueryTypeAcceptCaps+    toEnum 43523 = QueryTypeCaps+    toEnum 46086 = QueryTypeDrain+    toEnum 48643 = QueryTypeContext+    toEnum k = AnotherQueryType k++foreign import ccall "gst_query_type_get_type" c_gst_query_type_get_type :: +    IO GType++instance BoxedEnum QueryType where+    boxedEnumType _ = c_gst_query_type_get_type++-- Enum QOSType++data QOSType = +      QOSTypeOverflow+    | QOSTypeUnderflow+    | QOSTypeThrottle+    | AnotherQOSType Int+    deriving (Show, Eq)++instance Enum QOSType where+    fromEnum QOSTypeOverflow = 0+    fromEnum QOSTypeUnderflow = 1+    fromEnum QOSTypeThrottle = 2+    fromEnum (AnotherQOSType k) = k++    toEnum 0 = QOSTypeOverflow+    toEnum 1 = QOSTypeUnderflow+    toEnum 2 = QOSTypeThrottle+    toEnum k = AnotherQOSType k++foreign import ccall "gst_qos_type_get_type" c_gst_qos_type_get_type :: +    IO GType++instance BoxedEnum QOSType where+    boxedEnumType _ = c_gst_qos_type_get_type++-- Enum ProgressType++data ProgressType = +      ProgressTypeStart+    | ProgressTypeContinue+    | ProgressTypeComplete+    | ProgressTypeCanceled+    | ProgressTypeError+    | AnotherProgressType Int+    deriving (Show, Eq)++instance Enum ProgressType where+    fromEnum ProgressTypeStart = 0+    fromEnum ProgressTypeContinue = 1+    fromEnum ProgressTypeComplete = 2+    fromEnum ProgressTypeCanceled = 3+    fromEnum ProgressTypeError = 4+    fromEnum (AnotherProgressType k) = k++    toEnum 0 = ProgressTypeStart+    toEnum 1 = ProgressTypeContinue+    toEnum 2 = ProgressTypeComplete+    toEnum 3 = ProgressTypeCanceled+    toEnum 4 = ProgressTypeError+    toEnum k = AnotherProgressType k++foreign import ccall "gst_progress_type_get_type" c_gst_progress_type_get_type :: +    IO GType++instance BoxedEnum ProgressType where+    boxedEnumType _ = c_gst_progress_type_get_type++-- Enum PluginError++data PluginError = +      PluginErrorModule+    | PluginErrorDependencies+    | PluginErrorNameMismatch+    | AnotherPluginError Int+    deriving (Show, Eq)++instance Enum PluginError where+    fromEnum PluginErrorModule = 0+    fromEnum PluginErrorDependencies = 1+    fromEnum PluginErrorNameMismatch = 2+    fromEnum (AnotherPluginError k) = k++    toEnum 0 = PluginErrorModule+    toEnum 1 = PluginErrorDependencies+    toEnum 2 = PluginErrorNameMismatch+    toEnum k = AnotherPluginError k++instance GErrorClass PluginError where+    gerrorClassDomain _ = "gst_plugin_error"++catchPluginError ::+    IO a ->+    (PluginError -> GErrorMessage -> IO a) ->+    IO a+catchPluginError = catchGErrorJustDomain++handlePluginError ::+    (PluginError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handlePluginError = handleGErrorJustDomain++foreign import ccall "gst_plugin_error_get_type" c_gst_plugin_error_get_type :: +    IO GType++instance BoxedEnum PluginError where+    boxedEnumType _ = c_gst_plugin_error_get_type++-- Enum ParseError++data ParseError = +      ParseErrorSyntax+    | ParseErrorNoSuchElement+    | ParseErrorNoSuchProperty+    | ParseErrorLink+    | ParseErrorCouldNotSetProperty+    | ParseErrorEmptyBin+    | ParseErrorEmpty+    | AnotherParseError Int+    deriving (Show, Eq)++instance Enum ParseError where+    fromEnum ParseErrorSyntax = 0+    fromEnum ParseErrorNoSuchElement = 1+    fromEnum ParseErrorNoSuchProperty = 2+    fromEnum ParseErrorLink = 3+    fromEnum ParseErrorCouldNotSetProperty = 4+    fromEnum ParseErrorEmptyBin = 5+    fromEnum ParseErrorEmpty = 6+    fromEnum (AnotherParseError k) = k++    toEnum 0 = ParseErrorSyntax+    toEnum 1 = ParseErrorNoSuchElement+    toEnum 2 = ParseErrorNoSuchProperty+    toEnum 3 = ParseErrorLink+    toEnum 4 = ParseErrorCouldNotSetProperty+    toEnum 5 = ParseErrorEmptyBin+    toEnum 6 = ParseErrorEmpty+    toEnum k = AnotherParseError k++instance GErrorClass ParseError where+    gerrorClassDomain _ = "gst_parse_error"++catchParseError ::+    IO a ->+    (ParseError -> GErrorMessage -> IO a) ->+    IO a+catchParseError = catchGErrorJustDomain++handleParseError ::+    (ParseError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleParseError = handleGErrorJustDomain++foreign import ccall "gst_parse_error_get_type" c_gst_parse_error_get_type :: +    IO GType++instance BoxedEnum ParseError where+    boxedEnumType _ = c_gst_parse_error_get_type++-- Enum PadProbeReturn++data PadProbeReturn = +      PadProbeReturnDrop+    | PadProbeReturnOk+    | PadProbeReturnRemove+    | PadProbeReturnPass+    | PadProbeReturnHandled+    | AnotherPadProbeReturn Int+    deriving (Show, Eq)++instance Enum PadProbeReturn where+    fromEnum PadProbeReturnDrop = 0+    fromEnum PadProbeReturnOk = 1+    fromEnum PadProbeReturnRemove = 2+    fromEnum PadProbeReturnPass = 3+    fromEnum PadProbeReturnHandled = 4+    fromEnum (AnotherPadProbeReturn k) = k++    toEnum 0 = PadProbeReturnDrop+    toEnum 1 = PadProbeReturnOk+    toEnum 2 = PadProbeReturnRemove+    toEnum 3 = PadProbeReturnPass+    toEnum 4 = PadProbeReturnHandled+    toEnum k = AnotherPadProbeReturn k++foreign import ccall "gst_pad_probe_return_get_type" c_gst_pad_probe_return_get_type :: +    IO GType++instance BoxedEnum PadProbeReturn where+    boxedEnumType _ = c_gst_pad_probe_return_get_type++-- Enum PadPresence++data PadPresence = +      PadPresenceAlways+    | PadPresenceSometimes+    | PadPresenceRequest+    | AnotherPadPresence Int+    deriving (Show, Eq)++instance Enum PadPresence where+    fromEnum PadPresenceAlways = 0+    fromEnum PadPresenceSometimes = 1+    fromEnum PadPresenceRequest = 2+    fromEnum (AnotherPadPresence k) = k++    toEnum 0 = PadPresenceAlways+    toEnum 1 = PadPresenceSometimes+    toEnum 2 = PadPresenceRequest+    toEnum k = AnotherPadPresence k++foreign import ccall "gst_pad_presence_get_type" c_gst_pad_presence_get_type :: +    IO GType++instance BoxedEnum PadPresence where+    boxedEnumType _ = c_gst_pad_presence_get_type++-- Enum PadMode++data PadMode = +      PadModeNone+    | PadModePush+    | PadModePull+    | AnotherPadMode Int+    deriving (Show, Eq)++instance Enum PadMode where+    fromEnum PadModeNone = 0+    fromEnum PadModePush = 1+    fromEnum PadModePull = 2+    fromEnum (AnotherPadMode k) = k++    toEnum 0 = PadModeNone+    toEnum 1 = PadModePush+    toEnum 2 = PadModePull+    toEnum k = AnotherPadMode k++foreign import ccall "gst_pad_mode_get_type" c_gst_pad_mode_get_type :: +    IO GType++instance BoxedEnum PadMode where+    boxedEnumType _ = c_gst_pad_mode_get_type++-- Enum PadLinkReturn++data PadLinkReturn = +      PadLinkReturnOk+    | PadLinkReturnWrongHierarchy+    | PadLinkReturnWasLinked+    | PadLinkReturnWrongDirection+    | PadLinkReturnNoformat+    | PadLinkReturnNosched+    | PadLinkReturnRefused+    | AnotherPadLinkReturn Int+    deriving (Show, Eq)++instance Enum PadLinkReturn where+    fromEnum PadLinkReturnOk = 0+    fromEnum PadLinkReturnWrongHierarchy = -1+    fromEnum PadLinkReturnWasLinked = -2+    fromEnum PadLinkReturnWrongDirection = -3+    fromEnum PadLinkReturnNoformat = -4+    fromEnum PadLinkReturnNosched = -5+    fromEnum PadLinkReturnRefused = -6+    fromEnum (AnotherPadLinkReturn k) = k++    toEnum -6 = PadLinkReturnRefused+    toEnum -5 = PadLinkReturnNosched+    toEnum -4 = PadLinkReturnNoformat+    toEnum -3 = PadLinkReturnWrongDirection+    toEnum -2 = PadLinkReturnWasLinked+    toEnum -1 = PadLinkReturnWrongHierarchy+    toEnum 0 = PadLinkReturnOk+    toEnum k = AnotherPadLinkReturn k++foreign import ccall "gst_pad_link_return_get_type" c_gst_pad_link_return_get_type :: +    IO GType++instance BoxedEnum PadLinkReturn where+    boxedEnumType _ = c_gst_pad_link_return_get_type++-- Enum PadDirection++data PadDirection = +      PadDirectionUnknown+    | PadDirectionSrc+    | PadDirectionSink+    | AnotherPadDirection Int+    deriving (Show, Eq)++instance Enum PadDirection where+    fromEnum PadDirectionUnknown = 0+    fromEnum PadDirectionSrc = 1+    fromEnum PadDirectionSink = 2+    fromEnum (AnotherPadDirection k) = k++    toEnum 0 = PadDirectionUnknown+    toEnum 1 = PadDirectionSrc+    toEnum 2 = PadDirectionSink+    toEnum k = AnotherPadDirection k++foreign import ccall "gst_pad_direction_get_type" c_gst_pad_direction_get_type :: +    IO GType++instance BoxedEnum PadDirection where+    boxedEnumType _ = c_gst_pad_direction_get_type++-- Enum LibraryError++data LibraryError = +      LibraryErrorFailed+    | LibraryErrorTooLazy+    | LibraryErrorInit+    | LibraryErrorShutdown+    | LibraryErrorSettings+    | LibraryErrorEncode+    | LibraryErrorNumErrors+    | AnotherLibraryError Int+    deriving (Show, Eq)++instance Enum LibraryError where+    fromEnum LibraryErrorFailed = 1+    fromEnum LibraryErrorTooLazy = 2+    fromEnum LibraryErrorInit = 3+    fromEnum LibraryErrorShutdown = 4+    fromEnum LibraryErrorSettings = 5+    fromEnum LibraryErrorEncode = 6+    fromEnum LibraryErrorNumErrors = 7+    fromEnum (AnotherLibraryError k) = k++    toEnum 1 = LibraryErrorFailed+    toEnum 2 = LibraryErrorTooLazy+    toEnum 3 = LibraryErrorInit+    toEnum 4 = LibraryErrorShutdown+    toEnum 5 = LibraryErrorSettings+    toEnum 6 = LibraryErrorEncode+    toEnum 7 = LibraryErrorNumErrors+    toEnum k = AnotherLibraryError k++instance GErrorClass LibraryError where+    gerrorClassDomain _ = "gst-library-error-quark"++catchLibraryError ::+    IO a ->+    (LibraryError -> GErrorMessage -> IO a) ->+    IO a+catchLibraryError = catchGErrorJustDomain++handleLibraryError ::+    (LibraryError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleLibraryError = handleGErrorJustDomain++foreign import ccall "gst_library_error_get_type" c_gst_library_error_get_type :: +    IO GType++instance BoxedEnum LibraryError where+    boxedEnumType _ = c_gst_library_error_get_type++-- Enum IteratorResult++data IteratorResult = +      IteratorResultDone+    | IteratorResultOk+    | IteratorResultResync+    | IteratorResultError+    | AnotherIteratorResult Int+    deriving (Show, Eq)++instance Enum IteratorResult where+    fromEnum IteratorResultDone = 0+    fromEnum IteratorResultOk = 1+    fromEnum IteratorResultResync = 2+    fromEnum IteratorResultError = 3+    fromEnum (AnotherIteratorResult k) = k++    toEnum 0 = IteratorResultDone+    toEnum 1 = IteratorResultOk+    toEnum 2 = IteratorResultResync+    toEnum 3 = IteratorResultError+    toEnum k = AnotherIteratorResult k++foreign import ccall "gst_iterator_result_get_type" c_gst_iterator_result_get_type :: +    IO GType++instance BoxedEnum IteratorResult where+    boxedEnumType _ = c_gst_iterator_result_get_type++-- Enum IteratorItem++data IteratorItem = +      IteratorItemSkip+    | IteratorItemPass+    | IteratorItemEnd+    | AnotherIteratorItem Int+    deriving (Show, Eq)++instance Enum IteratorItem where+    fromEnum IteratorItemSkip = 0+    fromEnum IteratorItemPass = 1+    fromEnum IteratorItemEnd = 2+    fromEnum (AnotherIteratorItem k) = k++    toEnum 0 = IteratorItemSkip+    toEnum 1 = IteratorItemPass+    toEnum 2 = IteratorItemEnd+    toEnum k = AnotherIteratorItem k++foreign import ccall "gst_iterator_item_get_type" c_gst_iterator_item_get_type :: +    IO GType++instance BoxedEnum IteratorItem where+    boxedEnumType _ = c_gst_iterator_item_get_type++-- Enum Format++data Format = +      FormatUndefined+    | FormatDefault+    | FormatBytes+    | FormatTime+    | FormatBuffers+    | FormatPercent+    | AnotherFormat Int+    deriving (Show, Eq)++instance Enum Format where+    fromEnum FormatUndefined = 0+    fromEnum FormatDefault = 1+    fromEnum FormatBytes = 2+    fromEnum FormatTime = 3+    fromEnum FormatBuffers = 4+    fromEnum FormatPercent = 5+    fromEnum (AnotherFormat k) = k++    toEnum 0 = FormatUndefined+    toEnum 1 = FormatDefault+    toEnum 2 = FormatBytes+    toEnum 3 = FormatTime+    toEnum 4 = FormatBuffers+    toEnum 5 = FormatPercent+    toEnum k = AnotherFormat k++foreign import ccall "gst_format_get_type" c_gst_format_get_type :: +    IO GType++instance BoxedEnum Format where+    boxedEnumType _ = c_gst_format_get_type++-- Enum FlowReturn++data FlowReturn = +      FlowReturnCustomSuccess2+    | FlowReturnCustomSuccess1+    | FlowReturnCustomSuccess+    | FlowReturnOk+    | FlowReturnNotLinked+    | FlowReturnFlushing+    | FlowReturnEos+    | FlowReturnNotNegotiated+    | FlowReturnError+    | FlowReturnNotSupported+    | FlowReturnCustomError+    | FlowReturnCustomError1+    | FlowReturnCustomError2+    | AnotherFlowReturn Int+    deriving (Show, Eq)++instance Enum FlowReturn where+    fromEnum FlowReturnCustomSuccess2 = 102+    fromEnum FlowReturnCustomSuccess1 = 101+    fromEnum FlowReturnCustomSuccess = 100+    fromEnum FlowReturnOk = 0+    fromEnum FlowReturnNotLinked = -1+    fromEnum FlowReturnFlushing = -2+    fromEnum FlowReturnEos = -3+    fromEnum FlowReturnNotNegotiated = -4+    fromEnum FlowReturnError = -5+    fromEnum FlowReturnNotSupported = -6+    fromEnum FlowReturnCustomError = -100+    fromEnum FlowReturnCustomError1 = -101+    fromEnum FlowReturnCustomError2 = -102+    fromEnum (AnotherFlowReturn k) = k++    toEnum -102 = FlowReturnCustomError2+    toEnum -101 = FlowReturnCustomError1+    toEnum -100 = FlowReturnCustomError+    toEnum -6 = FlowReturnNotSupported+    toEnum -5 = FlowReturnError+    toEnum -4 = FlowReturnNotNegotiated+    toEnum -3 = FlowReturnEos+    toEnum -2 = FlowReturnFlushing+    toEnum -1 = FlowReturnNotLinked+    toEnum 0 = FlowReturnOk+    toEnum 100 = FlowReturnCustomSuccess+    toEnum 101 = FlowReturnCustomSuccess1+    toEnum 102 = FlowReturnCustomSuccess2+    toEnum k = AnotherFlowReturn k++foreign import ccall "gst_flow_return_get_type" c_gst_flow_return_get_type :: +    IO GType++instance BoxedEnum FlowReturn where+    boxedEnumType _ = c_gst_flow_return_get_type++-- Enum EventType++data EventType = +      EventTypeUnknown+    | EventTypeFlushStart+    | EventTypeFlushStop+    | EventTypeStreamStart+    | EventTypeCaps+    | EventTypeSegment+    | EventTypeTag+    | EventTypeBuffersize+    | EventTypeSinkMessage+    | EventTypeEos+    | EventTypeToc+    | EventTypeProtection+    | EventTypeSegmentDone+    | EventTypeGap+    | EventTypeQos+    | EventTypeSeek+    | EventTypeNavigation+    | EventTypeLatency+    | EventTypeStep+    | EventTypeReconfigure+    | EventTypeTocSelect+    | EventTypeCustomUpstream+    | EventTypeCustomDownstream+    | EventTypeCustomDownstreamOob+    | EventTypeCustomDownstreamSticky+    | EventTypeCustomBoth+    | EventTypeCustomBothOob+    | AnotherEventType Int+    deriving (Show, Eq)++instance Enum EventType where+    fromEnum EventTypeUnknown = 0+    fromEnum EventTypeFlushStart = 2563+    fromEnum EventTypeFlushStop = 5127+    fromEnum EventTypeStreamStart = 10254+    fromEnum EventTypeCaps = 12814+    fromEnum EventTypeSegment = 17934+    fromEnum EventTypeTag = 20510+    fromEnum EventTypeBuffersize = 23054+    fromEnum EventTypeSinkMessage = 25630+    fromEnum EventTypeEos = 28174+    fromEnum EventTypeToc = 30750+    fromEnum EventTypeProtection = 33310+    fromEnum EventTypeSegmentDone = 38406+    fromEnum EventTypeGap = 40966+    fromEnum EventTypeQos = 48641+    fromEnum EventTypeSeek = 51201+    fromEnum EventTypeNavigation = 53761+    fromEnum EventTypeLatency = 56321+    fromEnum EventTypeStep = 58881+    fromEnum EventTypeReconfigure = 61441+    fromEnum EventTypeTocSelect = 64001+    fromEnum EventTypeCustomUpstream = 69121+    fromEnum EventTypeCustomDownstream = 71686+    fromEnum EventTypeCustomDownstreamOob = 74242+    fromEnum EventTypeCustomDownstreamSticky = 76830+    fromEnum EventTypeCustomBoth = 79367+    fromEnum EventTypeCustomBothOob = 81923+    fromEnum (AnotherEventType k) = k++    toEnum 0 = EventTypeUnknown+    toEnum 2563 = EventTypeFlushStart+    toEnum 5127 = EventTypeFlushStop+    toEnum 10254 = EventTypeStreamStart+    toEnum 12814 = EventTypeCaps+    toEnum 17934 = EventTypeSegment+    toEnum 20510 = EventTypeTag+    toEnum 23054 = EventTypeBuffersize+    toEnum 25630 = EventTypeSinkMessage+    toEnum 28174 = EventTypeEos+    toEnum 30750 = EventTypeToc+    toEnum 33310 = EventTypeProtection+    toEnum 38406 = EventTypeSegmentDone+    toEnum 40966 = EventTypeGap+    toEnum 48641 = EventTypeQos+    toEnum 51201 = EventTypeSeek+    toEnum 53761 = EventTypeNavigation+    toEnum 56321 = EventTypeLatency+    toEnum 58881 = EventTypeStep+    toEnum 61441 = EventTypeReconfigure+    toEnum 64001 = EventTypeTocSelect+    toEnum 69121 = EventTypeCustomUpstream+    toEnum 71686 = EventTypeCustomDownstream+    toEnum 74242 = EventTypeCustomDownstreamOob+    toEnum 76830 = EventTypeCustomDownstreamSticky+    toEnum 79367 = EventTypeCustomBoth+    toEnum 81923 = EventTypeCustomBothOob+    toEnum k = AnotherEventType k++foreign import ccall "gst_event_type_get_type" c_gst_event_type_get_type :: +    IO GType++instance BoxedEnum EventType where+    boxedEnumType _ = c_gst_event_type_get_type++-- Enum DebugLevel++data DebugLevel = +      DebugLevelNone+    | DebugLevelError+    | DebugLevelWarning+    | DebugLevelFixme+    | DebugLevelInfo+    | DebugLevelDebug+    | DebugLevelLog+    | DebugLevelTrace+    | DebugLevelMemdump+    | DebugLevelCount+    | AnotherDebugLevel Int+    deriving (Show, Eq)++instance Enum DebugLevel where+    fromEnum DebugLevelNone = 0+    fromEnum DebugLevelError = 1+    fromEnum DebugLevelWarning = 2+    fromEnum DebugLevelFixme = 3+    fromEnum DebugLevelInfo = 4+    fromEnum DebugLevelDebug = 5+    fromEnum DebugLevelLog = 6+    fromEnum DebugLevelTrace = 7+    fromEnum DebugLevelMemdump = 9+    fromEnum DebugLevelCount = 10+    fromEnum (AnotherDebugLevel k) = k++    toEnum 0 = DebugLevelNone+    toEnum 1 = DebugLevelError+    toEnum 2 = DebugLevelWarning+    toEnum 3 = DebugLevelFixme+    toEnum 4 = DebugLevelInfo+    toEnum 5 = DebugLevelDebug+    toEnum 6 = DebugLevelLog+    toEnum 7 = DebugLevelTrace+    toEnum 9 = DebugLevelMemdump+    toEnum 10 = DebugLevelCount+    toEnum k = AnotherDebugLevel k++foreign import ccall "gst_debug_level_get_type" c_gst_debug_level_get_type :: +    IO GType++instance BoxedEnum DebugLevel where+    boxedEnumType _ = c_gst_debug_level_get_type++-- Enum DebugColorMode++data DebugColorMode = +      DebugColorModeOff+    | DebugColorModeOn+    | DebugColorModeUnix+    | AnotherDebugColorMode Int+    deriving (Show, Eq)++instance Enum DebugColorMode where+    fromEnum DebugColorModeOff = 0+    fromEnum DebugColorModeOn = 1+    fromEnum DebugColorModeUnix = 2+    fromEnum (AnotherDebugColorMode k) = k++    toEnum 0 = DebugColorModeOff+    toEnum 1 = DebugColorModeOn+    toEnum 2 = DebugColorModeUnix+    toEnum k = AnotherDebugColorMode k++foreign import ccall "gst_debug_color_mode_get_type" c_gst_debug_color_mode_get_type :: +    IO GType++instance BoxedEnum DebugColorMode where+    boxedEnumType _ = c_gst_debug_color_mode_get_type++-- Enum DebugColorFlags++data DebugColorFlags = +      DebugColorFlagsFgBlack+    | DebugColorFlagsFgRed+    | DebugColorFlagsFgGreen+    | DebugColorFlagsFgYellow+    | DebugColorFlagsFgBlue+    | DebugColorFlagsFgMagenta+    | DebugColorFlagsFgCyan+    | DebugColorFlagsFgWhite+    | DebugColorFlagsBgBlack+    | DebugColorFlagsBgRed+    | DebugColorFlagsBgGreen+    | DebugColorFlagsBgYellow+    | DebugColorFlagsBgBlue+    | DebugColorFlagsBgMagenta+    | DebugColorFlagsBgCyan+    | DebugColorFlagsBgWhite+    | DebugColorFlagsBold+    | DebugColorFlagsUnderline+    | AnotherDebugColorFlags Int+    deriving (Show, Eq)++instance Enum DebugColorFlags where+    fromEnum DebugColorFlagsFgBlack = 0+    fromEnum DebugColorFlagsFgRed = 1+    fromEnum DebugColorFlagsFgGreen = 2+    fromEnum DebugColorFlagsFgYellow = 3+    fromEnum DebugColorFlagsFgBlue = 4+    fromEnum DebugColorFlagsFgMagenta = 5+    fromEnum DebugColorFlagsFgCyan = 6+    fromEnum DebugColorFlagsFgWhite = 7+    fromEnum DebugColorFlagsBgBlack = 0+    fromEnum DebugColorFlagsBgRed = 16+    fromEnum DebugColorFlagsBgGreen = 32+    fromEnum DebugColorFlagsBgYellow = 48+    fromEnum DebugColorFlagsBgBlue = 64+    fromEnum DebugColorFlagsBgMagenta = 80+    fromEnum DebugColorFlagsBgCyan = 96+    fromEnum DebugColorFlagsBgWhite = 112+    fromEnum DebugColorFlagsBold = 256+    fromEnum DebugColorFlagsUnderline = 512+    fromEnum (AnotherDebugColorFlags k) = k++    toEnum 0 = DebugColorFlagsFgBlack+    toEnum 1 = DebugColorFlagsFgRed+    toEnum 2 = DebugColorFlagsFgGreen+    toEnum 3 = DebugColorFlagsFgYellow+    toEnum 4 = DebugColorFlagsFgBlue+    toEnum 5 = DebugColorFlagsFgMagenta+    toEnum 6 = DebugColorFlagsFgCyan+    toEnum 7 = DebugColorFlagsFgWhite+    toEnum 16 = DebugColorFlagsBgRed+    toEnum 32 = DebugColorFlagsBgGreen+    toEnum 48 = DebugColorFlagsBgYellow+    toEnum 64 = DebugColorFlagsBgBlue+    toEnum 80 = DebugColorFlagsBgMagenta+    toEnum 96 = DebugColorFlagsBgCyan+    toEnum 112 = DebugColorFlagsBgWhite+    toEnum 256 = DebugColorFlagsBold+    toEnum 512 = DebugColorFlagsUnderline+    toEnum k = AnotherDebugColorFlags k++foreign import ccall "gst_debug_color_flags_get_type" c_gst_debug_color_flags_get_type :: +    IO GType++instance BoxedEnum DebugColorFlags where+    boxedEnumType _ = c_gst_debug_color_flags_get_type++-- Enum CoreError++data CoreError = +      CoreErrorFailed+    | CoreErrorTooLazy+    | CoreErrorNotImplemented+    | CoreErrorStateChange+    | CoreErrorPad+    | CoreErrorThread+    | CoreErrorNegotiation+    | CoreErrorEvent+    | CoreErrorSeek+    | CoreErrorCaps+    | CoreErrorTag+    | CoreErrorMissingPlugin+    | CoreErrorClock+    | CoreErrorDisabled+    | CoreErrorNumErrors+    | AnotherCoreError Int+    deriving (Show, Eq)++instance Enum CoreError where+    fromEnum CoreErrorFailed = 1+    fromEnum CoreErrorTooLazy = 2+    fromEnum CoreErrorNotImplemented = 3+    fromEnum CoreErrorStateChange = 4+    fromEnum CoreErrorPad = 5+    fromEnum CoreErrorThread = 6+    fromEnum CoreErrorNegotiation = 7+    fromEnum CoreErrorEvent = 8+    fromEnum CoreErrorSeek = 9+    fromEnum CoreErrorCaps = 10+    fromEnum CoreErrorTag = 11+    fromEnum CoreErrorMissingPlugin = 12+    fromEnum CoreErrorClock = 13+    fromEnum CoreErrorDisabled = 14+    fromEnum CoreErrorNumErrors = 15+    fromEnum (AnotherCoreError k) = k++    toEnum 1 = CoreErrorFailed+    toEnum 2 = CoreErrorTooLazy+    toEnum 3 = CoreErrorNotImplemented+    toEnum 4 = CoreErrorStateChange+    toEnum 5 = CoreErrorPad+    toEnum 6 = CoreErrorThread+    toEnum 7 = CoreErrorNegotiation+    toEnum 8 = CoreErrorEvent+    toEnum 9 = CoreErrorSeek+    toEnum 10 = CoreErrorCaps+    toEnum 11 = CoreErrorTag+    toEnum 12 = CoreErrorMissingPlugin+    toEnum 13 = CoreErrorClock+    toEnum 14 = CoreErrorDisabled+    toEnum 15 = CoreErrorNumErrors+    toEnum k = AnotherCoreError k++instance GErrorClass CoreError where+    gerrorClassDomain _ = "gst-core-error-quark"++catchCoreError ::+    IO a ->+    (CoreError -> GErrorMessage -> IO a) ->+    IO a+catchCoreError = catchGErrorJustDomain++handleCoreError ::+    (CoreError -> GErrorMessage -> IO a) ->+    IO a ->+    IO a+handleCoreError = handleGErrorJustDomain++foreign import ccall "gst_core_error_get_type" c_gst_core_error_get_type :: +    IO GType++instance BoxedEnum CoreError where+    boxedEnumType _ = c_gst_core_error_get_type++-- Enum ClockType++data ClockType = +      ClockTypeRealtime+    | ClockTypeMonotonic+    | ClockTypeOther+    | AnotherClockType Int+    deriving (Show, Eq)++instance Enum ClockType where+    fromEnum ClockTypeRealtime = 0+    fromEnum ClockTypeMonotonic = 1+    fromEnum ClockTypeOther = 2+    fromEnum (AnotherClockType k) = k++    toEnum 0 = ClockTypeRealtime+    toEnum 1 = ClockTypeMonotonic+    toEnum 2 = ClockTypeOther+    toEnum k = AnotherClockType k++foreign import ccall "gst_clock_type_get_type" c_gst_clock_type_get_type :: +    IO GType++instance BoxedEnum ClockType where+    boxedEnumType _ = c_gst_clock_type_get_type++-- Enum ClockReturn++data ClockReturn = +      ClockReturnOk+    | ClockReturnEarly+    | ClockReturnUnscheduled+    | ClockReturnBusy+    | ClockReturnBadtime+    | ClockReturnError+    | ClockReturnUnsupported+    | ClockReturnDone+    | AnotherClockReturn Int+    deriving (Show, Eq)++instance Enum ClockReturn where+    fromEnum ClockReturnOk = 0+    fromEnum ClockReturnEarly = 1+    fromEnum ClockReturnUnscheduled = 2+    fromEnum ClockReturnBusy = 3+    fromEnum ClockReturnBadtime = 4+    fromEnum ClockReturnError = 5+    fromEnum ClockReturnUnsupported = 6+    fromEnum ClockReturnDone = 7+    fromEnum (AnotherClockReturn k) = k++    toEnum 0 = ClockReturnOk+    toEnum 1 = ClockReturnEarly+    toEnum 2 = ClockReturnUnscheduled+    toEnum 3 = ClockReturnBusy+    toEnum 4 = ClockReturnBadtime+    toEnum 5 = ClockReturnError+    toEnum 6 = ClockReturnUnsupported+    toEnum 7 = ClockReturnDone+    toEnum k = AnotherClockReturn k++foreign import ccall "gst_clock_return_get_type" c_gst_clock_return_get_type :: +    IO GType++instance BoxedEnum ClockReturn where+    boxedEnumType _ = c_gst_clock_return_get_type++-- Enum ClockEntryType++data ClockEntryType = +      ClockEntryTypeSingle+    | ClockEntryTypePeriodic+    | AnotherClockEntryType Int+    deriving (Show, Eq)++instance Enum ClockEntryType where+    fromEnum ClockEntryTypeSingle = 0+    fromEnum ClockEntryTypePeriodic = 1+    fromEnum (AnotherClockEntryType k) = k++    toEnum 0 = ClockEntryTypeSingle+    toEnum 1 = ClockEntryTypePeriodic+    toEnum k = AnotherClockEntryType k++foreign import ccall "gst_clock_entry_type_get_type" c_gst_clock_entry_type_get_type :: +    IO GType++instance BoxedEnum ClockEntryType where+    boxedEnumType _ = c_gst_clock_entry_type_get_type++-- Enum CapsIntersectMode++data CapsIntersectMode = +      CapsIntersectModeZigZag+    | CapsIntersectModeFirst+    | AnotherCapsIntersectMode Int+    deriving (Show, Eq)++instance Enum CapsIntersectMode where+    fromEnum CapsIntersectModeZigZag = 0+    fromEnum CapsIntersectModeFirst = 1+    fromEnum (AnotherCapsIntersectMode k) = k++    toEnum 0 = CapsIntersectModeZigZag+    toEnum 1 = CapsIntersectModeFirst+    toEnum k = AnotherCapsIntersectMode k++foreign import ccall "gst_caps_intersect_mode_get_type" c_gst_caps_intersect_mode_get_type :: +    IO GType++instance BoxedEnum CapsIntersectMode where+    boxedEnumType _ = c_gst_caps_intersect_mode_get_type++-- Enum BusSyncReply++data BusSyncReply = +      BusSyncReplyDrop+    | BusSyncReplyPass+    | BusSyncReplyAsync+    | AnotherBusSyncReply Int+    deriving (Show, Eq)++instance Enum BusSyncReply where+    fromEnum BusSyncReplyDrop = 0+    fromEnum BusSyncReplyPass = 1+    fromEnum BusSyncReplyAsync = 2+    fromEnum (AnotherBusSyncReply k) = k++    toEnum 0 = BusSyncReplyDrop+    toEnum 1 = BusSyncReplyPass+    toEnum 2 = BusSyncReplyAsync+    toEnum k = AnotherBusSyncReply k++foreign import ccall "gst_bus_sync_reply_get_type" c_gst_bus_sync_reply_get_type :: +    IO GType++instance BoxedEnum BusSyncReply where+    boxedEnumType _ = c_gst_bus_sync_reply_get_type++-- Enum BufferingMode++data BufferingMode = +      BufferingModeStream+    | BufferingModeDownload+    | BufferingModeTimeshift+    | BufferingModeLive+    | AnotherBufferingMode Int+    deriving (Show, Eq)++instance Enum BufferingMode where+    fromEnum BufferingModeStream = 0+    fromEnum BufferingModeDownload = 1+    fromEnum BufferingModeTimeshift = 2+    fromEnum BufferingModeLive = 3+    fromEnum (AnotherBufferingMode k) = k++    toEnum 0 = BufferingModeStream+    toEnum 1 = BufferingModeDownload+    toEnum 2 = BufferingModeTimeshift+    toEnum 3 = BufferingModeLive+    toEnum k = AnotherBufferingMode k++foreign import ccall "gst_buffering_mode_get_type" c_gst_buffering_mode_get_type :: +    IO GType++instance BoxedEnum BufferingMode where+    boxedEnumType _ = c_gst_buffering_mode_get_type++
+ GI/Gst/Flags.hs view
@@ -0,0 +1,1244 @@+++{- |+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.Flags+    ( ++-- * Exported types+    StreamFlags(..)                         ,+    SegmentFlags(..)                        ,+    SeekFlags(..)                           ,+    SchedulingFlags(..)                     ,+    QueryTypeFlags(..)                      ,+    PluginFlags(..)                         ,+    PluginDependencyFlags(..)               ,+    PipelineFlags(..)                       ,+    ParseFlags(..)                          ,+    PadTemplateFlags(..)                    ,+    PadProbeType(..)                        ,+    PadLinkCheck(..)                        ,+    PadFlags(..)                            ,+    ObjectFlags(..)                         ,+    MiniObjectFlags(..)                     ,+    MetaFlags(..)                           ,+    MessageType(..)                         ,+    MemoryFlags(..)                         ,+    MapFlags(..)                            ,+    LockFlags(..)                           ,+    EventTypeFlags(..)                      ,+    ElementFlags(..)                        ,+    DebugGraphDetails(..)                   ,+    ClockFlags(..)                          ,+    CapsFlags(..)                           ,+    BusFlags(..)                            ,+    BufferPoolAcquireFlags(..)              ,+    BufferFlags(..)                         ,+    BufferCopyFlags(..)                     ,+    BinFlags(..)                            ,+    AllocatorFlags(..)                      ,+++    ) 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+++++-- Flags StreamFlags++data StreamFlags = +      StreamFlagsNone+    | StreamFlagsSparse+    | StreamFlagsSelect+    | StreamFlagsUnselect+    | AnotherStreamFlags Int+    deriving (Show, Eq)++instance Enum StreamFlags where+    fromEnum StreamFlagsNone = 0+    fromEnum StreamFlagsSparse = 1+    fromEnum StreamFlagsSelect = 2+    fromEnum StreamFlagsUnselect = 4+    fromEnum (AnotherStreamFlags k) = k++    toEnum 0 = StreamFlagsNone+    toEnum 1 = StreamFlagsSparse+    toEnum 2 = StreamFlagsSelect+    toEnum 4 = StreamFlagsUnselect+    toEnum k = AnotherStreamFlags k++foreign import ccall "gst_stream_flags_get_type" c_gst_stream_flags_get_type :: +    IO GType++instance BoxedEnum StreamFlags where+    boxedEnumType _ = c_gst_stream_flags_get_type++instance IsGFlag StreamFlags++-- Flags SegmentFlags++data SegmentFlags = +      SegmentFlagsNone+    | SegmentFlagsReset+    | SegmentFlagsTrickmode+    | SegmentFlagsSkip+    | SegmentFlagsSegment+    | SegmentFlagsTrickmodeKeyUnits+    | SegmentFlagsTrickmodeNoAudio+    | AnotherSegmentFlags Int+    deriving (Show, Eq)++instance Enum SegmentFlags where+    fromEnum SegmentFlagsNone = 0+    fromEnum SegmentFlagsReset = 1+    fromEnum SegmentFlagsTrickmode = 16+    fromEnum SegmentFlagsSkip = 16+    fromEnum SegmentFlagsSegment = 8+    fromEnum SegmentFlagsTrickmodeKeyUnits = 128+    fromEnum SegmentFlagsTrickmodeNoAudio = 256+    fromEnum (AnotherSegmentFlags k) = k++    toEnum 0 = SegmentFlagsNone+    toEnum 1 = SegmentFlagsReset+    toEnum 8 = SegmentFlagsSegment+    toEnum 16 = SegmentFlagsTrickmode+    toEnum 128 = SegmentFlagsTrickmodeKeyUnits+    toEnum 256 = SegmentFlagsTrickmodeNoAudio+    toEnum k = AnotherSegmentFlags k++foreign import ccall "gst_segment_flags_get_type" c_gst_segment_flags_get_type :: +    IO GType++instance BoxedEnum SegmentFlags where+    boxedEnumType _ = c_gst_segment_flags_get_type++instance IsGFlag SegmentFlags++-- Flags SeekFlags++data SeekFlags = +      SeekFlagsNone+    | SeekFlagsFlush+    | SeekFlagsAccurate+    | SeekFlagsKeyUnit+    | SeekFlagsSegment+    | SeekFlagsTrickmode+    | SeekFlagsSkip+    | SeekFlagsSnapBefore+    | SeekFlagsSnapAfter+    | SeekFlagsSnapNearest+    | SeekFlagsTrickmodeKeyUnits+    | SeekFlagsTrickmodeNoAudio+    | AnotherSeekFlags Int+    deriving (Show, Eq)++instance Enum SeekFlags where+    fromEnum SeekFlagsNone = 0+    fromEnum SeekFlagsFlush = 1+    fromEnum SeekFlagsAccurate = 2+    fromEnum SeekFlagsKeyUnit = 4+    fromEnum SeekFlagsSegment = 8+    fromEnum SeekFlagsTrickmode = 16+    fromEnum SeekFlagsSkip = 16+    fromEnum SeekFlagsSnapBefore = 32+    fromEnum SeekFlagsSnapAfter = 64+    fromEnum SeekFlagsSnapNearest = 96+    fromEnum SeekFlagsTrickmodeKeyUnits = 128+    fromEnum SeekFlagsTrickmodeNoAudio = 256+    fromEnum (AnotherSeekFlags k) = k++    toEnum 0 = SeekFlagsNone+    toEnum 1 = SeekFlagsFlush+    toEnum 2 = SeekFlagsAccurate+    toEnum 4 = SeekFlagsKeyUnit+    toEnum 8 = SeekFlagsSegment+    toEnum 16 = SeekFlagsTrickmode+    toEnum 32 = SeekFlagsSnapBefore+    toEnum 64 = SeekFlagsSnapAfter+    toEnum 96 = SeekFlagsSnapNearest+    toEnum 128 = SeekFlagsTrickmodeKeyUnits+    toEnum 256 = SeekFlagsTrickmodeNoAudio+    toEnum k = AnotherSeekFlags k++foreign import ccall "gst_seek_flags_get_type" c_gst_seek_flags_get_type :: +    IO GType++instance BoxedEnum SeekFlags where+    boxedEnumType _ = c_gst_seek_flags_get_type++instance IsGFlag SeekFlags++-- Flags SchedulingFlags++data SchedulingFlags = +      SchedulingFlagsSeekable+    | SchedulingFlagsSequential+    | SchedulingFlagsBandwidthLimited+    | AnotherSchedulingFlags Int+    deriving (Show, Eq)++instance Enum SchedulingFlags where+    fromEnum SchedulingFlagsSeekable = 1+    fromEnum SchedulingFlagsSequential = 2+    fromEnum SchedulingFlagsBandwidthLimited = 4+    fromEnum (AnotherSchedulingFlags k) = k++    toEnum 1 = SchedulingFlagsSeekable+    toEnum 2 = SchedulingFlagsSequential+    toEnum 4 = SchedulingFlagsBandwidthLimited+    toEnum k = AnotherSchedulingFlags k++foreign import ccall "gst_scheduling_flags_get_type" c_gst_scheduling_flags_get_type :: +    IO GType++instance BoxedEnum SchedulingFlags where+    boxedEnumType _ = c_gst_scheduling_flags_get_type++instance IsGFlag SchedulingFlags++-- Flags QueryTypeFlags++data QueryTypeFlags = +      QueryTypeFlagsUpstream+    | QueryTypeFlagsDownstream+    | QueryTypeFlagsSerialized+    | AnotherQueryTypeFlags Int+    deriving (Show, Eq)++instance Enum QueryTypeFlags where+    fromEnum QueryTypeFlagsUpstream = 1+    fromEnum QueryTypeFlagsDownstream = 2+    fromEnum QueryTypeFlagsSerialized = 4+    fromEnum (AnotherQueryTypeFlags k) = k++    toEnum 1 = QueryTypeFlagsUpstream+    toEnum 2 = QueryTypeFlagsDownstream+    toEnum 4 = QueryTypeFlagsSerialized+    toEnum k = AnotherQueryTypeFlags k++foreign import ccall "gst_query_type_flags_get_type" c_gst_query_type_flags_get_type :: +    IO GType++instance BoxedEnum QueryTypeFlags where+    boxedEnumType _ = c_gst_query_type_flags_get_type++instance IsGFlag QueryTypeFlags++-- Flags PluginFlags++data PluginFlags = +      PluginFlagsCached+    | PluginFlagsBlacklisted+    | AnotherPluginFlags Int+    deriving (Show, Eq)++instance Enum PluginFlags where+    fromEnum PluginFlagsCached = 16+    fromEnum PluginFlagsBlacklisted = 32+    fromEnum (AnotherPluginFlags k) = k++    toEnum 16 = PluginFlagsCached+    toEnum 32 = PluginFlagsBlacklisted+    toEnum k = AnotherPluginFlags k++foreign import ccall "gst_plugin_flags_get_type" c_gst_plugin_flags_get_type :: +    IO GType++instance BoxedEnum PluginFlags where+    boxedEnumType _ = c_gst_plugin_flags_get_type++instance IsGFlag PluginFlags++-- Flags PluginDependencyFlags++data PluginDependencyFlags = +      PluginDependencyFlagsNone+    | PluginDependencyFlagsRecurse+    | PluginDependencyFlagsPathsAreDefaultOnly+    | PluginDependencyFlagsFileNameIsSuffix+    | AnotherPluginDependencyFlags Int+    deriving (Show, Eq)++instance Enum PluginDependencyFlags where+    fromEnum PluginDependencyFlagsNone = 0+    fromEnum PluginDependencyFlagsRecurse = 1+    fromEnum PluginDependencyFlagsPathsAreDefaultOnly = 2+    fromEnum PluginDependencyFlagsFileNameIsSuffix = 4+    fromEnum (AnotherPluginDependencyFlags k) = k++    toEnum 0 = PluginDependencyFlagsNone+    toEnum 1 = PluginDependencyFlagsRecurse+    toEnum 2 = PluginDependencyFlagsPathsAreDefaultOnly+    toEnum 4 = PluginDependencyFlagsFileNameIsSuffix+    toEnum k = AnotherPluginDependencyFlags k++foreign import ccall "gst_plugin_dependency_flags_get_type" c_gst_plugin_dependency_flags_get_type :: +    IO GType++instance BoxedEnum PluginDependencyFlags where+    boxedEnumType _ = c_gst_plugin_dependency_flags_get_type++instance IsGFlag PluginDependencyFlags++-- Flags PipelineFlags++data PipelineFlags = +      PipelineFlagsFixedClock+    | PipelineFlagsLast+    | AnotherPipelineFlags Int+    deriving (Show, Eq)++instance Enum PipelineFlags where+    fromEnum PipelineFlagsFixedClock = 524288+    fromEnum PipelineFlagsLast = 8388608+    fromEnum (AnotherPipelineFlags k) = k++    toEnum 524288 = PipelineFlagsFixedClock+    toEnum 8388608 = PipelineFlagsLast+    toEnum k = AnotherPipelineFlags k++foreign import ccall "gst_pipeline_flags_get_type" c_gst_pipeline_flags_get_type :: +    IO GType++instance BoxedEnum PipelineFlags where+    boxedEnumType _ = c_gst_pipeline_flags_get_type++instance IsGFlag PipelineFlags++-- Flags ParseFlags++data ParseFlags = +      ParseFlagsNone+    | ParseFlagsFatalErrors+    | ParseFlagsNoSingleElementBins+    | AnotherParseFlags Int+    deriving (Show, Eq)++instance Enum ParseFlags where+    fromEnum ParseFlagsNone = 0+    fromEnum ParseFlagsFatalErrors = 1+    fromEnum ParseFlagsNoSingleElementBins = 2+    fromEnum (AnotherParseFlags k) = k++    toEnum 0 = ParseFlagsNone+    toEnum 1 = ParseFlagsFatalErrors+    toEnum 2 = ParseFlagsNoSingleElementBins+    toEnum k = AnotherParseFlags k++foreign import ccall "gst_parse_flags_get_type" c_gst_parse_flags_get_type :: +    IO GType++instance BoxedEnum ParseFlags where+    boxedEnumType _ = c_gst_parse_flags_get_type++instance IsGFlag ParseFlags++-- Flags PadTemplateFlags++data PadTemplateFlags = +      PadTemplateFlagsLast+    | AnotherPadTemplateFlags Int+    deriving (Show, Eq)++instance Enum PadTemplateFlags where+    fromEnum PadTemplateFlagsLast = 256+    fromEnum (AnotherPadTemplateFlags k) = k++    toEnum 256 = PadTemplateFlagsLast+    toEnum k = AnotherPadTemplateFlags k++foreign import ccall "gst_pad_template_flags_get_type" c_gst_pad_template_flags_get_type :: +    IO GType++instance BoxedEnum PadTemplateFlags where+    boxedEnumType _ = c_gst_pad_template_flags_get_type++instance IsGFlag PadTemplateFlags++-- Flags PadProbeType++data PadProbeType = +      PadProbeTypeInvalid+    | PadProbeTypeIdle+    | PadProbeTypeBlock+    | PadProbeTypeBuffer+    | PadProbeTypeBufferList+    | PadProbeTypeEventDownstream+    | PadProbeTypeEventUpstream+    | PadProbeTypeEventFlush+    | PadProbeTypeQueryDownstream+    | PadProbeTypeQueryUpstream+    | PadProbeTypePush+    | PadProbeTypePull+    | PadProbeTypeBlocking+    | PadProbeTypeDataDownstream+    | PadProbeTypeDataUpstream+    | PadProbeTypeDataBoth+    | PadProbeTypeBlockDownstream+    | PadProbeTypeBlockUpstream+    | PadProbeTypeEventBoth+    | PadProbeTypeQueryBoth+    | PadProbeTypeAllBoth+    | PadProbeTypeScheduling+    | AnotherPadProbeType Int+    deriving (Show, Eq)++instance Enum PadProbeType where+    fromEnum PadProbeTypeInvalid = 0+    fromEnum PadProbeTypeIdle = 1+    fromEnum PadProbeTypeBlock = 2+    fromEnum PadProbeTypeBuffer = 16+    fromEnum PadProbeTypeBufferList = 32+    fromEnum PadProbeTypeEventDownstream = 64+    fromEnum PadProbeTypeEventUpstream = 128+    fromEnum PadProbeTypeEventFlush = 256+    fromEnum PadProbeTypeQueryDownstream = 512+    fromEnum PadProbeTypeQueryUpstream = 1024+    fromEnum PadProbeTypePush = 4096+    fromEnum PadProbeTypePull = 8192+    fromEnum PadProbeTypeBlocking = 3+    fromEnum PadProbeTypeDataDownstream = 112+    fromEnum PadProbeTypeDataUpstream = 128+    fromEnum PadProbeTypeDataBoth = 240+    fromEnum PadProbeTypeBlockDownstream = 114+    fromEnum PadProbeTypeBlockUpstream = 130+    fromEnum PadProbeTypeEventBoth = 192+    fromEnum PadProbeTypeQueryBoth = 1536+    fromEnum PadProbeTypeAllBoth = 1776+    fromEnum PadProbeTypeScheduling = 12288+    fromEnum (AnotherPadProbeType k) = k++    toEnum 0 = PadProbeTypeInvalid+    toEnum 1 = PadProbeTypeIdle+    toEnum 2 = PadProbeTypeBlock+    toEnum 3 = PadProbeTypeBlocking+    toEnum 16 = PadProbeTypeBuffer+    toEnum 32 = PadProbeTypeBufferList+    toEnum 64 = PadProbeTypeEventDownstream+    toEnum 112 = PadProbeTypeDataDownstream+    toEnum 114 = PadProbeTypeBlockDownstream+    toEnum 128 = PadProbeTypeEventUpstream+    toEnum 130 = PadProbeTypeBlockUpstream+    toEnum 192 = PadProbeTypeEventBoth+    toEnum 240 = PadProbeTypeDataBoth+    toEnum 256 = PadProbeTypeEventFlush+    toEnum 512 = PadProbeTypeQueryDownstream+    toEnum 1024 = PadProbeTypeQueryUpstream+    toEnum 1536 = PadProbeTypeQueryBoth+    toEnum 1776 = PadProbeTypeAllBoth+    toEnum 4096 = PadProbeTypePush+    toEnum 8192 = PadProbeTypePull+    toEnum 12288 = PadProbeTypeScheduling+    toEnum k = AnotherPadProbeType k++foreign import ccall "gst_pad_probe_type_get_type" c_gst_pad_probe_type_get_type :: +    IO GType++instance BoxedEnum PadProbeType where+    boxedEnumType _ = c_gst_pad_probe_type_get_type++instance IsGFlag PadProbeType++-- Flags PadLinkCheck++data PadLinkCheck = +      PadLinkCheckNothing+    | PadLinkCheckHierarchy+    | PadLinkCheckTemplateCaps+    | PadLinkCheckCaps+    | PadLinkCheckDefault+    | AnotherPadLinkCheck Int+    deriving (Show, Eq)++instance Enum PadLinkCheck where+    fromEnum PadLinkCheckNothing = 0+    fromEnum PadLinkCheckHierarchy = 1+    fromEnum PadLinkCheckTemplateCaps = 2+    fromEnum PadLinkCheckCaps = 4+    fromEnum PadLinkCheckDefault = 5+    fromEnum (AnotherPadLinkCheck k) = k++    toEnum 0 = PadLinkCheckNothing+    toEnum 1 = PadLinkCheckHierarchy+    toEnum 2 = PadLinkCheckTemplateCaps+    toEnum 4 = PadLinkCheckCaps+    toEnum 5 = PadLinkCheckDefault+    toEnum k = AnotherPadLinkCheck k++foreign import ccall "gst_pad_link_check_get_type" c_gst_pad_link_check_get_type :: +    IO GType++instance BoxedEnum PadLinkCheck where+    boxedEnumType _ = c_gst_pad_link_check_get_type++instance IsGFlag PadLinkCheck++-- Flags PadFlags++data PadFlags = +      PadFlagsBlocked+    | PadFlagsFlushing+    | PadFlagsEos+    | PadFlagsBlocking+    | PadFlagsNeedParent+    | PadFlagsNeedReconfigure+    | PadFlagsPendingEvents+    | PadFlagsFixedCaps+    | PadFlagsProxyCaps+    | PadFlagsProxyAllocation+    | PadFlagsProxyScheduling+    | PadFlagsAcceptIntersect+    | PadFlagsAcceptTemplate+    | PadFlagsLast+    | AnotherPadFlags Int+    deriving (Show, Eq)++instance Enum PadFlags where+    fromEnum PadFlagsBlocked = 16+    fromEnum PadFlagsFlushing = 32+    fromEnum PadFlagsEos = 64+    fromEnum PadFlagsBlocking = 128+    fromEnum PadFlagsNeedParent = 256+    fromEnum PadFlagsNeedReconfigure = 512+    fromEnum PadFlagsPendingEvents = 1024+    fromEnum PadFlagsFixedCaps = 2048+    fromEnum PadFlagsProxyCaps = 4096+    fromEnum PadFlagsProxyAllocation = 8192+    fromEnum PadFlagsProxyScheduling = 16384+    fromEnum PadFlagsAcceptIntersect = 32768+    fromEnum PadFlagsAcceptTemplate = 65536+    fromEnum PadFlagsLast = 1048576+    fromEnum (AnotherPadFlags k) = k++    toEnum 16 = PadFlagsBlocked+    toEnum 32 = PadFlagsFlushing+    toEnum 64 = PadFlagsEos+    toEnum 128 = PadFlagsBlocking+    toEnum 256 = PadFlagsNeedParent+    toEnum 512 = PadFlagsNeedReconfigure+    toEnum 1024 = PadFlagsPendingEvents+    toEnum 2048 = PadFlagsFixedCaps+    toEnum 4096 = PadFlagsProxyCaps+    toEnum 8192 = PadFlagsProxyAllocation+    toEnum 16384 = PadFlagsProxyScheduling+    toEnum 32768 = PadFlagsAcceptIntersect+    toEnum 65536 = PadFlagsAcceptTemplate+    toEnum 1048576 = PadFlagsLast+    toEnum k = AnotherPadFlags k++foreign import ccall "gst_pad_flags_get_type" c_gst_pad_flags_get_type :: +    IO GType++instance BoxedEnum PadFlags where+    boxedEnumType _ = c_gst_pad_flags_get_type++instance IsGFlag PadFlags++-- Flags ObjectFlags++data ObjectFlags = +      ObjectFlagsLast+    | AnotherObjectFlags Int+    deriving (Show, Eq)++instance Enum ObjectFlags where+    fromEnum ObjectFlagsLast = 16+    fromEnum (AnotherObjectFlags k) = k++    toEnum 16 = ObjectFlagsLast+    toEnum k = AnotherObjectFlags k++foreign import ccall "gst_object_flags_get_type" c_gst_object_flags_get_type :: +    IO GType++instance BoxedEnum ObjectFlags where+    boxedEnumType _ = c_gst_object_flags_get_type++instance IsGFlag ObjectFlags++-- Flags MiniObjectFlags++data MiniObjectFlags = +      MiniObjectFlagsLockable+    | MiniObjectFlagsLockReadonly+    | MiniObjectFlagsLast+    | AnotherMiniObjectFlags Int+    deriving (Show, Eq)++instance Enum MiniObjectFlags where+    fromEnum MiniObjectFlagsLockable = 1+    fromEnum MiniObjectFlagsLockReadonly = 2+    fromEnum MiniObjectFlagsLast = 16+    fromEnum (AnotherMiniObjectFlags k) = k++    toEnum 1 = MiniObjectFlagsLockable+    toEnum 2 = MiniObjectFlagsLockReadonly+    toEnum 16 = MiniObjectFlagsLast+    toEnum k = AnotherMiniObjectFlags k++foreign import ccall "gst_mini_object_flags_get_type" c_gst_mini_object_flags_get_type :: +    IO GType++instance BoxedEnum MiniObjectFlags where+    boxedEnumType _ = c_gst_mini_object_flags_get_type++instance IsGFlag MiniObjectFlags++-- Flags MetaFlags++data MetaFlags = +      MetaFlagsNone+    | MetaFlagsReadonly+    | MetaFlagsPooled+    | MetaFlagsLocked+    | MetaFlagsLast+    | AnotherMetaFlags Int+    deriving (Show, Eq)++instance Enum MetaFlags where+    fromEnum MetaFlagsNone = 0+    fromEnum MetaFlagsReadonly = 1+    fromEnum MetaFlagsPooled = 2+    fromEnum MetaFlagsLocked = 4+    fromEnum MetaFlagsLast = 65536+    fromEnum (AnotherMetaFlags k) = k++    toEnum 0 = MetaFlagsNone+    toEnum 1 = MetaFlagsReadonly+    toEnum 2 = MetaFlagsPooled+    toEnum 4 = MetaFlagsLocked+    toEnum 65536 = MetaFlagsLast+    toEnum k = AnotherMetaFlags k++foreign import ccall "gst_meta_flags_get_type" c_gst_meta_flags_get_type :: +    IO GType++instance BoxedEnum MetaFlags where+    boxedEnumType _ = c_gst_meta_flags_get_type++instance IsGFlag MetaFlags++-- Flags MessageType++data MessageType = +      MessageTypeUnknown+    | MessageTypeEos+    | MessageTypeError+    | MessageTypeWarning+    | MessageTypeInfo+    | MessageTypeTag+    | MessageTypeBuffering+    | MessageTypeStateChanged+    | MessageTypeStateDirty+    | MessageTypeStepDone+    | MessageTypeClockProvide+    | MessageTypeClockLost+    | MessageTypeNewClock+    | MessageTypeStructureChange+    | MessageTypeStreamStatus+    | MessageTypeApplication+    | MessageTypeElement+    | MessageTypeSegmentStart+    | MessageTypeSegmentDone+    | MessageTypeDurationChanged+    | MessageTypeLatency+    | MessageTypeAsyncStart+    | MessageTypeAsyncDone+    | MessageTypeRequestState+    | MessageTypeStepStart+    | MessageTypeQos+    | MessageTypeProgress+    | MessageTypeToc+    | MessageTypeResetTime+    | MessageTypeStreamStart+    | MessageTypeNeedContext+    | MessageTypeHaveContext+    | MessageTypeExtended+    | MessageTypeDeviceAdded+    | MessageTypeDeviceRemoved+    | MessageTypeAny+    | AnotherMessageType Int+    deriving (Show, Eq)++instance Enum MessageType where+    fromEnum MessageTypeUnknown = 0+    fromEnum MessageTypeEos = 1+    fromEnum MessageTypeError = 2+    fromEnum MessageTypeWarning = 4+    fromEnum MessageTypeInfo = 8+    fromEnum MessageTypeTag = 16+    fromEnum MessageTypeBuffering = 32+    fromEnum MessageTypeStateChanged = 64+    fromEnum MessageTypeStateDirty = 128+    fromEnum MessageTypeStepDone = 256+    fromEnum MessageTypeClockProvide = 512+    fromEnum MessageTypeClockLost = 1024+    fromEnum MessageTypeNewClock = 2048+    fromEnum MessageTypeStructureChange = 4096+    fromEnum MessageTypeStreamStatus = 8192+    fromEnum MessageTypeApplication = 16384+    fromEnum MessageTypeElement = 32768+    fromEnum MessageTypeSegmentStart = 65536+    fromEnum MessageTypeSegmentDone = 131072+    fromEnum MessageTypeDurationChanged = 262144+    fromEnum MessageTypeLatency = 524288+    fromEnum MessageTypeAsyncStart = 1048576+    fromEnum MessageTypeAsyncDone = 2097152+    fromEnum MessageTypeRequestState = 4194304+    fromEnum MessageTypeStepStart = 8388608+    fromEnum MessageTypeQos = 16777216+    fromEnum MessageTypeProgress = 33554432+    fromEnum MessageTypeToc = 67108864+    fromEnum MessageTypeResetTime = 134217728+    fromEnum MessageTypeStreamStart = 268435456+    fromEnum MessageTypeNeedContext = 536870912+    fromEnum MessageTypeHaveContext = 1073741824+    fromEnum MessageTypeExtended = 2147483648+    fromEnum MessageTypeDeviceAdded = 2147483649+    fromEnum MessageTypeDeviceRemoved = 2147483650+    fromEnum MessageTypeAny = 4294967295+    fromEnum (AnotherMessageType k) = k++    toEnum 0 = MessageTypeUnknown+    toEnum 1 = MessageTypeEos+    toEnum 2 = MessageTypeError+    toEnum 4 = MessageTypeWarning+    toEnum 8 = MessageTypeInfo+    toEnum 16 = MessageTypeTag+    toEnum 32 = MessageTypeBuffering+    toEnum 64 = MessageTypeStateChanged+    toEnum 128 = MessageTypeStateDirty+    toEnum 256 = MessageTypeStepDone+    toEnum 512 = MessageTypeClockProvide+    toEnum 1024 = MessageTypeClockLost+    toEnum 2048 = MessageTypeNewClock+    toEnum 4096 = MessageTypeStructureChange+    toEnum 8192 = MessageTypeStreamStatus+    toEnum 16384 = MessageTypeApplication+    toEnum 32768 = MessageTypeElement+    toEnum 65536 = MessageTypeSegmentStart+    toEnum 131072 = MessageTypeSegmentDone+    toEnum 262144 = MessageTypeDurationChanged+    toEnum 524288 = MessageTypeLatency+    toEnum 1048576 = MessageTypeAsyncStart+    toEnum 2097152 = MessageTypeAsyncDone+    toEnum 4194304 = MessageTypeRequestState+    toEnum 8388608 = MessageTypeStepStart+    toEnum 16777216 = MessageTypeQos+    toEnum 33554432 = MessageTypeProgress+    toEnum 67108864 = MessageTypeToc+    toEnum 134217728 = MessageTypeResetTime+    toEnum 268435456 = MessageTypeStreamStart+    toEnum 536870912 = MessageTypeNeedContext+    toEnum 1073741824 = MessageTypeHaveContext+    toEnum 2147483648 = MessageTypeExtended+    toEnum 2147483649 = MessageTypeDeviceAdded+    toEnum 2147483650 = MessageTypeDeviceRemoved+    toEnum 4294967295 = MessageTypeAny+    toEnum k = AnotherMessageType k++foreign import ccall "gst_message_type_get_type" c_gst_message_type_get_type :: +    IO GType++instance BoxedEnum MessageType where+    boxedEnumType _ = c_gst_message_type_get_type++instance IsGFlag MessageType++-- Flags MemoryFlags++data MemoryFlags = +      MemoryFlagsReadonly+    | MemoryFlagsNoShare+    | MemoryFlagsZeroPrefixed+    | MemoryFlagsZeroPadded+    | MemoryFlagsPhysicallyContiguous+    | MemoryFlagsNotMappable+    | MemoryFlagsLast+    | AnotherMemoryFlags Int+    deriving (Show, Eq)++instance Enum MemoryFlags where+    fromEnum MemoryFlagsReadonly = 2+    fromEnum MemoryFlagsNoShare = 16+    fromEnum MemoryFlagsZeroPrefixed = 32+    fromEnum MemoryFlagsZeroPadded = 64+    fromEnum MemoryFlagsPhysicallyContiguous = 128+    fromEnum MemoryFlagsNotMappable = 256+    fromEnum MemoryFlagsLast = 1048576+    fromEnum (AnotherMemoryFlags k) = k++    toEnum 2 = MemoryFlagsReadonly+    toEnum 16 = MemoryFlagsNoShare+    toEnum 32 = MemoryFlagsZeroPrefixed+    toEnum 64 = MemoryFlagsZeroPadded+    toEnum 128 = MemoryFlagsPhysicallyContiguous+    toEnum 256 = MemoryFlagsNotMappable+    toEnum 1048576 = MemoryFlagsLast+    toEnum k = AnotherMemoryFlags k++foreign import ccall "gst_memory_flags_get_type" c_gst_memory_flags_get_type :: +    IO GType++instance BoxedEnum MemoryFlags where+    boxedEnumType _ = c_gst_memory_flags_get_type++instance IsGFlag MemoryFlags++-- Flags MapFlags++data MapFlags = +      MapFlagsRead+    | MapFlagsWrite+    | MapFlagsFlagLast+    | AnotherMapFlags Int+    deriving (Show, Eq)++instance Enum MapFlags where+    fromEnum MapFlagsRead = 1+    fromEnum MapFlagsWrite = 2+    fromEnum MapFlagsFlagLast = 65536+    fromEnum (AnotherMapFlags k) = k++    toEnum 1 = MapFlagsRead+    toEnum 2 = MapFlagsWrite+    toEnum 65536 = MapFlagsFlagLast+    toEnum k = AnotherMapFlags k++foreign import ccall "gst_map_flags_get_type" c_gst_map_flags_get_type :: +    IO GType++instance BoxedEnum MapFlags where+    boxedEnumType _ = c_gst_map_flags_get_type++instance IsGFlag MapFlags++-- Flags LockFlags++data LockFlags = +      LockFlagsRead+    | LockFlagsWrite+    | LockFlagsExclusive+    | LockFlagsLast+    | AnotherLockFlags Int+    deriving (Show, Eq)++instance Enum LockFlags where+    fromEnum LockFlagsRead = 1+    fromEnum LockFlagsWrite = 2+    fromEnum LockFlagsExclusive = 4+    fromEnum LockFlagsLast = 256+    fromEnum (AnotherLockFlags k) = k++    toEnum 1 = LockFlagsRead+    toEnum 2 = LockFlagsWrite+    toEnum 4 = LockFlagsExclusive+    toEnum 256 = LockFlagsLast+    toEnum k = AnotherLockFlags k++foreign import ccall "gst_lock_flags_get_type" c_gst_lock_flags_get_type :: +    IO GType++instance BoxedEnum LockFlags where+    boxedEnumType _ = c_gst_lock_flags_get_type++instance IsGFlag LockFlags++-- Flags EventTypeFlags++data EventTypeFlags = +      EventTypeFlagsUpstream+    | EventTypeFlagsDownstream+    | EventTypeFlagsSerialized+    | EventTypeFlagsSticky+    | EventTypeFlagsStickyMulti+    | AnotherEventTypeFlags Int+    deriving (Show, Eq)++instance Enum EventTypeFlags where+    fromEnum EventTypeFlagsUpstream = 1+    fromEnum EventTypeFlagsDownstream = 2+    fromEnum EventTypeFlagsSerialized = 4+    fromEnum EventTypeFlagsSticky = 8+    fromEnum EventTypeFlagsStickyMulti = 16+    fromEnum (AnotherEventTypeFlags k) = k++    toEnum 1 = EventTypeFlagsUpstream+    toEnum 2 = EventTypeFlagsDownstream+    toEnum 4 = EventTypeFlagsSerialized+    toEnum 8 = EventTypeFlagsSticky+    toEnum 16 = EventTypeFlagsStickyMulti+    toEnum k = AnotherEventTypeFlags k++foreign import ccall "gst_event_type_flags_get_type" c_gst_event_type_flags_get_type :: +    IO GType++instance BoxedEnum EventTypeFlags where+    boxedEnumType _ = c_gst_event_type_flags_get_type++instance IsGFlag EventTypeFlags++-- Flags ElementFlags++data ElementFlags = +      ElementFlagsLockedState+    | ElementFlagsSink+    | ElementFlagsSource+    | ElementFlagsProvideClock+    | ElementFlagsRequireClock+    | ElementFlagsIndexable+    | ElementFlagsLast+    | AnotherElementFlags Int+    deriving (Show, Eq)++instance Enum ElementFlags where+    fromEnum ElementFlagsLockedState = 16+    fromEnum ElementFlagsSink = 32+    fromEnum ElementFlagsSource = 64+    fromEnum ElementFlagsProvideClock = 128+    fromEnum ElementFlagsRequireClock = 256+    fromEnum ElementFlagsIndexable = 512+    fromEnum ElementFlagsLast = 16384+    fromEnum (AnotherElementFlags k) = k++    toEnum 16 = ElementFlagsLockedState+    toEnum 32 = ElementFlagsSink+    toEnum 64 = ElementFlagsSource+    toEnum 128 = ElementFlagsProvideClock+    toEnum 256 = ElementFlagsRequireClock+    toEnum 512 = ElementFlagsIndexable+    toEnum 16384 = ElementFlagsLast+    toEnum k = AnotherElementFlags k++foreign import ccall "gst_element_flags_get_type" c_gst_element_flags_get_type :: +    IO GType++instance BoxedEnum ElementFlags where+    boxedEnumType _ = c_gst_element_flags_get_type++instance IsGFlag ElementFlags++-- Flags DebugGraphDetails++data DebugGraphDetails = +      DebugGraphDetailsMediaType+    | DebugGraphDetailsCapsDetails+    | DebugGraphDetailsNonDefaultParams+    | DebugGraphDetailsStates+    | DebugGraphDetailsFullParams+    | DebugGraphDetailsAll+    | DebugGraphDetailsVerbose+    | AnotherDebugGraphDetails Int+    deriving (Show, Eq)++instance Enum DebugGraphDetails where+    fromEnum DebugGraphDetailsMediaType = 1+    fromEnum DebugGraphDetailsCapsDetails = 2+    fromEnum DebugGraphDetailsNonDefaultParams = 4+    fromEnum DebugGraphDetailsStates = 8+    fromEnum DebugGraphDetailsFullParams = 16+    fromEnum DebugGraphDetailsAll = 15+    fromEnum DebugGraphDetailsVerbose = -1+    fromEnum (AnotherDebugGraphDetails k) = k++    toEnum -1 = DebugGraphDetailsVerbose+    toEnum 1 = DebugGraphDetailsMediaType+    toEnum 2 = DebugGraphDetailsCapsDetails+    toEnum 4 = DebugGraphDetailsNonDefaultParams+    toEnum 8 = DebugGraphDetailsStates+    toEnum 15 = DebugGraphDetailsAll+    toEnum 16 = DebugGraphDetailsFullParams+    toEnum k = AnotherDebugGraphDetails k++foreign import ccall "gst_debug_graph_details_get_type" c_gst_debug_graph_details_get_type :: +    IO GType++instance BoxedEnum DebugGraphDetails where+    boxedEnumType _ = c_gst_debug_graph_details_get_type++instance IsGFlag DebugGraphDetails++-- Flags ClockFlags++data ClockFlags = +      ClockFlagsCanDoSingleSync+    | ClockFlagsCanDoSingleAsync+    | ClockFlagsCanDoPeriodicSync+    | ClockFlagsCanDoPeriodicAsync+    | ClockFlagsCanSetResolution+    | ClockFlagsCanSetMaster+    | ClockFlagsNeedsStartupSync+    | ClockFlagsLast+    | AnotherClockFlags Int+    deriving (Show, Eq)++instance Enum ClockFlags where+    fromEnum ClockFlagsCanDoSingleSync = 16+    fromEnum ClockFlagsCanDoSingleAsync = 32+    fromEnum ClockFlagsCanDoPeriodicSync = 64+    fromEnum ClockFlagsCanDoPeriodicAsync = 128+    fromEnum ClockFlagsCanSetResolution = 256+    fromEnum ClockFlagsCanSetMaster = 512+    fromEnum ClockFlagsNeedsStartupSync = 1024+    fromEnum ClockFlagsLast = 4096+    fromEnum (AnotherClockFlags k) = k++    toEnum 16 = ClockFlagsCanDoSingleSync+    toEnum 32 = ClockFlagsCanDoSingleAsync+    toEnum 64 = ClockFlagsCanDoPeriodicSync+    toEnum 128 = ClockFlagsCanDoPeriodicAsync+    toEnum 256 = ClockFlagsCanSetResolution+    toEnum 512 = ClockFlagsCanSetMaster+    toEnum 1024 = ClockFlagsNeedsStartupSync+    toEnum 4096 = ClockFlagsLast+    toEnum k = AnotherClockFlags k++foreign import ccall "gst_clock_flags_get_type" c_gst_clock_flags_get_type :: +    IO GType++instance BoxedEnum ClockFlags where+    boxedEnumType _ = c_gst_clock_flags_get_type++instance IsGFlag ClockFlags++-- Flags CapsFlags++data CapsFlags = +      CapsFlagsAny+    | AnotherCapsFlags Int+    deriving (Show, Eq)++instance Enum CapsFlags where+    fromEnum CapsFlagsAny = 16+    fromEnum (AnotherCapsFlags k) = k++    toEnum 16 = CapsFlagsAny+    toEnum k = AnotherCapsFlags k++foreign import ccall "gst_caps_flags_get_type" c_gst_caps_flags_get_type :: +    IO GType++instance BoxedEnum CapsFlags where+    boxedEnumType _ = c_gst_caps_flags_get_type++instance IsGFlag CapsFlags++-- Flags BusFlags++data BusFlags = +      BusFlagsFlushing+    | BusFlagsFlagLast+    | AnotherBusFlags Int+    deriving (Show, Eq)++instance Enum BusFlags where+    fromEnum BusFlagsFlushing = 16+    fromEnum BusFlagsFlagLast = 32+    fromEnum (AnotherBusFlags k) = k++    toEnum 16 = BusFlagsFlushing+    toEnum 32 = BusFlagsFlagLast+    toEnum k = AnotherBusFlags k++foreign import ccall "gst_bus_flags_get_type" c_gst_bus_flags_get_type :: +    IO GType++instance BoxedEnum BusFlags where+    boxedEnumType _ = c_gst_bus_flags_get_type++instance IsGFlag BusFlags++-- Flags BufferPoolAcquireFlags++data BufferPoolAcquireFlags = +      BufferPoolAcquireFlagsNone+    | BufferPoolAcquireFlagsKeyUnit+    | BufferPoolAcquireFlagsDontwait+    | BufferPoolAcquireFlagsDiscont+    | BufferPoolAcquireFlagsLast+    | AnotherBufferPoolAcquireFlags Int+    deriving (Show, Eq)++instance Enum BufferPoolAcquireFlags where+    fromEnum BufferPoolAcquireFlagsNone = 0+    fromEnum BufferPoolAcquireFlagsKeyUnit = 1+    fromEnum BufferPoolAcquireFlagsDontwait = 2+    fromEnum BufferPoolAcquireFlagsDiscont = 4+    fromEnum BufferPoolAcquireFlagsLast = 65536+    fromEnum (AnotherBufferPoolAcquireFlags k) = k++    toEnum 0 = BufferPoolAcquireFlagsNone+    toEnum 1 = BufferPoolAcquireFlagsKeyUnit+    toEnum 2 = BufferPoolAcquireFlagsDontwait+    toEnum 4 = BufferPoolAcquireFlagsDiscont+    toEnum 65536 = BufferPoolAcquireFlagsLast+    toEnum k = AnotherBufferPoolAcquireFlags k++foreign import ccall "gst_buffer_pool_acquire_flags_get_type" c_gst_buffer_pool_acquire_flags_get_type :: +    IO GType++instance BoxedEnum BufferPoolAcquireFlags where+    boxedEnumType _ = c_gst_buffer_pool_acquire_flags_get_type++instance IsGFlag BufferPoolAcquireFlags++-- Flags BufferFlags++data BufferFlags = +      BufferFlagsLive+    | BufferFlagsDecodeOnly+    | BufferFlagsDiscont+    | BufferFlagsResync+    | BufferFlagsCorrupted+    | BufferFlagsMarker+    | BufferFlagsHeader+    | BufferFlagsGap+    | BufferFlagsDroppable+    | BufferFlagsDeltaUnit+    | BufferFlagsTagMemory+    | BufferFlagsSyncAfter+    | BufferFlagsLast+    | AnotherBufferFlags Int+    deriving (Show, Eq)++instance Enum BufferFlags where+    fromEnum BufferFlagsLive = 16+    fromEnum BufferFlagsDecodeOnly = 32+    fromEnum BufferFlagsDiscont = 64+    fromEnum BufferFlagsResync = 128+    fromEnum BufferFlagsCorrupted = 256+    fromEnum BufferFlagsMarker = 512+    fromEnum BufferFlagsHeader = 1024+    fromEnum BufferFlagsGap = 2048+    fromEnum BufferFlagsDroppable = 4096+    fromEnum BufferFlagsDeltaUnit = 8192+    fromEnum BufferFlagsTagMemory = 16384+    fromEnum BufferFlagsSyncAfter = 32768+    fromEnum BufferFlagsLast = 1048576+    fromEnum (AnotherBufferFlags k) = k++    toEnum 16 = BufferFlagsLive+    toEnum 32 = BufferFlagsDecodeOnly+    toEnum 64 = BufferFlagsDiscont+    toEnum 128 = BufferFlagsResync+    toEnum 256 = BufferFlagsCorrupted+    toEnum 512 = BufferFlagsMarker+    toEnum 1024 = BufferFlagsHeader+    toEnum 2048 = BufferFlagsGap+    toEnum 4096 = BufferFlagsDroppable+    toEnum 8192 = BufferFlagsDeltaUnit+    toEnum 16384 = BufferFlagsTagMemory+    toEnum 32768 = BufferFlagsSyncAfter+    toEnum 1048576 = BufferFlagsLast+    toEnum k = AnotherBufferFlags k++foreign import ccall "gst_buffer_flags_get_type" c_gst_buffer_flags_get_type :: +    IO GType++instance BoxedEnum BufferFlags where+    boxedEnumType _ = c_gst_buffer_flags_get_type++instance IsGFlag BufferFlags++-- Flags BufferCopyFlags++data BufferCopyFlags = +      BufferCopyFlagsNone+    | BufferCopyFlagsFlags+    | BufferCopyFlagsTimestamps+    | BufferCopyFlagsMeta+    | BufferCopyFlagsMemory+    | BufferCopyFlagsMerge+    | BufferCopyFlagsDeep+    | AnotherBufferCopyFlags Int+    deriving (Show, Eq)++instance Enum BufferCopyFlags where+    fromEnum BufferCopyFlagsNone = 0+    fromEnum BufferCopyFlagsFlags = 1+    fromEnum BufferCopyFlagsTimestamps = 2+    fromEnum BufferCopyFlagsMeta = 4+    fromEnum BufferCopyFlagsMemory = 8+    fromEnum BufferCopyFlagsMerge = 16+    fromEnum BufferCopyFlagsDeep = 32+    fromEnum (AnotherBufferCopyFlags k) = k++    toEnum 0 = BufferCopyFlagsNone+    toEnum 1 = BufferCopyFlagsFlags+    toEnum 2 = BufferCopyFlagsTimestamps+    toEnum 4 = BufferCopyFlagsMeta+    toEnum 8 = BufferCopyFlagsMemory+    toEnum 16 = BufferCopyFlagsMerge+    toEnum 32 = BufferCopyFlagsDeep+    toEnum k = AnotherBufferCopyFlags k++foreign import ccall "gst_buffer_copy_flags_get_type" c_gst_buffer_copy_flags_get_type :: +    IO GType++instance BoxedEnum BufferCopyFlags where+    boxedEnumType _ = c_gst_buffer_copy_flags_get_type++instance IsGFlag BufferCopyFlags++-- Flags BinFlags++data BinFlags = +      BinFlagsNoResync+    | BinFlagsLast+    | AnotherBinFlags Int+    deriving (Show, Eq)++instance Enum BinFlags where+    fromEnum BinFlagsNoResync = 16384+    fromEnum BinFlagsLast = 524288+    fromEnum (AnotherBinFlags k) = k++    toEnum 16384 = BinFlagsNoResync+    toEnum 524288 = BinFlagsLast+    toEnum k = AnotherBinFlags k++foreign import ccall "gst_bin_flags_get_type" c_gst_bin_flags_get_type :: +    IO GType++instance BoxedEnum BinFlags where+    boxedEnumType _ = c_gst_bin_flags_get_type++instance IsGFlag BinFlags++-- Flags AllocatorFlags++data AllocatorFlags = +      AllocatorFlagsCustomAlloc+    | AllocatorFlagsLast+    | AnotherAllocatorFlags Int+    deriving (Show, Eq)++instance Enum AllocatorFlags where+    fromEnum AllocatorFlagsCustomAlloc = 16+    fromEnum AllocatorFlagsLast = 1048576+    fromEnum (AnotherAllocatorFlags k) = k++    toEnum 16 = AllocatorFlagsCustomAlloc+    toEnum 1048576 = AllocatorFlagsLast+    toEnum k = AnotherAllocatorFlags k++foreign import ccall "gst_allocator_flags_get_type" c_gst_allocator_flags_get_type :: +    IO GType++instance BoxedEnum AllocatorFlags where+    boxedEnumType _ = c_gst_allocator_flags_get_type++instance IsGFlag AllocatorFlags++
+ GI/Gst/Functions.hs view
@@ -0,0 +1,3974 @@+++{- |+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.Functions+    ( ++ -- * Methods+-- ** debugAddLogFunction+    debugAddLogFunction                     ,+++-- ** debugBinToDotData+    debugBinToDotData                       ,+++-- ** debugBinToDotFile+    debugBinToDotFile                       ,+++-- ** debugBinToDotFileWithTs+    debugBinToDotFileWithTs                 ,+++-- ** debugConstructTermColor+    debugConstructTermColor                 ,+++-- ** debugConstructWinColor+    debugConstructWinColor                  ,+++-- ** debugGetAllCategories+    debugGetAllCategories                   ,+++-- ** debugGetColorMode+    debugGetColorMode                       ,+++-- ** debugGetDefaultThreshold+    debugGetDefaultThreshold                ,+++-- ** debugIsActive+    debugIsActive                           ,+++-- ** debugIsColored+    debugIsColored                          ,+++-- ** debugLogDefault+    debugLogDefault                         ,+++-- ** debugPrintStackTrace+    debugPrintStackTrace                    ,+++-- ** debugRemoveLogFunction+    debugRemoveLogFunction                  ,+++-- ** debugRemoveLogFunctionByData+    debugRemoveLogFunctionByData            ,+++-- ** debugSetActive+    debugSetActive                          ,+++-- ** debugSetColorMode+    debugSetColorMode                       ,+++-- ** debugSetColorModeFromString+    debugSetColorModeFromString             ,+++-- ** debugSetColored+    debugSetColored                         ,+++-- ** debugSetDefaultThreshold+    debugSetDefaultThreshold                ,+++-- ** debugSetThresholdForName+    debugSetThresholdForName                ,+++-- ** debugSetThresholdFromString+    debugSetThresholdFromString             ,+++-- ** debugUnsetThresholdForName+    debugUnsetThresholdForName              ,+++-- ** deinit+    deinit                                  ,+++-- ** errorGetMessage+    errorGetMessage                         ,+++-- ** filenameToUri+    filenameToUri                           ,+++-- ** flowGetName+    flowGetName                             ,+++-- ** flowToQuark+    flowToQuark                             ,+++-- ** formatsContains+    formatsContains                         ,+++-- ** isCapsFeatures+    isCapsFeatures                          ,+++-- ** isInitialized+    isInitialized                           ,+++-- ** paramSpecFraction+    paramSpecFraction                       ,+++-- ** parentBufferMetaApiGetType+    parentBufferMetaApiGetType              ,+++-- ** parseBinFromDescription+    parseBinFromDescription                 ,+++-- ** parseBinFromDescriptionFull+    parseBinFromDescriptionFull             ,+++-- ** parseLaunch+    parseLaunch                             ,+++-- ** parseLaunchFull+    parseLaunchFull                         ,+++-- ** parseLaunchv+    parseLaunchv                            ,+++-- ** parseLaunchvFull+    parseLaunchvFull                        ,+++-- ** protectionMetaApiGetType+    protectionMetaApiGetType                ,+++-- ** protectionSelectSystem+    protectionSelectSystem                  ,+++-- ** segtrapIsEnabled+    segtrapIsEnabled                        ,+++-- ** segtrapSetEnabled+    segtrapSetEnabled                       ,+++-- ** staticCapsGetType+    staticCapsGetType                       ,+++-- ** staticPadTemplateGetType+    staticPadTemplateGetType                ,+++-- ** tagExists+    tagExists                               ,+++-- ** tagGetDescription+    tagGetDescription                       ,+++-- ** tagGetFlag+    tagGetFlag                              ,+++-- ** tagGetNick+    tagGetNick                              ,+++-- ** tagGetType+    tagGetType                              ,+++-- ** tagIsFixed+    tagIsFixed                              ,+++-- ** tagMergeStringsWithComma+    tagMergeStringsWithComma                ,+++-- ** tagMergeUseFirst+    tagMergeUseFirst                        ,+++-- ** tagRegister+    tagRegister                             ,+++-- ** tagRegisterStatic+    tagRegisterStatic                       ,+++-- ** typeFindGetType+    typeFindGetType                         ,+++-- ** updateRegistry+    updateRegistry                          ,+++-- ** utilArrayBinarySearch+    utilArrayBinarySearch                   ,+++-- ** utilDoubleToFraction+    utilDoubleToFraction                    ,+++-- ** utilDumpMem+    utilDumpMem                             ,+++-- ** utilFractionAdd+    utilFractionAdd                         ,+++-- ** utilFractionCompare+    utilFractionCompare                     ,+++-- ** utilFractionMultiply+    utilFractionMultiply                    ,+++-- ** utilFractionToDouble+    utilFractionToDouble                    ,+++-- ** utilGdoubleToGuint64+    utilGdoubleToGuint64                    ,+++-- ** utilGetTimestamp+    utilGetTimestamp                        ,+++-- ** utilGreatestCommonDivisor+    utilGreatestCommonDivisor               ,+++-- ** utilGreatestCommonDivisorInt64+    utilGreatestCommonDivisorInt64          ,+++-- ** utilGroupIdNext+    utilGroupIdNext                         ,+++-- ** utilGuint64ToGdouble+    utilGuint64ToGdouble                    ,+++-- ** utilSeqnumCompare+    utilSeqnumCompare                       ,+++-- ** utilSeqnumNext+    utilSeqnumNext                          ,+++-- ** utilSetObjectArg+    utilSetObjectArg                        ,+++-- ** utilSetValueFromString+    utilSetValueFromString                  ,+++-- ** utilUint64Scale+    utilUint64Scale                         ,+++-- ** utilUint64ScaleCeil+    utilUint64ScaleCeil                     ,+++-- ** utilUint64ScaleInt+    utilUint64ScaleInt                      ,+++-- ** utilUint64ScaleIntCeil+    utilUint64ScaleIntCeil                  ,+++-- ** utilUint64ScaleIntRound+    utilUint64ScaleIntRound                 ,+++-- ** utilUint64ScaleRound+    utilUint64ScaleRound                    ,+++-- ** valueCanCompare+    valueCanCompare                         ,+++-- ** valueCanIntersect+    valueCanIntersect                       ,+++-- ** valueCanSubtract+    valueCanSubtract                        ,+++-- ** valueCanUnion+    valueCanUnion                           ,+++-- ** valueCompare+    valueCompare                            ,+++-- ** valueDeserialize+    valueDeserialize                        ,+++-- ** valueFixate+    valueFixate                             ,+++-- ** valueFractionMultiply+    valueFractionMultiply                   ,+++-- ** valueFractionSubtract+    valueFractionSubtract                   ,+++-- ** valueGetBitmask+    valueGetBitmask                         ,+++-- ** valueGetCaps+    valueGetCaps                            ,+++-- ** valueGetCapsFeatures+    valueGetCapsFeatures                    ,+++-- ** valueGetDoubleRangeMax+    valueGetDoubleRangeMax                  ,+++-- ** valueGetDoubleRangeMin+    valueGetDoubleRangeMin                  ,+++-- ** valueGetFlagsetFlags+    valueGetFlagsetFlags                    ,+++-- ** valueGetFlagsetMask+    valueGetFlagsetMask                     ,+++-- ** valueGetFractionDenominator+    valueGetFractionDenominator             ,+++-- ** valueGetFractionNumerator+    valueGetFractionNumerator               ,+++-- ** valueGetFractionRangeMax+    valueGetFractionRangeMax                ,+++-- ** valueGetFractionRangeMin+    valueGetFractionRangeMin                ,+++-- ** valueGetInt64RangeMax+    valueGetInt64RangeMax                   ,+++-- ** valueGetInt64RangeMin+    valueGetInt64RangeMin                   ,+++-- ** valueGetInt64RangeStep+    valueGetInt64RangeStep                  ,+++-- ** valueGetIntRangeMax+    valueGetIntRangeMax                     ,+++-- ** valueGetIntRangeMin+    valueGetIntRangeMin                     ,+++-- ** valueGetIntRangeStep+    valueGetIntRangeStep                    ,+++-- ** valueGetStructure+    valueGetStructure                       ,+++-- ** valueInitAndCopy+    valueInitAndCopy                        ,+++-- ** valueIntersect+    valueIntersect                          ,+++-- ** valueIsFixed+    valueIsFixed                            ,+++-- ** valueIsSubset+    valueIsSubset                           ,+++-- ** valueRegister+    valueRegister                           ,+++-- ** valueSerialize+    valueSerialize                          ,+++-- ** valueSetBitmask+    valueSetBitmask                         ,+++-- ** valueSetCaps+    valueSetCaps                            ,+++-- ** valueSetCapsFeatures+    valueSetCapsFeatures                    ,+++-- ** valueSetDoubleRange+    valueSetDoubleRange                     ,+++-- ** valueSetFlagset+    valueSetFlagset                         ,+++-- ** valueSetFraction+    valueSetFraction                        ,+++-- ** valueSetFractionRange+    valueSetFractionRange                   ,+++-- ** valueSetFractionRangeFull+    valueSetFractionRangeFull               ,+++-- ** valueSetInt64Range+    valueSetInt64Range                      ,+++-- ** valueSetInt64RangeStep+    valueSetInt64RangeStep                  ,+++-- ** valueSetIntRange+    valueSetIntRange                        ,+++-- ** valueSetIntRangeStep+    valueSetIntRangeStep                    ,+++-- ** valueSetStructure+    valueSetStructure                       ,+++-- ** valueSubtract+    valueSubtract                           ,+++-- ** valueUnion+    valueUnion                              ,+++-- ** version+    version                                 ,+++-- ** versionString+    versionString                           ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++-- function gst_version_string+-- Args : []+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_version_string" gst_version_string :: +    IO CString+++versionString ::+    (MonadIO m) =>+    m T.Text                                -- result+versionString  = liftIO $ do+    result <- gst_version_string+    checkUnexpectedReturnNULL "gst_version_string" result+    result' <- cstringToText result+    freeMem result+    return result'+++-- function gst_version+-- Args : [Arg {argCName = "major", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minor", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "micro", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nano", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_version" gst_version :: +    Ptr Word32 ->                           -- major : TBasicType TUInt32+    Ptr Word32 ->                           -- minor : TBasicType TUInt32+    Ptr Word32 ->                           -- micro : TBasicType TUInt32+    Ptr Word32 ->                           -- nano : TBasicType TUInt32+    IO ()+++version ::+    (MonadIO m) =>+    m (Word32,Word32,Word32,Word32)         -- result+version  = liftIO $ do+    major <- allocMem :: IO (Ptr Word32)+    minor <- allocMem :: IO (Ptr Word32)+    micro <- allocMem :: IO (Ptr Word32)+    nano <- allocMem :: IO (Ptr Word32)+    gst_version major minor micro nano+    major' <- peek major+    minor' <- peek minor+    micro' <- peek micro+    nano' <- peek nano+    freeMem major+    freeMem minor+    freeMem micro+    freeMem nano+    return (major', minor', micro', nano')+++-- function gst_value_union+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_union" gst_value_union :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"+    IO CInt+++valueUnion ::+    (MonadIO m) =>+    GValue                                  -- value1+    -> GValue                               -- value2+    -> m (Bool,GValue)                      -- result+valueUnion value1 value2 = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let value1' = unsafeManagedPtrGetPtr value1+    let value2' = unsafeManagedPtrGetPtr value2+    result <- gst_value_union dest value1' value2'+    let result' = (/= 0) result+    dest' <- (wrapBoxed GValue) dest+    touchManagedPtr value1+    touchManagedPtr value2+    return (result', dest')+++-- function gst_value_subtract+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "minuend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_subtract" gst_value_subtract :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- minuend : TInterface "GObject" "Value"+    Ptr GValue ->                           -- subtrahend : TInterface "GObject" "Value"+    IO CInt+++valueSubtract ::+    (MonadIO m) =>+    GValue                                  -- minuend+    -> GValue                               -- subtrahend+    -> m (Bool,GValue)                      -- result+valueSubtract minuend subtrahend = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let minuend' = unsafeManagedPtrGetPtr minuend+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend+    result <- gst_value_subtract dest minuend' subtrahend'+    let result' = (/= 0) result+    dest' <- (wrapBoxed GValue) dest+    touchManagedPtr minuend+    touchManagedPtr subtrahend+    return (result', dest')+++-- function gst_value_set_structure+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_structure" gst_value_set_structure :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO ()+++valueSetStructure ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Structure                            -- structure+    -> m ()                                 -- result+valueSetStructure value structure = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    let structure' = unsafeManagedPtrGetPtr structure+    gst_value_set_structure value' structure'+    touchManagedPtr value+    touchManagedPtr structure+    return ()+++-- function gst_value_set_int_range_step+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "step", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_int_range_step" gst_value_set_int_range_step :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Int32 ->                                -- start : TBasicType TInt32+    Int32 ->                                -- end : TBasicType TInt32+    Int32 ->                                -- step : TBasicType TInt32+    IO ()+++valueSetIntRangeStep ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Int32                                -- start+    -> Int32                                -- end+    -> Int32                                -- step+    -> m ()                                 -- result+valueSetIntRangeStep value start end step = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_int_range_step value' start end step+    touchManagedPtr value+    return ()+++-- function gst_value_set_int_range+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_int_range" gst_value_set_int_range :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Int32 ->                                -- start : TBasicType TInt32+    Int32 ->                                -- end : TBasicType TInt32+    IO ()+++valueSetIntRange ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Int32                                -- start+    -> Int32                                -- end+    -> m ()                                 -- result+valueSetIntRange value start end = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_int_range value' start end+    touchManagedPtr value+    return ()+++-- function gst_value_set_int64_range_step+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "step", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_int64_range_step" gst_value_set_int64_range_step :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Int64 ->                                -- start : TBasicType TInt64+    Int64 ->                                -- end : TBasicType TInt64+    Int64 ->                                -- step : TBasicType TInt64+    IO ()+++valueSetInt64RangeStep ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Int64                                -- start+    -> Int64                                -- end+    -> Int64                                -- step+    -> m ()                                 -- result+valueSetInt64RangeStep value start end step = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_int64_range_step value' start end step+    touchManagedPtr value+    return ()+++-- function gst_value_set_int64_range+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_int64_range" gst_value_set_int64_range :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Int64 ->                                -- start : TBasicType TInt64+    Int64 ->                                -- end : TBasicType TInt64+    IO ()+++valueSetInt64Range ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Int64                                -- start+    -> Int64                                -- end+    -> m ()                                 -- result+valueSetInt64Range value start end = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_int64_range value' start end+    touchManagedPtr value+    return ()+++-- function gst_value_set_fraction_range_full+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "numerator_start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denominator_start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "numerator_end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denominator_end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_fraction_range_full" gst_value_set_fraction_range_full :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Int32 ->                                -- numerator_start : TBasicType TInt32+    Int32 ->                                -- denominator_start : TBasicType TInt32+    Int32 ->                                -- numerator_end : TBasicType TInt32+    Int32 ->                                -- denominator_end : TBasicType TInt32+    IO ()+++valueSetFractionRangeFull ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Int32                                -- numeratorStart+    -> Int32                                -- denominatorStart+    -> Int32                                -- numeratorEnd+    -> Int32                                -- denominatorEnd+    -> m ()                                 -- result+valueSetFractionRangeFull value numeratorStart denominatorStart numeratorEnd denominatorEnd = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_fraction_range_full value' numeratorStart denominatorStart numeratorEnd denominatorEnd+    touchManagedPtr value+    return ()+++-- function gst_value_set_fraction_range+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_fraction_range" gst_value_set_fraction_range :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Ptr GValue ->                           -- start : TInterface "GObject" "Value"+    Ptr GValue ->                           -- end : TInterface "GObject" "Value"+    IO ()+++valueSetFractionRange ::+    (MonadIO m) =>+    GValue                                  -- value+    -> GValue                               -- start+    -> GValue                               -- end+    -> m ()                                 -- result+valueSetFractionRange value start end = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    let start' = unsafeManagedPtrGetPtr start+    let end' = unsafeManagedPtrGetPtr end+    gst_value_set_fraction_range value' start' end'+    touchManagedPtr value+    touchManagedPtr start+    touchManagedPtr end+    return ()+++-- function gst_value_set_fraction+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "numerator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denominator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_fraction" gst_value_set_fraction :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Int32 ->                                -- numerator : TBasicType TInt32+    Int32 ->                                -- denominator : TBasicType TInt32+    IO ()+++valueSetFraction ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Int32                                -- numerator+    -> Int32                                -- denominator+    -> m ()                                 -- result+valueSetFraction value numerator denominator = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_fraction value' numerator denominator+    touchManagedPtr value+    return ()+++-- function gst_value_set_flagset+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_flagset" gst_value_set_flagset :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Word32 ->                               -- flags : TBasicType TUInt32+    Word32 ->                               -- mask : TBasicType TUInt32+    IO ()+++valueSetFlagset ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Word32                               -- flags+    -> Word32                               -- mask+    -> m ()                                 -- result+valueSetFlagset value flags mask = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_flagset value' flags mask+    touchManagedPtr value+    return ()+++-- function gst_value_set_double_range+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_double_range" gst_value_set_double_range :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    CDouble ->                              -- start : TBasicType TDouble+    CDouble ->                              -- end : TBasicType TDouble+    IO ()+++valueSetDoubleRange ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Double                               -- start+    -> Double                               -- end+    -> m ()                                 -- result+valueSetDoubleRange value start end = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    let start' = realToFrac start+    let end' = realToFrac end+    gst_value_set_double_range value' start' end'+    touchManagedPtr value+    return ()+++-- function gst_value_set_caps_features+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_caps_features" gst_value_set_caps_features :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"+    IO ()+++valueSetCapsFeatures ::+    (MonadIO m) =>+    GValue                                  -- value+    -> CapsFeatures                         -- features+    -> m ()                                 -- result+valueSetCapsFeatures value features = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    let features' = unsafeManagedPtrGetPtr features+    gst_value_set_caps_features value' features'+    touchManagedPtr value+    touchManagedPtr features+    return ()+++-- function gst_value_set_caps+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_caps" gst_value_set_caps :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO ()+++valueSetCaps ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Caps                                 -- caps+    -> m ()                                 -- result+valueSetCaps value caps = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    let caps' = unsafeManagedPtrGetPtr caps+    gst_value_set_caps value' caps'+    touchManagedPtr value+    touchManagedPtr caps+    return ()+++-- function gst_value_set_bitmask+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bitmask", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_set_bitmask" gst_value_set_bitmask :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    Word64 ->                               -- bitmask : TBasicType TUInt64+    IO ()+++valueSetBitmask ::+    (MonadIO m) =>+    GValue                                  -- value+    -> Word64                               -- bitmask+    -> m ()                                 -- result+valueSetBitmask value bitmask = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    gst_value_set_bitmask value' bitmask+    touchManagedPtr value+    return ()+++-- function gst_value_serialize+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_serialize" gst_value_serialize :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO CString+++valueSerialize ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m T.Text                             -- result+valueSerialize value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_serialize value'+    checkUnexpectedReturnNULL "gst_value_serialize" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr value+    return result'+++-- function gst_value_register+-- Args : [Arg {argCName = "table", argType = TInterface "Gst" "ValueTable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_register" gst_value_register :: +    Ptr ValueTable ->                       -- table : TInterface "Gst" "ValueTable"+    IO ()+++valueRegister ::+    (MonadIO m) =>+    ValueTable                              -- table+    -> m ()                                 -- result+valueRegister table = liftIO $ do+    let table' = unsafeManagedPtrGetPtr table+    gst_value_register table'+    touchManagedPtr table+    return ()+++-- function gst_value_is_subset+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_is_subset" gst_value_is_subset :: +    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"+    IO CInt+++valueIsSubset ::+    (MonadIO m) =>+    GValue                                  -- value1+    -> GValue                               -- value2+    -> m Bool                               -- result+valueIsSubset value1 value2 = liftIO $ do+    let value1' = unsafeManagedPtrGetPtr value1+    let value2' = unsafeManagedPtrGetPtr value2+    result <- gst_value_is_subset value1' value2'+    let result' = (/= 0) result+    touchManagedPtr value1+    touchManagedPtr value2+    return result'+++-- function gst_value_is_fixed+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_is_fixed" gst_value_is_fixed :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO CInt+++valueIsFixed ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Bool                               -- result+valueIsFixed value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_is_fixed value'+    let result' = (/= 0) result+    touchManagedPtr value+    return result'+++-- function gst_value_intersect+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything},Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_intersect" gst_value_intersect :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"+    IO CInt+++valueIntersect ::+    (MonadIO m) =>+    GValue                                  -- value1+    -> GValue                               -- value2+    -> m (Bool,GValue)                      -- result+valueIntersect value1 value2 = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let value1' = unsafeManagedPtrGetPtr value1+    let value2' = unsafeManagedPtrGetPtr value2+    result <- gst_value_intersect dest value1' value2'+    let result' = (/= 0) result+    dest' <- (wrapBoxed GValue) dest+    touchManagedPtr value1+    touchManagedPtr value2+    return (result', dest')+++-- function gst_value_init_and_copy+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_init_and_copy" gst_value_init_and_copy :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"+    IO ()+++valueInitAndCopy ::+    (MonadIO m) =>+    GValue                                  -- src+    -> m (GValue)                           -- result+valueInitAndCopy src = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let src' = unsafeManagedPtrGetPtr src+    gst_value_init_and_copy dest src'+    dest' <- (wrapBoxed GValue) dest+    touchManagedPtr src+    return dest'+++-- function gst_value_get_structure+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_structure" gst_value_get_structure :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO (Ptr Structure)+++valueGetStructure ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Structure                          -- result+valueGetStructure value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_structure value'+    checkUnexpectedReturnNULL "gst_value_get_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr value+    return result'+++-- function gst_value_get_int_range_step+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_int_range_step" gst_value_get_int_range_step :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int32+++valueGetIntRangeStep ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int32                              -- result+valueGetIntRangeStep value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_int_range_step value'+    touchManagedPtr value+    return result+++-- function gst_value_get_int_range_min+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_int_range_min" gst_value_get_int_range_min :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int32+++valueGetIntRangeMin ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int32                              -- result+valueGetIntRangeMin value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_int_range_min value'+    touchManagedPtr value+    return result+++-- function gst_value_get_int_range_max+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_int_range_max" gst_value_get_int_range_max :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int32+++valueGetIntRangeMax ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int32                              -- result+valueGetIntRangeMax value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_int_range_max value'+    touchManagedPtr value+    return result+++-- function gst_value_get_int64_range_step+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_int64_range_step" gst_value_get_int64_range_step :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int64+++valueGetInt64RangeStep ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int64                              -- result+valueGetInt64RangeStep value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_int64_range_step value'+    touchManagedPtr value+    return result+++-- function gst_value_get_int64_range_min+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_int64_range_min" gst_value_get_int64_range_min :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int64+++valueGetInt64RangeMin ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int64                              -- result+valueGetInt64RangeMin value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_int64_range_min value'+    touchManagedPtr value+    return result+++-- function gst_value_get_int64_range_max+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_int64_range_max" gst_value_get_int64_range_max :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int64+++valueGetInt64RangeMax ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int64                              -- result+valueGetInt64RangeMax value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_int64_range_max value'+    touchManagedPtr value+    return result+++-- function gst_value_get_fraction_range_min+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_fraction_range_min" gst_value_get_fraction_range_min :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO (Ptr GValue)+++valueGetFractionRangeMin ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m GValue                             -- result+valueGetFractionRangeMin value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_fraction_range_min value'+    checkUnexpectedReturnNULL "gst_value_get_fraction_range_min" result+    result' <- (newBoxed GValue) result+    touchManagedPtr value+    return result'+++-- function gst_value_get_fraction_range_max+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_fraction_range_max" gst_value_get_fraction_range_max :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO (Ptr GValue)+++valueGetFractionRangeMax ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m GValue                             -- result+valueGetFractionRangeMax value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_fraction_range_max value'+    checkUnexpectedReturnNULL "gst_value_get_fraction_range_max" result+    result' <- (newBoxed GValue) result+    touchManagedPtr value+    return result'+++-- function gst_value_get_fraction_numerator+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_fraction_numerator" gst_value_get_fraction_numerator :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int32+++valueGetFractionNumerator ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int32                              -- result+valueGetFractionNumerator value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_fraction_numerator value'+    touchManagedPtr value+    return result+++-- function gst_value_get_fraction_denominator+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_fraction_denominator" gst_value_get_fraction_denominator :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Int32+++valueGetFractionDenominator ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Int32                              -- result+valueGetFractionDenominator value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_fraction_denominator value'+    touchManagedPtr value+    return result+++-- function gst_value_get_flagset_mask+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_flagset_mask" gst_value_get_flagset_mask :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Word32+++valueGetFlagsetMask ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Word32                             -- result+valueGetFlagsetMask value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_flagset_mask value'+    touchManagedPtr value+    return result+++-- function gst_value_get_flagset_flags+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_flagset_flags" gst_value_get_flagset_flags :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Word32+++valueGetFlagsetFlags ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Word32                             -- result+valueGetFlagsetFlags value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_flagset_flags value'+    touchManagedPtr value+    return result+++-- function gst_value_get_double_range_min+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_double_range_min" gst_value_get_double_range_min :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO CDouble+++valueGetDoubleRangeMin ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Double                             -- result+valueGetDoubleRangeMin value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_double_range_min value'+    let result' = realToFrac result+    touchManagedPtr value+    return result'+++-- function gst_value_get_double_range_max+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_double_range_max" gst_value_get_double_range_max :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO CDouble+++valueGetDoubleRangeMax ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Double                             -- result+valueGetDoubleRangeMax value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_double_range_max value'+    let result' = realToFrac result+    touchManagedPtr value+    return result'+++-- function gst_value_get_caps_features+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "CapsFeatures"+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_caps_features" gst_value_get_caps_features :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO (Ptr CapsFeatures)+++valueGetCapsFeatures ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m CapsFeatures                       -- result+valueGetCapsFeatures value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_caps_features value'+    checkUnexpectedReturnNULL "gst_value_get_caps_features" result+    result' <- (newBoxed CapsFeatures) result+    touchManagedPtr value+    return result'+++-- function gst_value_get_caps+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_caps" gst_value_get_caps :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO (Ptr Caps)+++valueGetCaps ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Caps                               -- result+valueGetCaps value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_caps value'+    checkUnexpectedReturnNULL "gst_value_get_caps" result+    result' <- (newBoxed Caps) result+    touchManagedPtr value+    return result'+++-- function gst_value_get_bitmask+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_get_bitmask" gst_value_get_bitmask :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO Word64+++valueGetBitmask ::+    (MonadIO m) =>+    GValue                                  -- value+    -> m Word64                             -- result+valueGetBitmask value = liftIO $ do+    let value' = unsafeManagedPtrGetPtr value+    result <- gst_value_get_bitmask value'+    touchManagedPtr value+    return result+++-- function gst_value_fraction_subtract+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minuend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_fraction_subtract" gst_value_fraction_subtract :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- minuend : TInterface "GObject" "Value"+    Ptr GValue ->                           -- subtrahend : TInterface "GObject" "Value"+    IO CInt+++valueFractionSubtract ::+    (MonadIO m) =>+    GValue                                  -- dest+    -> GValue                               -- minuend+    -> GValue                               -- subtrahend+    -> m Bool                               -- result+valueFractionSubtract dest minuend subtrahend = liftIO $ do+    let dest' = unsafeManagedPtrGetPtr dest+    let minuend' = unsafeManagedPtrGetPtr minuend+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend+    result <- gst_value_fraction_subtract dest' minuend' subtrahend'+    let result' = (/= 0) result+    touchManagedPtr dest+    touchManagedPtr minuend+    touchManagedPtr subtrahend+    return result'+++-- function gst_value_fraction_multiply+-- Args : [Arg {argCName = "product", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "factor1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "factor2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_fraction_multiply" gst_value_fraction_multiply :: +    Ptr GValue ->                           -- product : TInterface "GObject" "Value"+    Ptr GValue ->                           -- factor1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- factor2 : TInterface "GObject" "Value"+    IO CInt+++valueFractionMultiply ::+    (MonadIO m) =>+    GValue                                  -- product+    -> GValue                               -- factor1+    -> GValue                               -- factor2+    -> m Bool                               -- result+valueFractionMultiply product factor1 factor2 = liftIO $ do+    let product' = unsafeManagedPtrGetPtr product+    let factor1' = unsafeManagedPtrGetPtr factor1+    let factor2' = unsafeManagedPtrGetPtr factor2+    result <- gst_value_fraction_multiply product' factor1' factor2'+    let result' = (/= 0) result+    touchManagedPtr product+    touchManagedPtr factor1+    touchManagedPtr factor2+    return result'+++-- function gst_value_fixate+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_fixate" gst_value_fixate :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"+    IO CInt+++valueFixate ::+    (MonadIO m) =>+    GValue                                  -- dest+    -> GValue                               -- src+    -> m Bool                               -- result+valueFixate dest src = liftIO $ do+    let dest' = unsafeManagedPtrGetPtr dest+    let src' = unsafeManagedPtrGetPtr src+    result <- gst_value_fixate dest' src'+    let result' = (/= 0) result+    touchManagedPtr dest+    touchManagedPtr src+    return result'+++-- function gst_value_deserialize+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_deserialize" gst_value_deserialize :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    CString ->                              -- src : TBasicType TUTF8+    IO CInt+++valueDeserialize ::+    (MonadIO m) =>+    T.Text                                  -- src+    -> m (Bool,GValue)                      -- result+valueDeserialize src = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    src' <- textToCString src+    result <- gst_value_deserialize dest src'+    let result' = (/= 0) result+    dest' <- (wrapBoxed GValue) dest+    freeMem src'+    return (result', dest')+++-- function gst_value_compare+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_compare" gst_value_compare :: +    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"+    IO Int32+++valueCompare ::+    (MonadIO m) =>+    GValue                                  -- value1+    -> GValue                               -- value2+    -> m Int32                              -- result+valueCompare value1 value2 = liftIO $ do+    let value1' = unsafeManagedPtrGetPtr value1+    let value2' = unsafeManagedPtrGetPtr value2+    result <- gst_value_compare value1' value2'+    touchManagedPtr value1+    touchManagedPtr value2+    return result+++-- function gst_value_can_union+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_can_union" gst_value_can_union :: +    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"+    IO CInt+++valueCanUnion ::+    (MonadIO m) =>+    GValue                                  -- value1+    -> GValue                               -- value2+    -> m Bool                               -- result+valueCanUnion value1 value2 = liftIO $ do+    let value1' = unsafeManagedPtrGetPtr value1+    let value2' = unsafeManagedPtrGetPtr value2+    result <- gst_value_can_union value1' value2'+    let result' = (/= 0) result+    touchManagedPtr value1+    touchManagedPtr value2+    return result'+++-- function gst_value_can_subtract+-- Args : [Arg {argCName = "minuend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_can_subtract" gst_value_can_subtract :: +    Ptr GValue ->                           -- minuend : TInterface "GObject" "Value"+    Ptr GValue ->                           -- subtrahend : TInterface "GObject" "Value"+    IO CInt+++valueCanSubtract ::+    (MonadIO m) =>+    GValue                                  -- minuend+    -> GValue                               -- subtrahend+    -> m Bool                               -- result+valueCanSubtract minuend subtrahend = liftIO $ do+    let minuend' = unsafeManagedPtrGetPtr minuend+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend+    result <- gst_value_can_subtract minuend' subtrahend'+    let result' = (/= 0) result+    touchManagedPtr minuend+    touchManagedPtr subtrahend+    return result'+++-- function gst_value_can_intersect+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_can_intersect" gst_value_can_intersect :: +    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"+    IO CInt+++valueCanIntersect ::+    (MonadIO m) =>+    GValue                                  -- value1+    -> GValue                               -- value2+    -> m Bool                               -- result+valueCanIntersect value1 value2 = liftIO $ do+    let value1' = unsafeManagedPtrGetPtr value1+    let value2' = unsafeManagedPtrGetPtr value2+    result <- gst_value_can_intersect value1' value2'+    let result' = (/= 0) result+    touchManagedPtr value1+    touchManagedPtr value2+    return result'+++-- function gst_value_can_compare+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_value_can_compare" gst_value_can_compare :: +    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"+    IO CInt+++valueCanCompare ::+    (MonadIO m) =>+    GValue                                  -- value1+    -> GValue                               -- value2+    -> m Bool                               -- result+valueCanCompare value1 value2 = liftIO $ do+    let value1' = unsafeManagedPtrGetPtr value1+    let value2' = unsafeManagedPtrGetPtr value2+    result <- gst_value_can_compare value1' value2'+    let result' = (/= 0) result+    touchManagedPtr value1+    touchManagedPtr value2+    return result'+++-- function gst_util_uint64_scale_round+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_uint64_scale_round" gst_util_uint64_scale_round :: +    Word64 ->                               -- val : TBasicType TUInt64+    Word64 ->                               -- num : TBasicType TUInt64+    Word64 ->                               -- denom : TBasicType TUInt64+    IO Word64+++utilUint64ScaleRound ::+    (MonadIO m) =>+    Word64                                  -- val+    -> Word64                               -- num+    -> Word64                               -- denom+    -> m Word64                             -- result+utilUint64ScaleRound val num denom = liftIO $ do+    result <- gst_util_uint64_scale_round val num denom+    return result+++-- function gst_util_uint64_scale_int_round+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_uint64_scale_int_round" gst_util_uint64_scale_int_round :: +    Word64 ->                               -- val : TBasicType TUInt64+    Int32 ->                                -- num : TBasicType TInt32+    Int32 ->                                -- denom : TBasicType TInt32+    IO Word64+++utilUint64ScaleIntRound ::+    (MonadIO m) =>+    Word64                                  -- val+    -> Int32                                -- num+    -> Int32                                -- denom+    -> m Word64                             -- result+utilUint64ScaleIntRound val num denom = liftIO $ do+    result <- gst_util_uint64_scale_int_round val num denom+    return result+++-- function gst_util_uint64_scale_int_ceil+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_uint64_scale_int_ceil" gst_util_uint64_scale_int_ceil :: +    Word64 ->                               -- val : TBasicType TUInt64+    Int32 ->                                -- num : TBasicType TInt32+    Int32 ->                                -- denom : TBasicType TInt32+    IO Word64+++utilUint64ScaleIntCeil ::+    (MonadIO m) =>+    Word64                                  -- val+    -> Int32                                -- num+    -> Int32                                -- denom+    -> m Word64                             -- result+utilUint64ScaleIntCeil val num denom = liftIO $ do+    result <- gst_util_uint64_scale_int_ceil val num denom+    return result+++-- function gst_util_uint64_scale_int+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_uint64_scale_int" gst_util_uint64_scale_int :: +    Word64 ->                               -- val : TBasicType TUInt64+    Int32 ->                                -- num : TBasicType TInt32+    Int32 ->                                -- denom : TBasicType TInt32+    IO Word64+++utilUint64ScaleInt ::+    (MonadIO m) =>+    Word64                                  -- val+    -> Int32                                -- num+    -> Int32                                -- denom+    -> m Word64                             -- result+utilUint64ScaleInt val num denom = liftIO $ do+    result <- gst_util_uint64_scale_int val num denom+    return result+++-- function gst_util_uint64_scale_ceil+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_uint64_scale_ceil" gst_util_uint64_scale_ceil :: +    Word64 ->                               -- val : TBasicType TUInt64+    Word64 ->                               -- num : TBasicType TUInt64+    Word64 ->                               -- denom : TBasicType TUInt64+    IO Word64+++utilUint64ScaleCeil ::+    (MonadIO m) =>+    Word64                                  -- val+    -> Word64                               -- num+    -> Word64                               -- denom+    -> m Word64                             -- result+utilUint64ScaleCeil val num denom = liftIO $ do+    result <- gst_util_uint64_scale_ceil val num denom+    return result+++-- function gst_util_uint64_scale+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_uint64_scale" gst_util_uint64_scale :: +    Word64 ->                               -- val : TBasicType TUInt64+    Word64 ->                               -- num : TBasicType TUInt64+    Word64 ->                               -- denom : TBasicType TUInt64+    IO Word64+++utilUint64Scale ::+    (MonadIO m) =>+    Word64                                  -- val+    -> Word64                               -- num+    -> Word64                               -- denom+    -> m Word64                             -- result+utilUint64Scale val num denom = liftIO $ do+    result <- gst_util_uint64_scale val num denom+    return result+++-- function gst_util_set_value_from_string+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "value_str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_set_value_from_string" gst_util_set_value_from_string :: +    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    CString ->                              -- value_str : TBasicType TUTF8+    IO ()+++utilSetValueFromString ::+    (MonadIO m) =>+    T.Text                                  -- valueStr+    -> m (GValue)                           -- result+utilSetValueFromString valueStr = liftIO $ do+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)+    valueStr' <- textToCString valueStr+    gst_util_set_value_from_string value valueStr'+    value' <- (wrapBoxed GValue) value+    freeMem valueStr'+    return value'+++-- function gst_util_set_object_arg+-- Args : [Arg {argCName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_set_object_arg" gst_util_set_object_arg :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO ()+++utilSetObjectArg ::+    (MonadIO m, GObject.ObjectK a) =>+    a                                       -- object+    -> T.Text                               -- name+    -> T.Text                               -- value+    -> m ()                                 -- result+utilSetObjectArg object name value = liftIO $ do+    let object' = unsafeManagedPtrCastPtr object+    name' <- textToCString name+    value' <- textToCString value+    gst_util_set_object_arg object' name' value'+    touchManagedPtr object+    freeMem name'+    freeMem value'+    return ()+++-- function gst_util_seqnum_next+-- Args : []+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_seqnum_next" gst_util_seqnum_next :: +    IO Word32+++utilSeqnumNext ::+    (MonadIO m) =>+    m Word32                                -- result+utilSeqnumNext  = liftIO $ do+    result <- gst_util_seqnum_next+    return result+++-- function gst_util_seqnum_compare+-- Args : [Arg {argCName = "s1", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "s2", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_seqnum_compare" gst_util_seqnum_compare :: +    Word32 ->                               -- s1 : TBasicType TUInt32+    Word32 ->                               -- s2 : TBasicType TUInt32+    IO Int32+++utilSeqnumCompare ::+    (MonadIO m) =>+    Word32                                  -- s1+    -> Word32                               -- s2+    -> m Int32                              -- result+utilSeqnumCompare s1 s2 = liftIO $ do+    result <- gst_util_seqnum_compare s1 s2+    return result+++-- function gst_util_guint64_to_gdouble+-- Args : [Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TDouble+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_guint64_to_gdouble" gst_util_guint64_to_gdouble :: +    Word64 ->                               -- value : TBasicType TUInt64+    IO CDouble+++utilGuint64ToGdouble ::+    (MonadIO m) =>+    Word64                                  -- value+    -> m Double                             -- result+utilGuint64ToGdouble value = liftIO $ do+    result <- gst_util_guint64_to_gdouble value+    let result' = realToFrac result+    return result'+++-- function gst_util_group_id_next+-- Args : []+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_group_id_next" gst_util_group_id_next :: +    IO Word32+++utilGroupIdNext ::+    (MonadIO m) =>+    m Word32                                -- result+utilGroupIdNext  = liftIO $ do+    result <- gst_util_group_id_next+    return result+++-- function gst_util_greatest_common_divisor_int64+-- Args : [Arg {argCName = "a", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_greatest_common_divisor_int64" gst_util_greatest_common_divisor_int64 :: +    Int64 ->                                -- a : TBasicType TInt64+    Int64 ->                                -- b : TBasicType TInt64+    IO Int64+++utilGreatestCommonDivisorInt64 ::+    (MonadIO m) =>+    Int64                                   -- a+    -> Int64                                -- b+    -> m Int64                              -- result+utilGreatestCommonDivisorInt64 a b = liftIO $ do+    result <- gst_util_greatest_common_divisor_int64 a b+    return result+++-- function gst_util_greatest_common_divisor+-- Args : [Arg {argCName = "a", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_greatest_common_divisor" gst_util_greatest_common_divisor :: +    Int32 ->                                -- a : TBasicType TInt32+    Int32 ->                                -- b : TBasicType TInt32+    IO Int32+++utilGreatestCommonDivisor ::+    (MonadIO m) =>+    Int32                                   -- a+    -> Int32                                -- b+    -> m Int32                              -- result+utilGreatestCommonDivisor a b = liftIO $ do+    result <- gst_util_greatest_common_divisor a b+    return result+++-- function gst_util_get_timestamp+-- Args : []+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_get_timestamp" gst_util_get_timestamp :: +    IO Word64+++utilGetTimestamp ::+    (MonadIO m) =>+    m Word64                                -- result+utilGetTimestamp  = liftIO $ do+    result <- gst_util_get_timestamp+    return result+++-- function gst_util_gdouble_to_guint64+-- Args : [Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_gdouble_to_guint64" gst_util_gdouble_to_guint64 :: +    CDouble ->                              -- value : TBasicType TDouble+    IO Word64+++utilGdoubleToGuint64 ::+    (MonadIO m) =>+    Double                                  -- value+    -> m Word64                             -- result+utilGdoubleToGuint64 value = liftIO $ do+    let value' = realToFrac value+    result <- gst_util_gdouble_to_guint64 value'+    return result+++-- function gst_util_fraction_to_double+-- Args : [Arg {argCName = "src_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_fraction_to_double" gst_util_fraction_to_double :: +    Int32 ->                                -- src_n : TBasicType TInt32+    Int32 ->                                -- src_d : TBasicType TInt32+    Ptr CDouble ->                          -- dest : TBasicType TDouble+    IO ()+++utilFractionToDouble ::+    (MonadIO m) =>+    Int32                                   -- srcN+    -> Int32                                -- srcD+    -> m (Double)                           -- result+utilFractionToDouble srcN srcD = liftIO $ do+    dest <- allocMem :: IO (Ptr CDouble)+    gst_util_fraction_to_double srcN srcD dest+    dest' <- peek dest+    let dest'' = realToFrac dest'+    freeMem dest+    return dest''+++-- function gst_util_fraction_multiply+-- Args : [Arg {argCName = "a_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res_n", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "res_d", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_fraction_multiply" gst_util_fraction_multiply :: +    Int32 ->                                -- a_n : TBasicType TInt32+    Int32 ->                                -- a_d : TBasicType TInt32+    Int32 ->                                -- b_n : TBasicType TInt32+    Int32 ->                                -- b_d : TBasicType TInt32+    Ptr Int32 ->                            -- res_n : TBasicType TInt32+    Ptr Int32 ->                            -- res_d : TBasicType TInt32+    IO CInt+++utilFractionMultiply ::+    (MonadIO m) =>+    Int32                                   -- aN+    -> Int32                                -- aD+    -> Int32                                -- bN+    -> Int32                                -- bD+    -> m (Bool,Int32,Int32)                 -- result+utilFractionMultiply aN aD bN bD = liftIO $ do+    resN <- allocMem :: IO (Ptr Int32)+    resD <- allocMem :: IO (Ptr Int32)+    result <- gst_util_fraction_multiply aN aD bN bD resN resD+    let result' = (/= 0) result+    resN' <- peek resN+    resD' <- peek resD+    freeMem resN+    freeMem resD+    return (result', resN', resD')+++-- function gst_util_fraction_compare+-- Args : [Arg {argCName = "a_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_fraction_compare" gst_util_fraction_compare :: +    Int32 ->                                -- a_n : TBasicType TInt32+    Int32 ->                                -- a_d : TBasicType TInt32+    Int32 ->                                -- b_n : TBasicType TInt32+    Int32 ->                                -- b_d : TBasicType TInt32+    IO Int32+++utilFractionCompare ::+    (MonadIO m) =>+    Int32                                   -- aN+    -> Int32                                -- aD+    -> Int32                                -- bN+    -> Int32                                -- bD+    -> m Int32                              -- result+utilFractionCompare aN aD bN bD = liftIO $ do+    result <- gst_util_fraction_compare aN aD bN bD+    return result+++-- function gst_util_fraction_add+-- Args : [Arg {argCName = "a_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res_n", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "res_d", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_fraction_add" gst_util_fraction_add :: +    Int32 ->                                -- a_n : TBasicType TInt32+    Int32 ->                                -- a_d : TBasicType TInt32+    Int32 ->                                -- b_n : TBasicType TInt32+    Int32 ->                                -- b_d : TBasicType TInt32+    Ptr Int32 ->                            -- res_n : TBasicType TInt32+    Ptr Int32 ->                            -- res_d : TBasicType TInt32+    IO CInt+++utilFractionAdd ::+    (MonadIO m) =>+    Int32                                   -- aN+    -> Int32                                -- aD+    -> Int32                                -- bN+    -> Int32                                -- bD+    -> m (Bool,Int32,Int32)                 -- result+utilFractionAdd aN aD bN bD = liftIO $ do+    resN <- allocMem :: IO (Ptr Int32)+    resD <- allocMem :: IO (Ptr Int32)+    result <- gst_util_fraction_add aN aD bN bD resN resD+    let result' = (/= 0) result+    resN' <- peek resN+    resD' <- peek resD+    freeMem resN+    freeMem resD+    return (result', resN', resD')+++-- function gst_util_dump_mem+-- Args : [Arg {argCName = "mem", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_dump_mem" gst_util_dump_mem :: +    Word8 ->                                -- mem : TBasicType TUInt8+    Word32 ->                               -- size : TBasicType TUInt32+    IO ()+++utilDumpMem ::+    (MonadIO m) =>+    Word8                                   -- mem+    -> Word32                               -- size+    -> m ()                                 -- result+utilDumpMem mem size = liftIO $ do+    gst_util_dump_mem mem size+    return ()+++-- function gst_util_double_to_fraction+-- Args : [Arg {argCName = "src", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_n", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_d", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_double_to_fraction" gst_util_double_to_fraction :: +    CDouble ->                              -- src : TBasicType TDouble+    Ptr Int32 ->                            -- dest_n : TBasicType TInt32+    Ptr Int32 ->                            -- dest_d : TBasicType TInt32+    IO ()+++utilDoubleToFraction ::+    (MonadIO m) =>+    Double                                  -- src+    -> m (Int32,Int32)                      -- result+utilDoubleToFraction src = liftIO $ do+    let src' = realToFrac src+    destN <- allocMem :: IO (Ptr Int32)+    destD <- allocMem :: IO (Ptr Int32)+    gst_util_double_to_fraction src' destN destD+    destN' <- peek destN+    destD' <- peek destD+    freeMem destN+    freeMem destD+    return (destN', destD')+++-- function gst_util_array_binary_search+-- Args : [Arg {argCName = "array", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num_elements", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_func", argType = TInterface "GLib" "CompareDataFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "SearchMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_util_array_binary_search" gst_util_array_binary_search :: +    Ptr () ->                               -- array : TBasicType TVoid+    Word32 ->                               -- num_elements : TBasicType TUInt32+    Word64 ->                               -- element_size : TBasicType TUInt64+    FunPtr GLib.CompareDataFuncC ->         -- search_func : TInterface "GLib" "CompareDataFunc"+    CUInt ->                                -- mode : TInterface "Gst" "SearchMode"+    Ptr () ->                               -- search_data : TBasicType TVoid+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++utilArrayBinarySearch ::+    (MonadIO m) =>+    Ptr ()                                  -- array+    -> Word32                               -- numElements+    -> Word64                               -- elementSize+    -> GLib.CompareDataFunc                 -- searchFunc+    -> SearchMode                           -- mode+    -> Ptr ()                               -- searchData+    -> m ()                                 -- result+utilArrayBinarySearch array numElements elementSize searchFunc mode searchData = liftIO $ do+    searchFunc' <- GLib.mkCompareDataFunc (GLib.compareDataFuncWrapper Nothing searchFunc)+    let mode' = (fromIntegral . fromEnum) mode+    let userData = nullPtr+    gst_util_array_binary_search array numElements elementSize searchFunc' mode' searchData userData+    safeFreeFunPtr $ castFunPtrToPtr searchFunc'+    return ()+++-- function gst_update_registry+-- Args : []+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_update_registry" gst_update_registry :: +    IO CInt+++updateRegistry ::+    (MonadIO m) =>+    m Bool                                  -- result+updateRegistry  = liftIO $ do+    result <- gst_update_registry+    let result' = (/= 0) result+    return result'+++-- function gst_type_find_get_type+-- Args : []+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_get_type" gst_type_find_get_type :: +    IO CGType+++typeFindGetType ::+    (MonadIO m) =>+    m GType                                 -- result+typeFindGetType  = liftIO $ do+    result <- gst_type_find_get_type+    let result' = GType result+    return result'+++-- function gst_tag_register_static+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flag", argType = TInterface "Gst" "TagFlag", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nick", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blurb", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TagMergeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_register_static" gst_tag_register_static :: +    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- flag : TInterface "Gst" "TagFlag"+    CGType ->                               -- type : TBasicType TGType+    CString ->                              -- nick : TBasicType TUTF8+    CString ->                              -- blurb : TBasicType TUTF8+    FunPtr TagMergeFuncC ->                 -- func : TInterface "Gst" "TagMergeFunc"+    IO ()+++tagRegisterStatic ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> TagFlag                              -- flag+    -> GType                                -- type_+    -> T.Text                               -- nick+    -> T.Text                               -- blurb+    -> Maybe (TagMergeFunc)                 -- func+    -> m ()                                 -- result+tagRegisterStatic name flag type_ nick blurb func = liftIO $ do+    name' <- textToCString name+    let flag' = (fromIntegral . fromEnum) flag+    let type_' = gtypeToCGType type_+    nick' <- textToCString nick+    blurb' <- textToCString blurb+    maybeFunc <- case func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFunc -> do+            jFunc' <- mkTagMergeFunc (tagMergeFuncWrapper Nothing jFunc)+            return jFunc'+    gst_tag_register_static name' flag' type_' nick' blurb' maybeFunc+    safeFreeFunPtr $ castFunPtrToPtr maybeFunc+    freeMem name'+    freeMem nick'+    freeMem blurb'+    return ()+++-- function gst_tag_register+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flag", argType = TInterface "Gst" "TagFlag", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nick", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blurb", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TagMergeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_register" gst_tag_register :: +    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- flag : TInterface "Gst" "TagFlag"+    CGType ->                               -- type : TBasicType TGType+    CString ->                              -- nick : TBasicType TUTF8+    CString ->                              -- blurb : TBasicType TUTF8+    FunPtr TagMergeFuncC ->                 -- func : TInterface "Gst" "TagMergeFunc"+    IO ()+++tagRegister ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> TagFlag                              -- flag+    -> GType                                -- type_+    -> T.Text                               -- nick+    -> T.Text                               -- blurb+    -> Maybe (TagMergeFunc)                 -- func+    -> m ()                                 -- result+tagRegister name flag type_ nick blurb func = liftIO $ do+    name' <- textToCString name+    let flag' = (fromIntegral . fromEnum) flag+    let type_' = gtypeToCGType type_+    nick' <- textToCString nick+    blurb' <- textToCString blurb+    maybeFunc <- case func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFunc -> do+            jFunc' <- mkTagMergeFunc (tagMergeFuncWrapper Nothing jFunc)+            return jFunc'+    gst_tag_register name' flag' type_' nick' blurb' maybeFunc+    safeFreeFunPtr $ castFunPtrToPtr maybeFunc+    freeMem name'+    freeMem nick'+    freeMem blurb'+    return ()+++-- function gst_tag_merge_use_first+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_merge_use_first" gst_tag_merge_use_first :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"+    IO ()+++tagMergeUseFirst ::+    (MonadIO m) =>+    GValue                                  -- src+    -> m (GValue)                           -- result+tagMergeUseFirst src = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let src' = unsafeManagedPtrGetPtr src+    gst_tag_merge_use_first dest src'+    dest' <- (wrapBoxed GValue) dest+    touchManagedPtr src+    return dest'+++-- function gst_tag_merge_strings_with_comma+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_merge_strings_with_comma" gst_tag_merge_strings_with_comma :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"+    IO ()+++tagMergeStringsWithComma ::+    (MonadIO m) =>+    GValue                                  -- src+    -> m (GValue)                           -- result+tagMergeStringsWithComma src = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let src' = unsafeManagedPtrGetPtr src+    gst_tag_merge_strings_with_comma dest src'+    dest' <- (wrapBoxed GValue) dest+    touchManagedPtr src+    return dest'+++-- function gst_tag_is_fixed+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_is_fixed" gst_tag_is_fixed :: +    CString ->                              -- tag : TBasicType TUTF8+    IO CInt+++tagIsFixed ::+    (MonadIO m) =>+    T.Text                                  -- tag+    -> m Bool                               -- result+tagIsFixed tag = liftIO $ do+    tag' <- textToCString tag+    result <- gst_tag_is_fixed tag'+    let result' = (/= 0) result+    freeMem tag'+    return result'+++-- function gst_tag_get_type+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_type" gst_tag_get_type :: +    CString ->                              -- tag : TBasicType TUTF8+    IO CGType+++tagGetType ::+    (MonadIO m) =>+    T.Text                                  -- tag+    -> m GType                              -- result+tagGetType tag = liftIO $ do+    tag' <- textToCString tag+    result <- gst_tag_get_type tag'+    let result' = GType result+    freeMem tag'+    return result'+++-- function gst_tag_get_nick+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_nick" gst_tag_get_nick :: +    CString ->                              -- tag : TBasicType TUTF8+    IO CString+++tagGetNick ::+    (MonadIO m) =>+    T.Text                                  -- tag+    -> m T.Text                             -- result+tagGetNick tag = liftIO $ do+    tag' <- textToCString tag+    result <- gst_tag_get_nick tag'+    checkUnexpectedReturnNULL "gst_tag_get_nick" result+    result' <- cstringToText result+    freeMem tag'+    return result'+++-- function gst_tag_get_flag+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagFlag"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_flag" gst_tag_get_flag :: +    CString ->                              -- tag : TBasicType TUTF8+    IO CUInt+++tagGetFlag ::+    (MonadIO m) =>+    T.Text                                  -- tag+    -> m TagFlag                            -- result+tagGetFlag tag = liftIO $ do+    tag' <- textToCString tag+    result <- gst_tag_get_flag tag'+    let result' = (toEnum . fromIntegral) result+    freeMem tag'+    return result'+++-- function gst_tag_get_description+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_get_description" gst_tag_get_description :: +    CString ->                              -- tag : TBasicType TUTF8+    IO CString+++tagGetDescription ::+    (MonadIO m) =>+    T.Text                                  -- tag+    -> m T.Text                             -- result+tagGetDescription tag = liftIO $ do+    tag' <- textToCString tag+    result <- gst_tag_get_description tag'+    checkUnexpectedReturnNULL "gst_tag_get_description" result+    result' <- cstringToText result+    freeMem tag'+    return result'+++-- function gst_tag_exists+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_exists" gst_tag_exists :: +    CString ->                              -- tag : TBasicType TUTF8+    IO CInt+++tagExists ::+    (MonadIO m) =>+    T.Text                                  -- tag+    -> m Bool                               -- result+tagExists tag = liftIO $ do+    tag' <- textToCString tag+    result <- gst_tag_exists tag'+    let result' = (/= 0) result+    freeMem tag'+    return result'+++-- function gst_static_pad_template_get_type+-- Args : []+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_static_pad_template_get_type" gst_static_pad_template_get_type :: +    IO CGType+++staticPadTemplateGetType ::+    (MonadIO m) =>+    m GType                                 -- result+staticPadTemplateGetType  = liftIO $ do+    result <- gst_static_pad_template_get_type+    let result' = GType result+    return result'+++-- function gst_static_caps_get_type+-- Args : []+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_static_caps_get_type" gst_static_caps_get_type :: +    IO CGType+++staticCapsGetType ::+    (MonadIO m) =>+    m GType                                 -- result+staticCapsGetType  = liftIO $ do+    result <- gst_static_caps_get_type+    let result' = GType result+    return result'+++-- function gst_segtrap_set_enabled+-- Args : [Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_segtrap_set_enabled" gst_segtrap_set_enabled :: +    CInt ->                                 -- enabled : TBasicType TBoolean+    IO ()+++segtrapSetEnabled ::+    (MonadIO m) =>+    Bool                                    -- enabled+    -> m ()                                 -- result+segtrapSetEnabled enabled = liftIO $ do+    let enabled' = (fromIntegral . fromEnum) enabled+    gst_segtrap_set_enabled enabled'+    return ()+++-- function gst_segtrap_is_enabled+-- Args : []+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_segtrap_is_enabled" gst_segtrap_is_enabled :: +    IO CInt+++segtrapIsEnabled ::+    (MonadIO m) =>+    m Bool                                  -- result+segtrapIsEnabled  = liftIO $ do+    result <- gst_segtrap_is_enabled+    let result' = (/= 0) result+    return result'+++-- function gst_protection_select_system+-- Args : [Arg {argCName = "system_identifiers", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_protection_select_system" gst_protection_select_system :: +    CString ->                              -- system_identifiers : TBasicType TUTF8+    IO CString+++protectionSelectSystem ::+    (MonadIO m) =>+    T.Text                                  -- systemIdentifiers+    -> m T.Text                             -- result+protectionSelectSystem systemIdentifiers = liftIO $ do+    systemIdentifiers' <- textToCString systemIdentifiers+    result <- gst_protection_select_system systemIdentifiers'+    checkUnexpectedReturnNULL "gst_protection_select_system" result+    result' <- cstringToText result+    freeMem systemIdentifiers'+    return result'+++-- function gst_protection_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_protection_meta_api_get_type" gst_protection_meta_api_get_type :: +    IO CGType+++protectionMetaApiGetType ::+    (MonadIO m) =>+    m GType                                 -- result+protectionMetaApiGetType  = liftIO $ do+    result <- gst_protection_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_parse_launchv_full+-- Args : [Arg {argCName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "ParseFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : True+-- Skip return : False++foreign import ccall "gst_parse_launchv_full" gst_parse_launchv_full :: +    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr ParseContext ->                     -- context : TInterface "Gst" "ParseContext"+    CUInt ->                                -- flags : TInterface "Gst" "ParseFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Element)+++parseLaunchvFull ::+    (MonadIO m) =>+    [T.Text]                                -- argv+    -> Maybe (ParseContext)                 -- context+    -> [ParseFlags]                         -- flags+    -> m Element                            -- result+parseLaunchvFull argv context flags = liftIO $ do+    argv' <- packZeroTerminatedUTF8CArray argv+    maybeContext <- case context of+        Nothing -> return nullPtr+        Just jContext -> do+            let jContext' = unsafeManagedPtrGetPtr jContext+            return jContext'+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ gst_parse_launchv_full argv' maybeContext flags'+        checkUnexpectedReturnNULL "gst_parse_launchv_full" result+        result' <- (newObject Element) result+        whenJust context touchManagedPtr+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+        return result'+     ) (do+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+     )+++-- function gst_parse_launchv+-- Args : [Arg {argCName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : True+-- Skip return : False++foreign import ccall "gst_parse_launchv" gst_parse_launchv :: +    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Element)+++parseLaunchv ::+    (MonadIO m) =>+    [T.Text]                                -- argv+    -> m Element                            -- result+parseLaunchv argv = liftIO $ do+    argv' <- packZeroTerminatedUTF8CArray argv+    onException (do+        result <- propagateGError $ gst_parse_launchv argv'+        checkUnexpectedReturnNULL "gst_parse_launchv" result+        result' <- (newObject Element) result+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+        return result'+     ) (do+        mapZeroTerminatedCArray freeMem argv'+        freeMem argv'+     )+++-- function gst_parse_launch_full+-- Args : [Arg {argCName = "pipeline_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "ParseFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : True+-- Skip return : False++foreign import ccall "gst_parse_launch_full" gst_parse_launch_full :: +    CString ->                              -- pipeline_description : TBasicType TUTF8+    Ptr ParseContext ->                     -- context : TInterface "Gst" "ParseContext"+    CUInt ->                                -- flags : TInterface "Gst" "ParseFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Element)+++parseLaunchFull ::+    (MonadIO m) =>+    T.Text                                  -- pipelineDescription+    -> Maybe (ParseContext)                 -- context+    -> [ParseFlags]                         -- flags+    -> m Element                            -- result+parseLaunchFull pipelineDescription context flags = liftIO $ do+    pipelineDescription' <- textToCString pipelineDescription+    maybeContext <- case context of+        Nothing -> return nullPtr+        Just jContext -> do+            let jContext' = unsafeManagedPtrGetPtr jContext+            return jContext'+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ gst_parse_launch_full pipelineDescription' maybeContext flags'+        checkUnexpectedReturnNULL "gst_parse_launch_full" result+        result' <- (newObject Element) result+        whenJust context touchManagedPtr+        freeMem pipelineDescription'+        return result'+     ) (do+        freeMem pipelineDescription'+     )+++-- function gst_parse_launch+-- Args : [Arg {argCName = "pipeline_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : True+-- Skip return : False++foreign import ccall "gst_parse_launch" gst_parse_launch :: +    CString ->                              -- pipeline_description : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Element)+++parseLaunch ::+    (MonadIO m) =>+    T.Text                                  -- pipelineDescription+    -> m Element                            -- result+parseLaunch pipelineDescription = liftIO $ do+    pipelineDescription' <- textToCString pipelineDescription+    onException (do+        result <- propagateGError $ gst_parse_launch pipelineDescription'+        checkUnexpectedReturnNULL "gst_parse_launch" result+        result' <- (newObject Element) result+        freeMem pipelineDescription'+        return result'+     ) (do+        freeMem pipelineDescription'+     )+++-- function gst_parse_bin_from_description_full+-- Args : [Arg {argCName = "bin_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ghost_unlinked_pads", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "ParseFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : True+-- Skip return : False++foreign import ccall "gst_parse_bin_from_description_full" gst_parse_bin_from_description_full :: +    CString ->                              -- bin_description : TBasicType TUTF8+    CInt ->                                 -- ghost_unlinked_pads : TBasicType TBoolean+    Ptr ParseContext ->                     -- context : TInterface "Gst" "ParseContext"+    CUInt ->                                -- flags : TInterface "Gst" "ParseFlags"+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Element)+++parseBinFromDescriptionFull ::+    (MonadIO m) =>+    T.Text                                  -- binDescription+    -> Bool                                 -- ghostUnlinkedPads+    -> Maybe (ParseContext)                 -- context+    -> [ParseFlags]                         -- flags+    -> m Element                            -- result+parseBinFromDescriptionFull binDescription ghostUnlinkedPads context flags = liftIO $ do+    binDescription' <- textToCString binDescription+    let ghostUnlinkedPads' = (fromIntegral . fromEnum) ghostUnlinkedPads+    maybeContext <- case context of+        Nothing -> return nullPtr+        Just jContext -> do+            let jContext' = unsafeManagedPtrGetPtr jContext+            return jContext'+    let flags' = gflagsToWord flags+    onException (do+        result <- propagateGError $ gst_parse_bin_from_description_full binDescription' ghostUnlinkedPads' maybeContext flags'+        checkUnexpectedReturnNULL "gst_parse_bin_from_description_full" result+        result' <- (newObject Element) result+        whenJust context touchManagedPtr+        freeMem binDescription'+        return result'+     ) (do+        freeMem binDescription'+     )+++-- function gst_parse_bin_from_description+-- Args : [Arg {argCName = "bin_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ghost_unlinked_pads", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Bin"+-- throws : True+-- Skip return : False++foreign import ccall "gst_parse_bin_from_description" gst_parse_bin_from_description :: +    CString ->                              -- bin_description : TBasicType TUTF8+    CInt ->                                 -- ghost_unlinked_pads : TBasicType TBoolean+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Bin)+++parseBinFromDescription ::+    (MonadIO m) =>+    T.Text                                  -- binDescription+    -> Bool                                 -- ghostUnlinkedPads+    -> m Bin                                -- result+parseBinFromDescription binDescription ghostUnlinkedPads = liftIO $ do+    binDescription' <- textToCString binDescription+    let ghostUnlinkedPads' = (fromIntegral . fromEnum) ghostUnlinkedPads+    onException (do+        result <- propagateGError $ gst_parse_bin_from_description binDescription' ghostUnlinkedPads'+        checkUnexpectedReturnNULL "gst_parse_bin_from_description" result+        result' <- (newObject Bin) result+        freeMem binDescription'+        return result'+     ) (do+        freeMem binDescription'+     )+++-- function gst_parent_buffer_meta_api_get_type+-- Args : []+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_parent_buffer_meta_api_get_type" gst_parent_buffer_meta_api_get_type :: +    IO CGType+++parentBufferMetaApiGetType ::+    (MonadIO m) =>+    m GType                                 -- result+parentBufferMetaApiGetType  = liftIO $ do+    result <- gst_parent_buffer_meta_api_get_type+    let result' = GType result+    return result'+++-- function gst_param_spec_fraction+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nick", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blurb", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GObject" "ParamFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TParamSpec+-- throws : False+-- Skip return : False++foreign import ccall "gst_param_spec_fraction" gst_param_spec_fraction :: +    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- nick : TBasicType TUTF8+    CString ->                              -- blurb : TBasicType TUTF8+    Int32 ->                                -- min_num : TBasicType TInt32+    Int32 ->                                -- min_denom : TBasicType TInt32+    Int32 ->                                -- max_num : TBasicType TInt32+    Int32 ->                                -- max_denom : TBasicType TInt32+    Int32 ->                                -- default_num : TBasicType TInt32+    Int32 ->                                -- default_denom : TBasicType TInt32+    CUInt ->                                -- flags : TInterface "GObject" "ParamFlags"+    IO (Ptr GParamSpec)+++paramSpecFraction ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> T.Text                               -- nick+    -> T.Text                               -- blurb+    -> Int32                                -- minNum+    -> Int32                                -- minDenom+    -> Int32                                -- maxNum+    -> Int32                                -- maxDenom+    -> Int32                                -- defaultNum+    -> Int32                                -- defaultDenom+    -> [GObject.ParamFlags]                 -- flags+    -> m GParamSpec                         -- result+paramSpecFraction name nick blurb minNum minDenom maxNum maxDenom defaultNum defaultDenom flags = liftIO $ do+    name' <- textToCString name+    nick' <- textToCString nick+    blurb' <- textToCString blurb+    let flags' = gflagsToWord flags+    result <- gst_param_spec_fraction name' nick' blurb' minNum minDenom maxNum maxDenom defaultNum defaultDenom flags'+    checkUnexpectedReturnNULL "gst_param_spec_fraction" result+    result' <- wrapGParamSpecPtr result+    freeMem name'+    freeMem nick'+    freeMem blurb'+    return result'+++-- function gst_is_initialized+-- Args : []+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_is_initialized" gst_is_initialized :: +    IO CInt+++isInitialized ::+    (MonadIO m) =>+    m Bool                                  -- result+isInitialized  = liftIO $ do+    result <- gst_is_initialized+    let result' = (/= 0) result+    return result'+++-- function gst_is_caps_features+-- Args : [Arg {argCName = "obj", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_is_caps_features" gst_is_caps_features :: +    Ptr () ->                               -- obj : TBasicType TVoid+    IO CInt+++isCapsFeatures ::+    (MonadIO m) =>+    Ptr ()                                  -- obj+    -> m Bool                               -- result+isCapsFeatures obj = liftIO $ do+    result <- gst_is_caps_features obj+    let result' = (/= 0) result+    return result'+++-- function gst_init_check+-- XXX Could not generate function gst_init_check+-- Error was : Bad introspection data: "argument \"argc\" is not of nullable type (TBasicType TInt32), but it is marked as such."++-- function gst_init+-- XXX Could not generate function gst_init+-- Error was : Bad introspection data: "argument \"argc\" is not of nullable type (TBasicType TInt32), but it is marked as such."++-- function gst_formats_contains+-- Args : [Arg {argCName = "formats", argType = TCArray True (-1) (-1) (TInterface "Gst" "Format"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_formats_contains" gst_formats_contains :: +    Ptr CUInt ->                            -- formats : TCArray True (-1) (-1) (TInterface "Gst" "Format")+    CUInt ->                                -- format : TInterface "Gst" "Format"+    IO CInt+++formatsContains ::+    (MonadIO m) =>+    [Format]                                -- formats+    -> Format                               -- format+    -> m Bool                               -- result+formatsContains formats format = liftIO $ do+    let formats' = map (fromIntegral . fromEnum) formats+    formats'' <- packZeroTerminatedStorableArray formats'+    let format' = (fromIntegral . fromEnum) format+    result <- gst_formats_contains formats'' format'+    let result' = (/= 0) result+    freeMem formats''+    return result'+++-- function gst_flow_to_quark+-- Args : [Arg {argCName = "ret", argType = TInterface "Gst" "FlowReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_flow_to_quark" gst_flow_to_quark :: +    CUInt ->                                -- ret : TInterface "Gst" "FlowReturn"+    IO Word32+++flowToQuark ::+    (MonadIO m) =>+    FlowReturn                              -- ret+    -> m Word32                             -- result+flowToQuark ret = liftIO $ do+    let ret' = (fromIntegral . fromEnum) ret+    result <- gst_flow_to_quark ret'+    return result+++-- function gst_flow_get_name+-- Args : [Arg {argCName = "ret", argType = TInterface "Gst" "FlowReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_flow_get_name" gst_flow_get_name :: +    CUInt ->                                -- ret : TInterface "Gst" "FlowReturn"+    IO CString+++flowGetName ::+    (MonadIO m) =>+    FlowReturn                              -- ret+    -> m T.Text                             -- result+flowGetName ret = liftIO $ do+    let ret' = (fromIntegral . fromEnum) ret+    result <- gst_flow_get_name ret'+    checkUnexpectedReturnNULL "gst_flow_get_name" result+    result' <- cstringToText result+    return result'+++-- function gst_filename_to_uri+-- Args : [Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : True+-- Skip return : False++foreign import ccall "gst_filename_to_uri" gst_filename_to_uri :: +    CString ->                              -- filename : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CString+++filenameToUri ::+    (MonadIO m) =>+    T.Text                                  -- filename+    -> m T.Text                             -- result+filenameToUri filename = liftIO $ do+    filename' <- textToCString filename+    onException (do+        result <- propagateGError $ gst_filename_to_uri filename'+        checkUnexpectedReturnNULL "gst_filename_to_uri" result+        result' <- cstringToText result+        freeMem result+        freeMem filename'+        return result'+     ) (do+        freeMem filename'+     )+++-- function gst_error_get_message+-- Args : [Arg {argCName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_error_get_message" gst_error_get_message :: +    Word32 ->                               -- domain : TBasicType TUInt32+    Int32 ->                                -- code : TBasicType TInt32+    IO CString+++errorGetMessage ::+    (MonadIO m) =>+    Word32                                  -- domain+    -> Int32                                -- code+    -> m T.Text                             -- result+errorGetMessage domain code = liftIO $ do+    result <- gst_error_get_message domain code+    checkUnexpectedReturnNULL "gst_error_get_message" result+    result' <- cstringToText result+    freeMem result+    return result'+++-- function gst_deinit+-- Args : []+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_deinit" gst_deinit :: +    IO ()+++deinit ::+    (MonadIO m) =>+    m ()                                    -- result+deinit  = liftIO $ do+    gst_deinit+    return ()+++-- function gst_debug_unset_threshold_for_name+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_unset_threshold_for_name" gst_debug_unset_threshold_for_name :: +    CString ->                              -- name : TBasicType TUTF8+    IO ()+++debugUnsetThresholdForName ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> m ()                                 -- result+debugUnsetThresholdForName name = liftIO $ do+    name' <- textToCString name+    gst_debug_unset_threshold_for_name name'+    freeMem name'+    return ()+++-- function gst_debug_set_threshold_from_string+-- Args : [Arg {argCName = "list", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reset", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_set_threshold_from_string" gst_debug_set_threshold_from_string :: +    CString ->                              -- list : TBasicType TUTF8+    CInt ->                                 -- reset : TBasicType TBoolean+    IO ()+++debugSetThresholdFromString ::+    (MonadIO m) =>+    T.Text                                  -- list+    -> Bool                                 -- reset+    -> m ()                                 -- result+debugSetThresholdFromString list reset = liftIO $ do+    list' <- textToCString list+    let reset' = (fromIntegral . fromEnum) reset+    gst_debug_set_threshold_from_string list' reset'+    freeMem list'+    return ()+++-- function gst_debug_set_threshold_for_name+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_set_threshold_for_name" gst_debug_set_threshold_for_name :: +    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"+    IO ()+++debugSetThresholdForName ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> DebugLevel                           -- level+    -> m ()                                 -- result+debugSetThresholdForName name level = liftIO $ do+    name' <- textToCString name+    let level' = (fromIntegral . fromEnum) level+    gst_debug_set_threshold_for_name name' level'+    freeMem name'+    return ()+++-- function gst_debug_set_default_threshold+-- Args : [Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_set_default_threshold" gst_debug_set_default_threshold :: +    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"+    IO ()+++debugSetDefaultThreshold ::+    (MonadIO m) =>+    DebugLevel                              -- level+    -> m ()                                 -- result+debugSetDefaultThreshold level = liftIO $ do+    let level' = (fromIntegral . fromEnum) level+    gst_debug_set_default_threshold level'+    return ()+++-- function gst_debug_set_colored+-- Args : [Arg {argCName = "colored", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_set_colored" gst_debug_set_colored :: +    CInt ->                                 -- colored : TBasicType TBoolean+    IO ()+++debugSetColored ::+    (MonadIO m) =>+    Bool                                    -- colored+    -> m ()                                 -- result+debugSetColored colored = liftIO $ do+    let colored' = (fromIntegral . fromEnum) colored+    gst_debug_set_colored colored'+    return ()+++-- function gst_debug_set_color_mode_from_string+-- Args : [Arg {argCName = "mode", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_set_color_mode_from_string" gst_debug_set_color_mode_from_string :: +    CString ->                              -- mode : TBasicType TUTF8+    IO ()+++debugSetColorModeFromString ::+    (MonadIO m) =>+    T.Text                                  -- mode+    -> m ()                                 -- result+debugSetColorModeFromString mode = liftIO $ do+    mode' <- textToCString mode+    gst_debug_set_color_mode_from_string mode'+    freeMem mode'+    return ()+++-- function gst_debug_set_color_mode+-- Args : [Arg {argCName = "mode", argType = TInterface "Gst" "DebugColorMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_set_color_mode" gst_debug_set_color_mode :: +    CUInt ->                                -- mode : TInterface "Gst" "DebugColorMode"+    IO ()+++debugSetColorMode ::+    (MonadIO m) =>+    DebugColorMode                          -- mode+    -> m ()                                 -- result+debugSetColorMode mode = liftIO $ do+    let mode' = (fromIntegral . fromEnum) mode+    gst_debug_set_color_mode mode'+    return ()+++-- function gst_debug_set_active+-- Args : [Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_set_active" gst_debug_set_active :: +    CInt ->                                 -- active : TBasicType TBoolean+    IO ()+++debugSetActive ::+    (MonadIO m) =>+    Bool                                    -- active+    -> m ()                                 -- result+debugSetActive active = liftIO $ do+    let active' = (fromIntegral . fromEnum) active+    gst_debug_set_active active'+    return ()+++-- function gst_debug_remove_log_function_by_data+-- Args : [Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_remove_log_function_by_data" gst_debug_remove_log_function_by_data :: +    Ptr () ->                               -- data : TBasicType TVoid+    IO Word32+++debugRemoveLogFunctionByData ::+    (MonadIO m) =>+    Ptr ()                                  -- data_+    -> m Word32                             -- result+debugRemoveLogFunctionByData data_ = liftIO $ do+    result <- gst_debug_remove_log_function_by_data data_+    return result+++-- function gst_debug_remove_log_function+-- Args : [Arg {argCName = "func", argType = TInterface "Gst" "LogFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_remove_log_function" gst_debug_remove_log_function :: +    FunPtr LogFunctionC ->                  -- func : TInterface "Gst" "LogFunction"+    IO Word32+++debugRemoveLogFunction ::+    (MonadIO m) =>+    LogFunction                             -- func+    -> m Word32                             -- result+debugRemoveLogFunction func = liftIO $ do+    func' <- mkLogFunction (logFunctionWrapper Nothing func)+    result <- gst_debug_remove_log_function func'+    safeFreeFunPtr $ castFunPtrToPtr func'+    return result+++-- function gst_debug_print_stack_trace+-- Args : []+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_print_stack_trace" gst_debug_print_stack_trace :: +    IO ()+++debugPrintStackTrace ::+    (MonadIO m) =>+    m ()                                    -- result+debugPrintStackTrace  = liftIO $ do+    gst_debug_print_stack_trace+    return ()+++-- function gst_debug_log_default+-- Args : [Arg {argCName = "category", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "function", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "DebugMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_log_default" gst_debug_log_default :: +    Ptr DebugCategory ->                    -- category : TInterface "Gst" "DebugCategory"+    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"+    CString ->                              -- file : TBasicType TUTF8+    CString ->                              -- function : TBasicType TUTF8+    Int32 ->                                -- line : TBasicType TInt32+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    Ptr DebugMessage ->                     -- message : TInterface "Gst" "DebugMessage"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++debugLogDefault ::+    (MonadIO m, GObject.ObjectK a) =>+    DebugCategory                           -- category+    -> DebugLevel                           -- level+    -> T.Text                               -- file+    -> T.Text                               -- function+    -> Int32                                -- line+    -> Maybe (a)                            -- object+    -> DebugMessage                         -- message+    -> Ptr ()                               -- userData+    -> m ()                                 -- result+debugLogDefault category level file function line object message userData = liftIO $ do+    let category' = unsafeManagedPtrGetPtr category+    let level' = (fromIntegral . fromEnum) level+    file' <- textToCString file+    function' <- textToCString function+    maybeObject <- case object of+        Nothing -> return nullPtr+        Just jObject -> do+            let jObject' = unsafeManagedPtrCastPtr jObject+            return jObject'+    let message' = unsafeManagedPtrGetPtr message+    gst_debug_log_default category' level' file' function' line maybeObject message' userData+    touchManagedPtr category+    whenJust object touchManagedPtr+    touchManagedPtr message+    freeMem file'+    freeMem function'+    return ()+++-- function gst_debug_is_colored+-- Args : []+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_is_colored" gst_debug_is_colored :: +    IO CInt+++debugIsColored ::+    (MonadIO m) =>+    m Bool                                  -- result+debugIsColored  = liftIO $ do+    result <- gst_debug_is_colored+    let result' = (/= 0) result+    return result'+++-- function gst_debug_is_active+-- Args : []+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_is_active" gst_debug_is_active :: +    IO CInt+++debugIsActive ::+    (MonadIO m) =>+    m Bool                                  -- result+debugIsActive  = liftIO $ do+    result <- gst_debug_is_active+    let result' = (/= 0) result+    return result'+++-- function gst_debug_get_default_threshold+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "DebugLevel"+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_get_default_threshold" gst_debug_get_default_threshold :: +    IO CUInt+++debugGetDefaultThreshold ::+    (MonadIO m) =>+    m DebugLevel                            -- result+debugGetDefaultThreshold  = liftIO $ do+    result <- gst_debug_get_default_threshold+    let result' = (toEnum . fromIntegral) result+    return result'+++-- function gst_debug_get_color_mode+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "DebugColorMode"+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_get_color_mode" gst_debug_get_color_mode :: +    IO CUInt+++debugGetColorMode ::+    (MonadIO m) =>+    m DebugColorMode                        -- result+debugGetColorMode  = liftIO $ do+    result <- gst_debug_get_color_mode+    let result' = (toEnum . fromIntegral) result+    return result'+++-- function gst_debug_get_all_categories+-- Args : []+-- Lengths : []+-- returnType : TGSList (TInterface "Gst" "DebugCategory")+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_get_all_categories" gst_debug_get_all_categories :: +    IO (Ptr (GSList (Ptr DebugCategory)))+++debugGetAllCategories ::+    (MonadIO m) =>+    m [DebugCategory]                       -- result+debugGetAllCategories  = liftIO $ do+    result <- gst_debug_get_all_categories+    checkUnexpectedReturnNULL "gst_debug_get_all_categories" result+    result' <- unpackGSList result+    result'' <- mapM (newPtr 24 DebugCategory) result'+    g_slist_free result+    return result''+++-- function gst_debug_construct_win_color+-- Args : [Arg {argCName = "colorinfo", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_construct_win_color" gst_debug_construct_win_color :: +    Word32 ->                               -- colorinfo : TBasicType TUInt32+    IO Int32+++debugConstructWinColor ::+    (MonadIO m) =>+    Word32                                  -- colorinfo+    -> m Int32                              -- result+debugConstructWinColor colorinfo = liftIO $ do+    result <- gst_debug_construct_win_color colorinfo+    return result+++-- function gst_debug_construct_term_color+-- Args : [Arg {argCName = "colorinfo", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_construct_term_color" gst_debug_construct_term_color :: +    Word32 ->                               -- colorinfo : TBasicType TUInt32+    IO CString+++debugConstructTermColor ::+    (MonadIO m) =>+    Word32                                  -- colorinfo+    -> m T.Text                             -- result+debugConstructTermColor colorinfo = liftIO $ do+    result <- gst_debug_construct_term_color colorinfo+    checkUnexpectedReturnNULL "gst_debug_construct_term_color" result+    result' <- cstringToText result+    freeMem result+    return result'+++-- function gst_debug_bin_to_dot_file_with_ts+-- Args : [Arg {argCName = "bin", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "details", argType = TInterface "Gst" "DebugGraphDetails", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_bin_to_dot_file_with_ts" gst_debug_bin_to_dot_file_with_ts :: +    Ptr Bin ->                              -- bin : TInterface "Gst" "Bin"+    CUInt ->                                -- details : TInterface "Gst" "DebugGraphDetails"+    CString ->                              -- file_name : TBasicType TUTF8+    IO ()+++debugBinToDotFileWithTs ::+    (MonadIO m, BinK a) =>+    a                                       -- bin+    -> [DebugGraphDetails]                  -- details+    -> T.Text                               -- fileName+    -> m ()                                 -- result+debugBinToDotFileWithTs bin details fileName = liftIO $ do+    let bin' = unsafeManagedPtrCastPtr bin+    let details' = gflagsToWord details+    fileName' <- textToCString fileName+    gst_debug_bin_to_dot_file_with_ts bin' details' fileName'+    touchManagedPtr bin+    freeMem fileName'+    return ()+++-- function gst_debug_bin_to_dot_file+-- Args : [Arg {argCName = "bin", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "details", argType = TInterface "Gst" "DebugGraphDetails", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_bin_to_dot_file" gst_debug_bin_to_dot_file :: +    Ptr Bin ->                              -- bin : TInterface "Gst" "Bin"+    CUInt ->                                -- details : TInterface "Gst" "DebugGraphDetails"+    CString ->                              -- file_name : TBasicType TUTF8+    IO ()+++debugBinToDotFile ::+    (MonadIO m, BinK a) =>+    a                                       -- bin+    -> [DebugGraphDetails]                  -- details+    -> T.Text                               -- fileName+    -> m ()                                 -- result+debugBinToDotFile bin details fileName = liftIO $ do+    let bin' = unsafeManagedPtrCastPtr bin+    let details' = gflagsToWord details+    fileName' <- textToCString fileName+    gst_debug_bin_to_dot_file bin' details' fileName'+    touchManagedPtr bin+    freeMem fileName'+    return ()+++-- function gst_debug_bin_to_dot_data+-- Args : [Arg {argCName = "bin", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "details", argType = TInterface "Gst" "DebugGraphDetails", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_bin_to_dot_data" gst_debug_bin_to_dot_data :: +    Ptr Bin ->                              -- bin : TInterface "Gst" "Bin"+    CUInt ->                                -- details : TInterface "Gst" "DebugGraphDetails"+    IO CString+++debugBinToDotData ::+    (MonadIO m, BinK a) =>+    a                                       -- bin+    -> [DebugGraphDetails]                  -- details+    -> m T.Text                             -- result+debugBinToDotData bin details = liftIO $ do+    let bin' = unsafeManagedPtrCastPtr bin+    let details' = gflagsToWord details+    result <- gst_debug_bin_to_dot_data bin' details'+    checkUnexpectedReturnNULL "gst_debug_bin_to_dot_data" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr bin+    return result'+++-- function gst_debug_add_log_function+-- Args : [Arg {argCName = "func", argType = TInterface "Gst" "LogFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 1, argDestroy = 2, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_add_log_function" gst_debug_add_log_function :: +    FunPtr LogFunctionC ->                  -- func : TInterface "Gst" "LogFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++debugAddLogFunction ::+    (MonadIO m) =>+    LogFunction                             -- func+    -> m ()                                 -- result+debugAddLogFunction func = liftIO $ do+    func' <- mkLogFunction (logFunctionWrapper Nothing func)+    let userData = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    gst_debug_add_log_function func' userData notify+    return ()+++
+ GI/Gst/Interfaces.hs view
@@ -0,0 +1,35 @@+++{- |+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.Interfaces+    (     module GI.Gst.Interfaces.ChildProxy     ,+    module GI.Gst.Interfaces.Preset         ,+    module GI.Gst.Interfaces.TagSetter      ,+    module GI.Gst.Interfaces.TocSetter      ,+    module GI.Gst.Interfaces.URIHandler     ,+++    ) where++import GI.Gst.Interfaces.ChildProxy+import GI.Gst.Interfaces.Preset+import GI.Gst.Interfaces.TagSetter+import GI.Gst.Interfaces.TocSetter+import GI.Gst.Interfaces.URIHandler++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 GI.Gst.Callbacks++
+ GI/Gst/Interfaces/ChildProxy.hs view
@@ -0,0 +1,542 @@+++{- |+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.Interfaces.ChildProxy+    ( ++-- * Exported types+    ChildProxy(..)                          ,+    noChildProxy                            ,+    ChildProxyK                             ,+    toChildProxy                            ,+++ -- * Methods+-- ** childProxyChildAdded+    ChildProxyChildAddedMethodInfo          ,+    childProxyChildAdded                    ,+++-- ** childProxyChildRemoved+    ChildProxyChildRemovedMethodInfo        ,+    childProxyChildRemoved                  ,+++-- ** childProxyGetChildByIndex+    ChildProxyGetChildByIndexMethodInfo     ,+    childProxyGetChildByIndex               ,+++-- ** childProxyGetChildByName+    ChildProxyGetChildByNameMethodInfo      ,+    childProxyGetChildByName                ,+++-- ** childProxyGetChildrenCount+    ChildProxyGetChildrenCountMethodInfo    ,+    childProxyGetChildrenCount              ,+++-- ** childProxyGetProperty+    ChildProxyGetPropertyMethodInfo         ,+    childProxyGetProperty                   ,+++-- ** childProxyLookup+    ChildProxyLookupMethodInfo              ,+    childProxyLookup                        ,+++-- ** childProxySetProperty+    ChildProxySetPropertyMethodInfo         ,+    childProxySetProperty                   ,+++++ -- * Signals+-- ** ChildAdded+    ChildProxyChildAddedCallback            ,+    ChildProxyChildAddedCallbackC           ,+    ChildProxyChildAddedSignalInfo          ,+    afterChildProxyChildAdded               ,+    childProxyChildAddedCallbackWrapper     ,+    childProxyChildAddedClosure             ,+    mkChildProxyChildAddedCallback          ,+    noChildProxyChildAddedCallback          ,+    onChildProxyChildAdded                  ,+++-- ** ChildRemoved+    ChildProxyChildRemovedCallback          ,+    ChildProxyChildRemovedCallbackC         ,+    ChildProxyChildRemovedSignalInfo        ,+    afterChildProxyChildRemoved             ,+    childProxyChildRemovedCallbackWrapper   ,+    childProxyChildRemovedClosure           ,+    mkChildProxyChildRemovedCallback        ,+    noChildProxyChildRemovedCallback        ,+    onChildProxyChildRemoved                ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++-- interface ChildProxy ++newtype ChildProxy = ChildProxy (ForeignPtr ChildProxy)+noChildProxy :: Maybe ChildProxy+noChildProxy = Nothing++type family ResolveChildProxyMethod (t :: Symbol) (o :: *) :: * where+    ResolveChildProxyMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveChildProxyMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveChildProxyMethod "childAdded" o = ChildProxyChildAddedMethodInfo+    ResolveChildProxyMethod "childRemoved" o = ChildProxyChildRemovedMethodInfo+    ResolveChildProxyMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveChildProxyMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveChildProxyMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveChildProxyMethod "lookup" o = ChildProxyLookupMethodInfo+    ResolveChildProxyMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveChildProxyMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveChildProxyMethod "ref" o = GObject.ObjectRefMethodInfo+    ResolveChildProxyMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveChildProxyMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveChildProxyMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveChildProxyMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveChildProxyMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveChildProxyMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveChildProxyMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveChildProxyMethod "unref" o = GObject.ObjectUnrefMethodInfo+    ResolveChildProxyMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveChildProxyMethod "getChildByIndex" o = ChildProxyGetChildByIndexMethodInfo+    ResolveChildProxyMethod "getChildByName" o = ChildProxyGetChildByNameMethodInfo+    ResolveChildProxyMethod "getChildrenCount" o = ChildProxyGetChildrenCountMethodInfo+    ResolveChildProxyMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveChildProxyMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveChildProxyMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveChildProxyMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveChildProxyMethod t ChildProxy, MethodInfo info ChildProxy p) => IsLabelProxy t (ChildProxy -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveChildProxyMethod t ChildProxy, MethodInfo info ChildProxy p) => IsLabel t (ChildProxy -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal ChildProxy::child-added+type ChildProxyChildAddedCallback =+    GObject.Object ->+    T.Text ->+    IO ()++noChildProxyChildAddedCallback :: Maybe ChildProxyChildAddedCallback+noChildProxyChildAddedCallback = Nothing++type ChildProxyChildAddedCallbackC =+    Ptr () ->                               -- object+    Ptr GObject.Object ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkChildProxyChildAddedCallback :: ChildProxyChildAddedCallbackC -> IO (FunPtr ChildProxyChildAddedCallbackC)++childProxyChildAddedClosure :: ChildProxyChildAddedCallback -> IO Closure+childProxyChildAddedClosure cb = newCClosure =<< mkChildProxyChildAddedCallback wrapped+    where wrapped = childProxyChildAddedCallbackWrapper cb++childProxyChildAddedCallbackWrapper ::+    ChildProxyChildAddedCallback ->+    Ptr () ->+    Ptr GObject.Object ->+    CString ->+    Ptr () ->+    IO ()+childProxyChildAddedCallbackWrapper _cb _ object name _ = do+    object' <- (newObject GObject.Object) object+    name' <- cstringToText name+    _cb  object' name'++onChildProxyChildAdded :: (GObject a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId+onChildProxyChildAdded obj cb = liftIO $ connectChildProxyChildAdded obj cb SignalConnectBefore+afterChildProxyChildAdded :: (GObject a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId+afterChildProxyChildAdded obj cb = connectChildProxyChildAdded obj cb SignalConnectAfter++connectChildProxyChildAdded :: (GObject a, MonadIO m) =>+                               a -> ChildProxyChildAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectChildProxyChildAdded obj cb after = liftIO $ do+    cb' <- mkChildProxyChildAddedCallback (childProxyChildAddedCallbackWrapper cb)+    connectSignalFunPtr obj "child-added" cb' after++-- signal ChildProxy::child-removed+type ChildProxyChildRemovedCallback =+    GObject.Object ->+    T.Text ->+    IO ()++noChildProxyChildRemovedCallback :: Maybe ChildProxyChildRemovedCallback+noChildProxyChildRemovedCallback = Nothing++type ChildProxyChildRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr GObject.Object ->+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkChildProxyChildRemovedCallback :: ChildProxyChildRemovedCallbackC -> IO (FunPtr ChildProxyChildRemovedCallbackC)++childProxyChildRemovedClosure :: ChildProxyChildRemovedCallback -> IO Closure+childProxyChildRemovedClosure cb = newCClosure =<< mkChildProxyChildRemovedCallback wrapped+    where wrapped = childProxyChildRemovedCallbackWrapper cb++childProxyChildRemovedCallbackWrapper ::+    ChildProxyChildRemovedCallback ->+    Ptr () ->+    Ptr GObject.Object ->+    CString ->+    Ptr () ->+    IO ()+childProxyChildRemovedCallbackWrapper _cb _ object name _ = do+    object' <- (newObject GObject.Object) object+    name' <- cstringToText name+    _cb  object' name'++onChildProxyChildRemoved :: (GObject a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId+onChildProxyChildRemoved obj cb = liftIO $ connectChildProxyChildRemoved obj cb SignalConnectBefore+afterChildProxyChildRemoved :: (GObject a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId+afterChildProxyChildRemoved obj cb = connectChildProxyChildRemoved obj cb SignalConnectAfter++connectChildProxyChildRemoved :: (GObject a, MonadIO m) =>+                                 a -> ChildProxyChildRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectChildProxyChildRemoved obj cb after = liftIO $ do+    cb' <- mkChildProxyChildRemovedCallback (childProxyChildRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "child-removed" cb' after++type instance AttributeList ChildProxy = ChildProxyAttributeList+type ChildProxyAttributeList = ('[ ] :: [(Symbol, *)])++data ChildProxyChildAddedSignalInfo+instance SignalInfo ChildProxyChildAddedSignalInfo where+    type HaskellCallbackType ChildProxyChildAddedSignalInfo = ChildProxyChildAddedCallback+    connectSignal _ = connectChildProxyChildAdded++data ChildProxyChildRemovedSignalInfo+instance SignalInfo ChildProxyChildRemovedSignalInfo where+    type HaskellCallbackType ChildProxyChildRemovedSignalInfo = ChildProxyChildRemovedCallback+    connectSignal _ = connectChildProxyChildRemoved++type instance SignalList ChildProxy = ChildProxySignalList+type ChildProxySignalList = ('[ '("childAdded", ChildProxyChildAddedSignalInfo), '("childRemoved", ChildProxyChildRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++foreign import ccall "gst_child_proxy_get_type"+    c_gst_child_proxy_get_type :: IO GType++type instance ParentTypes ChildProxy = ChildProxyParentTypes+type ChildProxyParentTypes = '[GObject.Object]++instance GObject ChildProxy where+    gobjectIsInitiallyUnowned _ = False+    gobjectType _ = c_gst_child_proxy_get_type+    ++class GObject o => ChildProxyK o+instance (GObject o, IsDescendantOf ChildProxy o) => ChildProxyK o++toChildProxy :: ChildProxyK o => o -> IO ChildProxy+toChildProxy = unsafeCastTo ChildProxy++-- method ChildProxy::child_added+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_child_added" gst_child_proxy_child_added :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++childProxyChildAdded ::+    (MonadIO m, ChildProxyK a, GObject.ObjectK b) =>+    a                                       -- _obj+    -> b                                    -- child+    -> T.Text                               -- name+    -> m ()                                 -- result+childProxyChildAdded _obj child name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    name' <- textToCString name+    gst_child_proxy_child_added _obj' child' name'+    touchManagedPtr _obj+    touchManagedPtr child+    freeMem name'+    return ()++data ChildProxyChildAddedMethodInfo+instance (signature ~ (b -> T.Text -> m ()), MonadIO m, ChildProxyK a, GObject.ObjectK b) => MethodInfo ChildProxyChildAddedMethodInfo a signature where+    overloadedMethod _ = childProxyChildAdded++-- method ChildProxy::child_removed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_child_removed" gst_child_proxy_child_removed :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++childProxyChildRemoved ::+    (MonadIO m, ChildProxyK a, GObject.ObjectK b) =>+    a                                       -- _obj+    -> b                                    -- child+    -> T.Text                               -- name+    -> m ()                                 -- result+childProxyChildRemoved _obj child name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let child' = unsafeManagedPtrCastPtr child+    name' <- textToCString name+    gst_child_proxy_child_removed _obj' child' name'+    touchManagedPtr _obj+    touchManagedPtr child+    freeMem name'+    return ()++data ChildProxyChildRemovedMethodInfo+instance (signature ~ (b -> T.Text -> m ()), MonadIO m, ChildProxyK a, GObject.ObjectK b) => MethodInfo ChildProxyChildRemovedMethodInfo a signature where+    overloadedMethod _ = childProxyChildRemoved++-- method ChildProxy::get_child_by_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_get_child_by_index" gst_child_proxy_get_child_by_index :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    Word32 ->                               -- index : TBasicType TUInt32+    IO (Ptr GObject.Object)+++childProxyGetChildByIndex ::+    (MonadIO m, ChildProxyK a) =>+    a                                       -- _obj+    -> Word32                               -- index+    -> m GObject.Object                     -- result+childProxyGetChildByIndex _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_child_proxy_get_child_by_index _obj' index+    checkUnexpectedReturnNULL "gst_child_proxy_get_child_by_index" result+    result' <- (wrapObject GObject.Object) result+    touchManagedPtr _obj+    return result'++data ChildProxyGetChildByIndexMethodInfo+instance (signature ~ (Word32 -> m GObject.Object), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetChildByIndexMethodInfo a signature where+    overloadedMethod _ = childProxyGetChildByIndex++-- method ChildProxy::get_child_by_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_get_child_by_name" gst_child_proxy_get_child_by_name :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr GObject.Object)+++childProxyGetChildByName ::+    (MonadIO m, ChildProxyK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m GObject.Object                     -- result+childProxyGetChildByName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_child_proxy_get_child_by_name _obj' name'+    checkUnexpectedReturnNULL "gst_child_proxy_get_child_by_name" result+    result' <- (wrapObject GObject.Object) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data ChildProxyGetChildByNameMethodInfo+instance (signature ~ (T.Text -> m GObject.Object), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetChildByNameMethodInfo a signature where+    overloadedMethod _ = childProxyGetChildByName++-- method ChildProxy::get_children_count+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_get_children_count" gst_child_proxy_get_children_count :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    IO Word32+++childProxyGetChildrenCount ::+    (MonadIO m, ChildProxyK a) =>+    a                                       -- _obj+    -> m Word32                             -- result+childProxyGetChildrenCount _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_child_proxy_get_children_count _obj'+    touchManagedPtr _obj+    return result++data ChildProxyGetChildrenCountMethodInfo+instance (signature ~ (m Word32), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetChildrenCountMethodInfo a signature where+    overloadedMethod _ = childProxyGetChildrenCount++-- method ChildProxy::get_property+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_get_property" gst_child_proxy_get_property :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    CString ->                              -- name : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++childProxyGetProperty ::+    (MonadIO m, ChildProxyK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m (GValue)                           -- result+childProxyGetProperty _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)+    gst_child_proxy_get_property _obj' name' value+    value' <- (wrapBoxed GValue) value+    touchManagedPtr _obj+    freeMem name'+    return value'++data ChildProxyGetPropertyMethodInfo+instance (signature ~ (T.Text -> m (GValue)), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetPropertyMethodInfo a signature where+    overloadedMethod _ = childProxyGetProperty++-- method ChildProxy::lookup+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface "GObject" "Object", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_lookup" gst_child_proxy_lookup :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    CString ->                              -- name : TBasicType TUTF8+    Ptr (Ptr GObject.Object) ->             -- target : TInterface "GObject" "Object"+    Ptr (Ptr GParamSpec) ->                 -- pspec : TParamSpec+    IO CInt+++childProxyLookup ::+    (MonadIO m, ChildProxyK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m (Bool,GObject.Object,GParamSpec)   -- result+childProxyLookup _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    target <- allocMem :: IO (Ptr (Ptr GObject.Object))+    pspec <- allocMem :: IO (Ptr (Ptr GParamSpec))+    result <- gst_child_proxy_lookup _obj' name' target pspec+    let result' = (/= 0) result+    target' <- peek target+    target'' <- (wrapObject GObject.Object) target'+    pspec' <- peek pspec+    pspec'' <- newGParamSpecFromPtr pspec'+    touchManagedPtr _obj+    freeMem name'+    freeMem target+    freeMem pspec+    return (result', target'', pspec'')++data ChildProxyLookupMethodInfo+instance (signature ~ (T.Text -> m (Bool,GObject.Object,GParamSpec)), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyLookupMethodInfo a signature where+    overloadedMethod _ = childProxyLookup++-- method ChildProxy::set_property+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_child_proxy_set_property" gst_child_proxy_set_property :: +    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"+    CString ->                              -- name : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++childProxySetProperty ::+    (MonadIO m, ChildProxyK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> GValue                               -- value+    -> m ()                                 -- result+childProxySetProperty _obj name value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    let value' = unsafeManagedPtrGetPtr value+    gst_child_proxy_set_property _obj' name' value'+    touchManagedPtr _obj+    touchManagedPtr value+    freeMem name'+    return ()++data ChildProxySetPropertyMethodInfo+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, ChildProxyK a) => MethodInfo ChildProxySetPropertyMethodInfo a signature where+    overloadedMethod _ = childProxySetProperty++
+ GI/Gst/Interfaces/ChildProxy.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gst.Interfaces.ChildProxy 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++newtype ChildProxy = ChildProxy (ForeignPtr ChildProxy)+data ChildProxyChildAddedSignalInfo+data ChildProxyChildRemovedSignalInfo+instance GObject ChildProxy where+class GObject o => ChildProxyK o+instance (GObject o, IsDescendantOf ChildProxy o) => ChildProxyK o+data ChildProxyChildAddedMethodInfo+data ChildProxyChildRemovedMethodInfo+data ChildProxyGetChildByIndexMethodInfo+data ChildProxyGetChildByNameMethodInfo+data ChildProxyGetChildrenCountMethodInfo+data ChildProxyGetPropertyMethodInfo+data ChildProxyLookupMethodInfo+data ChildProxySetPropertyMethodInfo
+ GI/Gst/Interfaces/Preset.hs view
@@ -0,0 +1,476 @@+++{- |+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.Interfaces.Preset+    ( ++-- * Exported types+    Preset(..)                              ,+    noPreset                                ,+    PresetK                                 ,+++ -- * Methods+-- ** presetDeletePreset+    PresetDeletePresetMethodInfo            ,+    presetDeletePreset                      ,+++-- ** presetGetAppDir+    presetGetAppDir                         ,+++-- ** presetGetMeta+    PresetGetMetaMethodInfo                 ,+    presetGetMeta                           ,+++-- ** presetGetPresetNames+    PresetGetPresetNamesMethodInfo          ,+    presetGetPresetNames                    ,+++-- ** presetGetPropertyNames+    PresetGetPropertyNamesMethodInfo        ,+    presetGetPropertyNames                  ,+++-- ** presetIsEditable+    PresetIsEditableMethodInfo              ,+    presetIsEditable                        ,+++-- ** presetLoadPreset+    PresetLoadPresetMethodInfo              ,+    presetLoadPreset                        ,+++-- ** presetRenamePreset+    PresetRenamePresetMethodInfo            ,+    presetRenamePreset                      ,+++-- ** presetSavePreset+    PresetSavePresetMethodInfo              ,+    presetSavePreset                        ,+++-- ** presetSetAppDir+    presetSetAppDir                         ,+++-- ** presetSetMeta+    PresetSetMetaMethodInfo                 ,+    presetSetMeta                           ,+++++    ) 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 GI.Gst.Callbacks++-- interface Preset ++newtype Preset = Preset (ForeignPtr Preset)+noPreset :: Maybe Preset+noPreset = Nothing++type family ResolvePresetMethod (t :: Symbol) (o :: *) :: * where+    ResolvePresetMethod "deletePreset" o = PresetDeletePresetMethodInfo+    ResolvePresetMethod "isEditable" o = PresetIsEditableMethodInfo+    ResolvePresetMethod "loadPreset" o = PresetLoadPresetMethodInfo+    ResolvePresetMethod "renamePreset" o = PresetRenamePresetMethodInfo+    ResolvePresetMethod "savePreset" o = PresetSavePresetMethodInfo+    ResolvePresetMethod "getMeta" o = PresetGetMetaMethodInfo+    ResolvePresetMethod "getPresetNames" o = PresetGetPresetNamesMethodInfo+    ResolvePresetMethod "getPropertyNames" o = PresetGetPropertyNamesMethodInfo+    ResolvePresetMethod "setMeta" o = PresetSetMetaMethodInfo+    ResolvePresetMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePresetMethod t Preset, MethodInfo info Preset p) => IsLabelProxy t (Preset -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePresetMethod t Preset, MethodInfo info Preset p) => IsLabel t (Preset -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList Preset = PresetAttributeList+type PresetAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList Preset = PresetSignalList+type PresetSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => PresetK a+instance (ForeignPtrNewtype o, IsDescendantOf Preset o) => PresetK o+type instance ParentTypes Preset = PresetParentTypes+type PresetParentTypes = '[]++-- method Preset::delete_preset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_delete_preset" gst_preset_delete_preset :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++presetDeletePreset ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Bool                               -- result+presetDeletePreset _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_preset_delete_preset _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data PresetDeletePresetMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetDeletePresetMethodInfo a signature where+    overloadedMethod _ = presetDeletePreset++-- method Preset::get_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_get_meta" gst_preset_get_meta :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- tag : TBasicType TUTF8+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt+++presetGetMeta ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> T.Text                               -- tag+    -> m (Bool,T.Text)                      -- result+presetGetMeta _obj name tag = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CString)+    result <- gst_preset_get_meta _obj' name' tag' value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- cstringToText value'+    freeMem value'+    touchManagedPtr _obj+    freeMem name'+    freeMem tag'+    freeMem value+    return (result', value'')++data PresetGetMetaMethodInfo+instance (signature ~ (T.Text -> T.Text -> m (Bool,T.Text)), MonadIO m, PresetK a) => MethodInfo PresetGetMetaMethodInfo a signature where+    overloadedMethod _ = presetGetMeta++-- method Preset::get_preset_names+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_get_preset_names" gst_preset_get_preset_names :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    IO (Ptr CString)+++presetGetPresetNames ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+presetGetPresetNames _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_preset_get_preset_names _obj'+    checkUnexpectedReturnNULL "gst_preset_get_preset_names" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++data PresetGetPresetNamesMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, PresetK a) => MethodInfo PresetGetPresetNamesMethodInfo a signature where+    overloadedMethod _ = presetGetPresetNames++-- method Preset::get_property_names+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_get_property_names" gst_preset_get_property_names :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    IO (Ptr CString)+++presetGetPropertyNames ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+presetGetPropertyNames _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_preset_get_property_names _obj'+    checkUnexpectedReturnNULL "gst_preset_get_property_names" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++data PresetGetPropertyNamesMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, PresetK a) => MethodInfo PresetGetPropertyNamesMethodInfo a signature where+    overloadedMethod _ = presetGetPropertyNames++-- method Preset::is_editable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_is_editable" gst_preset_is_editable :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    IO CInt+++presetIsEditable ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+presetIsEditable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_preset_is_editable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PresetIsEditableMethodInfo+instance (signature ~ (m Bool), MonadIO m, PresetK a) => MethodInfo PresetIsEditableMethodInfo a signature where+    overloadedMethod _ = presetIsEditable++-- method Preset::load_preset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_load_preset" gst_preset_load_preset :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++presetLoadPreset ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Bool                               -- result+presetLoadPreset _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_preset_load_preset _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data PresetLoadPresetMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetLoadPresetMethodInfo a signature where+    overloadedMethod _ = presetLoadPreset++-- method Preset::rename_preset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_rename_preset" gst_preset_rename_preset :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    CString ->                              -- old_name : TBasicType TUTF8+    CString ->                              -- new_name : TBasicType TUTF8+    IO CInt+++presetRenamePreset ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> T.Text                               -- oldName+    -> T.Text                               -- newName+    -> m Bool                               -- result+presetRenamePreset _obj oldName newName = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    oldName' <- textToCString oldName+    newName' <- textToCString newName+    result <- gst_preset_rename_preset _obj' oldName' newName'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem oldName'+    freeMem newName'+    return result'++data PresetRenamePresetMethodInfo+instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetRenamePresetMethodInfo a signature where+    overloadedMethod _ = presetRenamePreset++-- method Preset::save_preset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_save_preset" gst_preset_save_preset :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++presetSavePreset ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Bool                               -- result+presetSavePreset _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_preset_save_preset _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data PresetSavePresetMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetSavePresetMethodInfo a signature where+    overloadedMethod _ = presetSavePreset++-- method Preset::set_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_set_meta" gst_preset_set_meta :: +    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- tag : TBasicType TUTF8+    CString ->                              -- value : TBasicType TUTF8+    IO CInt+++presetSetMeta ::+    (MonadIO m, PresetK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> T.Text                               -- tag+    -> Maybe (T.Text)                       -- value+    -> m Bool                               -- result+presetSetMeta _obj name tag value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    tag' <- textToCString tag+    maybeValue <- case value of+        Nothing -> return nullPtr+        Just jValue -> do+            jValue' <- textToCString jValue+            return jValue'+    result <- gst_preset_set_meta _obj' name' tag' maybeValue+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    freeMem tag'+    freeMem maybeValue+    return result'++data PresetSetMetaMethodInfo+instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetSetMetaMethodInfo a signature where+    overloadedMethod _ = presetSetMeta++-- method Preset::get_app_dir+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_get_app_dir" gst_preset_get_app_dir :: +    IO CString+++presetGetAppDir ::+    (MonadIO m) =>+    m T.Text                                -- result+presetGetAppDir  = liftIO $ do+    result <- gst_preset_get_app_dir+    checkUnexpectedReturnNULL "gst_preset_get_app_dir" result+    result' <- cstringToText result+    return result'++-- method Preset::set_app_dir+-- method type : MemberFunction+-- Args : [Arg {argCName = "app_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_preset_set_app_dir" gst_preset_set_app_dir :: +    CString ->                              -- app_dir : TBasicType TUTF8+    IO CInt+++presetSetAppDir ::+    (MonadIO m) =>+    T.Text                                  -- appDir+    -> m Bool                               -- result+presetSetAppDir appDir = liftIO $ do+    appDir' <- textToCString appDir+    result <- gst_preset_set_app_dir appDir'+    let result' = (/= 0) result+    freeMem appDir'+    return result'++
+ GI/Gst/Interfaces/Preset.hs-boot view
@@ -0,0 +1,21 @@+module GI.Gst.Interfaces.Preset 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++newtype Preset = Preset (ForeignPtr Preset)+class ForeignPtrNewtype a => PresetK a+instance (ForeignPtrNewtype o, IsDescendantOf Preset o) => PresetK o+data PresetDeletePresetMethodInfo+data PresetGetMetaMethodInfo+data PresetGetPresetNamesMethodInfo+data PresetGetPropertyNamesMethodInfo+data PresetIsEditableMethodInfo+data PresetLoadPresetMethodInfo+data PresetRenamePresetMethodInfo+data PresetSavePresetMethodInfo+data PresetSetMetaMethodInfo
+ GI/Gst/Interfaces/TagSetter.hs view
@@ -0,0 +1,389 @@+++{- |+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.Interfaces.TagSetter+    ( ++-- * Exported types+    TagSetter(..)                           ,+    noTagSetter                             ,+    TagSetterK                              ,+    toTagSetter                             ,+++ -- * Methods+-- ** tagSetterAddTagValue+    TagSetterAddTagValueMethodInfo          ,+    tagSetterAddTagValue                    ,+++-- ** tagSetterGetTagList+    TagSetterGetTagListMethodInfo           ,+    tagSetterGetTagList                     ,+++-- ** tagSetterGetTagMergeMode+    TagSetterGetTagMergeModeMethodInfo      ,+    tagSetterGetTagMergeMode                ,+++-- ** tagSetterMergeTags+    TagSetterMergeTagsMethodInfo            ,+    tagSetterMergeTags                      ,+++-- ** tagSetterResetTags+    TagSetterResetTagsMethodInfo            ,+    tagSetterResetTags                      ,+++-- ** tagSetterSetTagMergeMode+    TagSetterSetTagMergeModeMethodInfo      ,+    tagSetterSetTagMergeMode                ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++-- interface TagSetter ++newtype TagSetter = TagSetter (ForeignPtr TagSetter)+noTagSetter :: Maybe TagSetter+noTagSetter = Nothing++type family ResolveTagSetterMethod (t :: Symbol) (o :: *) :: * where+    ResolveTagSetterMethod "abortState" o = ElementAbortStateMethodInfo+    ResolveTagSetterMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveTagSetterMethod "addPad" o = ElementAddPadMethodInfo+    ResolveTagSetterMethod "addTagValue" o = TagSetterAddTagValueMethodInfo+    ResolveTagSetterMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveTagSetterMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveTagSetterMethod "changeState" o = ElementChangeStateMethodInfo+    ResolveTagSetterMethod "continueState" o = ElementContinueStateMethodInfo+    ResolveTagSetterMethod "createAllPads" o = ElementCreateAllPadsMethodInfo+    ResolveTagSetterMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveTagSetterMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveTagSetterMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveTagSetterMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveTagSetterMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveTagSetterMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveTagSetterMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveTagSetterMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveTagSetterMethod "isLockedState" o = ElementIsLockedStateMethodInfo+    ResolveTagSetterMethod "iteratePads" o = ElementIteratePadsMethodInfo+    ResolveTagSetterMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo+    ResolveTagSetterMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo+    ResolveTagSetterMethod "link" o = ElementLinkMethodInfo+    ResolveTagSetterMethod "linkFiltered" o = ElementLinkFilteredMethodInfo+    ResolveTagSetterMethod "linkPads" o = ElementLinkPadsMethodInfo+    ResolveTagSetterMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo+    ResolveTagSetterMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo+    ResolveTagSetterMethod "lostState" o = ElementLostStateMethodInfo+    ResolveTagSetterMethod "mergeTags" o = TagSetterMergeTagsMethodInfo+    ResolveTagSetterMethod "messageFull" o = ElementMessageFullMethodInfo+    ResolveTagSetterMethod "noMorePads" o = ElementNoMorePadsMethodInfo+    ResolveTagSetterMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveTagSetterMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveTagSetterMethod "postMessage" o = ElementPostMessageMethodInfo+    ResolveTagSetterMethod "provideClock" o = ElementProvideClockMethodInfo+    ResolveTagSetterMethod "query" o = ElementQueryMethodInfo+    ResolveTagSetterMethod "queryConvert" o = ElementQueryConvertMethodInfo+    ResolveTagSetterMethod "queryDuration" o = ElementQueryDurationMethodInfo+    ResolveTagSetterMethod "queryPosition" o = ElementQueryPositionMethodInfo+    ResolveTagSetterMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveTagSetterMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo+    ResolveTagSetterMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveTagSetterMethod "removePad" o = ElementRemovePadMethodInfo+    ResolveTagSetterMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveTagSetterMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveTagSetterMethod "requestPad" o = ElementRequestPadMethodInfo+    ResolveTagSetterMethod "resetTags" o = TagSetterResetTagsMethodInfo+    ResolveTagSetterMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveTagSetterMethod "seek" o = ElementSeekMethodInfo+    ResolveTagSetterMethod "seekSimple" o = ElementSeekSimpleMethodInfo+    ResolveTagSetterMethod "sendEvent" o = ElementSendEventMethodInfo+    ResolveTagSetterMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveTagSetterMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveTagSetterMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveTagSetterMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo+    ResolveTagSetterMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveTagSetterMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveTagSetterMethod "unlink" o = ElementUnlinkMethodInfo+    ResolveTagSetterMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo+    ResolveTagSetterMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveTagSetterMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveTagSetterMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo+    ResolveTagSetterMethod "getBus" o = ElementGetBusMethodInfo+    ResolveTagSetterMethod "getClock" o = ElementGetClockMethodInfo+    ResolveTagSetterMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo+    ResolveTagSetterMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo+    ResolveTagSetterMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveTagSetterMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveTagSetterMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveTagSetterMethod "getFactory" o = ElementGetFactoryMethodInfo+    ResolveTagSetterMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveTagSetterMethod "getName" o = ObjectGetNameMethodInfo+    ResolveTagSetterMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveTagSetterMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveTagSetterMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveTagSetterMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveTagSetterMethod "getRequestPad" o = ElementGetRequestPadMethodInfo+    ResolveTagSetterMethod "getStartTime" o = ElementGetStartTimeMethodInfo+    ResolveTagSetterMethod "getState" o = ElementGetStateMethodInfo+    ResolveTagSetterMethod "getStaticPad" o = ElementGetStaticPadMethodInfo+    ResolveTagSetterMethod "getTagList" o = TagSetterGetTagListMethodInfo+    ResolveTagSetterMethod "getTagMergeMode" o = TagSetterGetTagMergeModeMethodInfo+    ResolveTagSetterMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveTagSetterMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveTagSetterMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo+    ResolveTagSetterMethod "setBus" o = ElementSetBusMethodInfo+    ResolveTagSetterMethod "setClock" o = ElementSetClockMethodInfo+    ResolveTagSetterMethod "setContext" o = ElementSetContextMethodInfo+    ResolveTagSetterMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveTagSetterMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveTagSetterMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveTagSetterMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveTagSetterMethod "setLockedState" o = ElementSetLockedStateMethodInfo+    ResolveTagSetterMethod "setName" o = ObjectSetNameMethodInfo+    ResolveTagSetterMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveTagSetterMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveTagSetterMethod "setStartTime" o = ElementSetStartTimeMethodInfo+    ResolveTagSetterMethod "setState" o = ElementSetStateMethodInfo+    ResolveTagSetterMethod "setTagMergeMode" o = TagSetterSetTagMergeModeMethodInfo+    ResolveTagSetterMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTagSetterMethod t TagSetter, MethodInfo info TagSetter p) => IsLabelProxy t (TagSetter -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTagSetterMethod t TagSetter, MethodInfo info TagSetter p) => IsLabel t (TagSetter -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList TagSetter = TagSetterAttributeList+type TagSetterAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TagSetter = TagSetterSignalList+type TagSetterSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++foreign import ccall "gst_tag_setter_get_type"+    c_gst_tag_setter_get_type :: IO GType++type instance ParentTypes TagSetter = TagSetterParentTypes+type TagSetterParentTypes = '[Element, Object, GObject.Object]++instance GObject TagSetter where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_tag_setter_get_type+    ++class GObject o => TagSetterK o+instance (GObject o, IsDescendantOf TagSetter o) => TagSetterK o++toTagSetter :: TagSetterK o => o -> IO TagSetter+toTagSetter = unsafeCastTo TagSetter++-- method TagSetter::add_tag_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_setter_add_tag_value" gst_tag_setter_add_tag_value :: +    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++tagSetterAddTagValue ::+    (MonadIO m, TagSetterK a) =>+    a                                       -- _obj+    -> TagMergeMode                         -- mode+    -> T.Text                               -- tag+    -> GValue                               -- value+    -> m ()                                 -- result+tagSetterAddTagValue _obj mode tag value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    tag' <- textToCString tag+    let value' = unsafeManagedPtrGetPtr value+    gst_tag_setter_add_tag_value _obj' mode' tag' value'+    touchManagedPtr _obj+    touchManagedPtr value+    freeMem tag'+    return ()++data TagSetterAddTagValueMethodInfo+instance (signature ~ (TagMergeMode -> T.Text -> GValue -> m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterAddTagValueMethodInfo a signature where+    overloadedMethod _ = tagSetterAddTagValue++-- method TagSetter::get_tag_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_setter_get_tag_list" gst_tag_setter_get_tag_list :: +    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"+    IO (Ptr TagList)+++tagSetterGetTagList ::+    (MonadIO m, TagSetterK a) =>+    a                                       -- _obj+    -> m TagList                            -- result+tagSetterGetTagList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_tag_setter_get_tag_list _obj'+    checkUnexpectedReturnNULL "gst_tag_setter_get_tag_list" result+    result' <- (newBoxed TagList) result+    touchManagedPtr _obj+    return result'++data TagSetterGetTagListMethodInfo+instance (signature ~ (m TagList), MonadIO m, TagSetterK a) => MethodInfo TagSetterGetTagListMethodInfo a signature where+    overloadedMethod _ = tagSetterGetTagList++-- method TagSetter::get_tag_merge_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagMergeMode"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_setter_get_tag_merge_mode" gst_tag_setter_get_tag_merge_mode :: +    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"+    IO CUInt+++tagSetterGetTagMergeMode ::+    (MonadIO m, TagSetterK a) =>+    a                                       -- _obj+    -> m TagMergeMode                       -- result+tagSetterGetTagMergeMode _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_tag_setter_get_tag_merge_mode _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data TagSetterGetTagMergeModeMethodInfo+instance (signature ~ (m TagMergeMode), MonadIO m, TagSetterK a) => MethodInfo TagSetterGetTagMergeModeMethodInfo a signature where+    overloadedMethod _ = tagSetterGetTagMergeMode++-- method TagSetter::merge_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_setter_merge_tags" gst_tag_setter_merge_tags :: +    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"+    Ptr TagList ->                          -- list : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO ()+++tagSetterMergeTags ::+    (MonadIO m, TagSetterK a) =>+    a                                       -- _obj+    -> TagList                              -- list+    -> TagMergeMode                         -- mode+    -> m ()                                 -- result+tagSetterMergeTags _obj list mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let list' = unsafeManagedPtrGetPtr list+    let mode' = (fromIntegral . fromEnum) mode+    gst_tag_setter_merge_tags _obj' list' mode'+    touchManagedPtr _obj+    touchManagedPtr list+    return ()++data TagSetterMergeTagsMethodInfo+instance (signature ~ (TagList -> TagMergeMode -> m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterMergeTagsMethodInfo a signature where+    overloadedMethod _ = tagSetterMergeTags++-- method TagSetter::reset_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_setter_reset_tags" gst_tag_setter_reset_tags :: +    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"+    IO ()+++tagSetterResetTags ::+    (MonadIO m, TagSetterK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+tagSetterResetTags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_tag_setter_reset_tags _obj'+    touchManagedPtr _obj+    return ()++data TagSetterResetTagsMethodInfo+instance (signature ~ (m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterResetTagsMethodInfo a signature where+    overloadedMethod _ = tagSetterResetTags++-- method TagSetter::set_tag_merge_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_setter_set_tag_merge_mode" gst_tag_setter_set_tag_merge_mode :: +    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO ()+++tagSetterSetTagMergeMode ::+    (MonadIO m, TagSetterK a) =>+    a                                       -- _obj+    -> TagMergeMode                         -- mode+    -> m ()                                 -- result+tagSetterSetTagMergeMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gst_tag_setter_set_tag_merge_mode _obj' mode'+    touchManagedPtr _obj+    return ()++data TagSetterSetTagMergeModeMethodInfo+instance (signature ~ (TagMergeMode -> m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterSetTagMergeModeMethodInfo a signature where+    overloadedMethod _ = tagSetterSetTagMergeMode++
+ GI/Gst/Interfaces/TagSetter.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gst.Interfaces.TagSetter 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++newtype TagSetter = TagSetter (ForeignPtr TagSetter)+instance GObject TagSetter where+class GObject o => TagSetterK o+instance (GObject o, IsDescendantOf TagSetter o) => TagSetterK o+data TagSetterAddTagValueMethodInfo+data TagSetterGetTagListMethodInfo+data TagSetterGetTagMergeModeMethodInfo+data TagSetterMergeTagsMethodInfo+data TagSetterResetTagsMethodInfo+data TagSetterSetTagMergeModeMethodInfo
+ GI/Gst/Interfaces/TocSetter.hs view
@@ -0,0 +1,276 @@+++{- |+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.Interfaces.TocSetter+    ( ++-- * Exported types+    TocSetter(..)                           ,+    noTocSetter                             ,+    TocSetterK                              ,+    toTocSetter                             ,+++ -- * Methods+-- ** tocSetterGetToc+    TocSetterGetTocMethodInfo               ,+    tocSetterGetToc                         ,+++-- ** tocSetterReset+    TocSetterResetMethodInfo                ,+    tocSetterReset                          ,+++-- ** tocSetterSetToc+    TocSetterSetTocMethodInfo               ,+    tocSetterSetToc                         ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++-- interface TocSetter ++newtype TocSetter = TocSetter (ForeignPtr TocSetter)+noTocSetter :: Maybe TocSetter+noTocSetter = Nothing++type family ResolveTocSetterMethod (t :: Symbol) (o :: *) :: * where+    ResolveTocSetterMethod "abortState" o = ElementAbortStateMethodInfo+    ResolveTocSetterMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveTocSetterMethod "addPad" o = ElementAddPadMethodInfo+    ResolveTocSetterMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveTocSetterMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveTocSetterMethod "changeState" o = ElementChangeStateMethodInfo+    ResolveTocSetterMethod "continueState" o = ElementContinueStateMethodInfo+    ResolveTocSetterMethod "createAllPads" o = ElementCreateAllPadsMethodInfo+    ResolveTocSetterMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveTocSetterMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveTocSetterMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveTocSetterMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveTocSetterMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveTocSetterMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveTocSetterMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveTocSetterMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveTocSetterMethod "isLockedState" o = ElementIsLockedStateMethodInfo+    ResolveTocSetterMethod "iteratePads" o = ElementIteratePadsMethodInfo+    ResolveTocSetterMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo+    ResolveTocSetterMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo+    ResolveTocSetterMethod "link" o = ElementLinkMethodInfo+    ResolveTocSetterMethod "linkFiltered" o = ElementLinkFilteredMethodInfo+    ResolveTocSetterMethod "linkPads" o = ElementLinkPadsMethodInfo+    ResolveTocSetterMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo+    ResolveTocSetterMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo+    ResolveTocSetterMethod "lostState" o = ElementLostStateMethodInfo+    ResolveTocSetterMethod "messageFull" o = ElementMessageFullMethodInfo+    ResolveTocSetterMethod "noMorePads" o = ElementNoMorePadsMethodInfo+    ResolveTocSetterMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveTocSetterMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveTocSetterMethod "postMessage" o = ElementPostMessageMethodInfo+    ResolveTocSetterMethod "provideClock" o = ElementProvideClockMethodInfo+    ResolveTocSetterMethod "query" o = ElementQueryMethodInfo+    ResolveTocSetterMethod "queryConvert" o = ElementQueryConvertMethodInfo+    ResolveTocSetterMethod "queryDuration" o = ElementQueryDurationMethodInfo+    ResolveTocSetterMethod "queryPosition" o = ElementQueryPositionMethodInfo+    ResolveTocSetterMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveTocSetterMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo+    ResolveTocSetterMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveTocSetterMethod "removePad" o = ElementRemovePadMethodInfo+    ResolveTocSetterMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveTocSetterMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveTocSetterMethod "requestPad" o = ElementRequestPadMethodInfo+    ResolveTocSetterMethod "reset" o = TocSetterResetMethodInfo+    ResolveTocSetterMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveTocSetterMethod "seek" o = ElementSeekMethodInfo+    ResolveTocSetterMethod "seekSimple" o = ElementSeekSimpleMethodInfo+    ResolveTocSetterMethod "sendEvent" o = ElementSendEventMethodInfo+    ResolveTocSetterMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveTocSetterMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveTocSetterMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveTocSetterMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo+    ResolveTocSetterMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveTocSetterMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveTocSetterMethod "unlink" o = ElementUnlinkMethodInfo+    ResolveTocSetterMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo+    ResolveTocSetterMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveTocSetterMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveTocSetterMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo+    ResolveTocSetterMethod "getBus" o = ElementGetBusMethodInfo+    ResolveTocSetterMethod "getClock" o = ElementGetClockMethodInfo+    ResolveTocSetterMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo+    ResolveTocSetterMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo+    ResolveTocSetterMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveTocSetterMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveTocSetterMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveTocSetterMethod "getFactory" o = ElementGetFactoryMethodInfo+    ResolveTocSetterMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveTocSetterMethod "getName" o = ObjectGetNameMethodInfo+    ResolveTocSetterMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveTocSetterMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveTocSetterMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveTocSetterMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveTocSetterMethod "getRequestPad" o = ElementGetRequestPadMethodInfo+    ResolveTocSetterMethod "getStartTime" o = ElementGetStartTimeMethodInfo+    ResolveTocSetterMethod "getState" o = ElementGetStateMethodInfo+    ResolveTocSetterMethod "getStaticPad" o = ElementGetStaticPadMethodInfo+    ResolveTocSetterMethod "getToc" o = TocSetterGetTocMethodInfo+    ResolveTocSetterMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveTocSetterMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveTocSetterMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo+    ResolveTocSetterMethod "setBus" o = ElementSetBusMethodInfo+    ResolveTocSetterMethod "setClock" o = ElementSetClockMethodInfo+    ResolveTocSetterMethod "setContext" o = ElementSetContextMethodInfo+    ResolveTocSetterMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveTocSetterMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveTocSetterMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveTocSetterMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveTocSetterMethod "setLockedState" o = ElementSetLockedStateMethodInfo+    ResolveTocSetterMethod "setName" o = ObjectSetNameMethodInfo+    ResolveTocSetterMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveTocSetterMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveTocSetterMethod "setStartTime" o = ElementSetStartTimeMethodInfo+    ResolveTocSetterMethod "setState" o = ElementSetStateMethodInfo+    ResolveTocSetterMethod "setToc" o = TocSetterSetTocMethodInfo+    ResolveTocSetterMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTocSetterMethod t TocSetter, MethodInfo info TocSetter p) => IsLabelProxy t (TocSetter -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTocSetterMethod t TocSetter, MethodInfo info TocSetter p) => IsLabel t (TocSetter -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList TocSetter = TocSetterAttributeList+type TocSetterAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TocSetter = TocSetterSignalList+type TocSetterSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++foreign import ccall "gst_toc_setter_get_type"+    c_gst_toc_setter_get_type :: IO GType++type instance ParentTypes TocSetter = TocSetterParentTypes+type TocSetterParentTypes = '[Element, Object, GObject.Object]++instance GObject TocSetter where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_toc_setter_get_type+    ++class GObject o => TocSetterK o+instance (GObject o, IsDescendantOf TocSetter o) => TocSetterK o++toTocSetter :: TocSetterK o => o -> IO TocSetter+toTocSetter = unsafeCastTo TocSetter++-- method TocSetter::get_toc+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Toc"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_setter_get_toc" gst_toc_setter_get_toc :: +    Ptr TocSetter ->                        -- _obj : TInterface "Gst" "TocSetter"+    IO (Ptr Toc)+++tocSetterGetToc ::+    (MonadIO m, TocSetterK a) =>+    a                                       -- _obj+    -> m Toc                                -- result+tocSetterGetToc _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_toc_setter_get_toc _obj'+    checkUnexpectedReturnNULL "gst_toc_setter_get_toc" result+    result' <- (wrapBoxed Toc) result+    touchManagedPtr _obj+    return result'++data TocSetterGetTocMethodInfo+instance (signature ~ (m Toc), MonadIO m, TocSetterK a) => MethodInfo TocSetterGetTocMethodInfo a signature where+    overloadedMethod _ = tocSetterGetToc++-- method TocSetter::reset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_setter_reset" gst_toc_setter_reset :: +    Ptr TocSetter ->                        -- _obj : TInterface "Gst" "TocSetter"+    IO ()+++tocSetterReset ::+    (MonadIO m, TocSetterK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+tocSetterReset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_toc_setter_reset _obj'+    touchManagedPtr _obj+    return ()++data TocSetterResetMethodInfo+instance (signature ~ (m ()), MonadIO m, TocSetterK a) => MethodInfo TocSetterResetMethodInfo a signature where+    overloadedMethod _ = tocSetterReset++-- method TocSetter::set_toc+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_setter_set_toc" gst_toc_setter_set_toc :: +    Ptr TocSetter ->                        -- _obj : TInterface "Gst" "TocSetter"+    Ptr Toc ->                              -- toc : TInterface "Gst" "Toc"+    IO ()+++tocSetterSetToc ::+    (MonadIO m, TocSetterK a) =>+    a                                       -- _obj+    -> Maybe (Toc)                          -- toc+    -> m ()                                 -- result+tocSetterSetToc _obj toc = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeToc <- case toc of+        Nothing -> return nullPtr+        Just jToc -> do+            let jToc' = unsafeManagedPtrGetPtr jToc+            return jToc'+    gst_toc_setter_set_toc _obj' maybeToc+    touchManagedPtr _obj+    whenJust toc touchManagedPtr+    return ()++data TocSetterSetTocMethodInfo+instance (signature ~ (Maybe (Toc) -> m ()), MonadIO m, TocSetterK a) => MethodInfo TocSetterSetTocMethodInfo a signature where+    overloadedMethod _ = tocSetterSetToc++
+ GI/Gst/Interfaces/TocSetter.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gst.Interfaces.TocSetter 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++newtype TocSetter = TocSetter (ForeignPtr TocSetter)+instance GObject TocSetter where+class GObject o => TocSetterK o+instance (GObject o, IsDescendantOf TocSetter o) => TocSetterK o+data TocSetterGetTocMethodInfo+data TocSetterResetMethodInfo+data TocSetterSetTocMethodInfo
+ GI/Gst/Interfaces/URIHandler.hs view
@@ -0,0 +1,208 @@+++{- |+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.Interfaces.URIHandler+    ( ++-- * Exported types+    URIHandler(..)                          ,+    noURIHandler                            ,+    URIHandlerK                             ,+++ -- * Methods+-- ** uRIHandlerGetProtocols+    URIHandlerGetProtocolsMethodInfo        ,+    uRIHandlerGetProtocols                  ,+++-- ** uRIHandlerGetUri+    URIHandlerGetUriMethodInfo              ,+    uRIHandlerGetUri                        ,+++-- ** uRIHandlerGetUriType+    URIHandlerGetUriTypeMethodInfo          ,+    uRIHandlerGetUriType                    ,+++-- ** uRIHandlerSetUri+    URIHandlerSetUriMethodInfo              ,+    uRIHandlerSetUri                        ,+++++    ) 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 GI.Gst.Callbacks++-- interface URIHandler ++newtype URIHandler = URIHandler (ForeignPtr URIHandler)+noURIHandler :: Maybe URIHandler+noURIHandler = Nothing++type family ResolveURIHandlerMethod (t :: Symbol) (o :: *) :: * where+    ResolveURIHandlerMethod "getProtocols" o = URIHandlerGetProtocolsMethodInfo+    ResolveURIHandlerMethod "getUri" o = URIHandlerGetUriMethodInfo+    ResolveURIHandlerMethod "getUriType" o = URIHandlerGetUriTypeMethodInfo+    ResolveURIHandlerMethod "setUri" o = URIHandlerSetUriMethodInfo+    ResolveURIHandlerMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveURIHandlerMethod t URIHandler, MethodInfo info URIHandler p) => IsLabelProxy t (URIHandler -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveURIHandlerMethod t URIHandler, MethodInfo info URIHandler p) => IsLabel t (URIHandler -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList URIHandler = URIHandlerAttributeList+type URIHandlerAttributeList = ('[ ] :: [(Symbol, *)])++type instance SignalList URIHandler = URIHandlerSignalList+type URIHandlerSignalList = ('[ ] :: [(Symbol, *)])++class ForeignPtrNewtype a => URIHandlerK a+instance (ForeignPtrNewtype o, IsDescendantOf URIHandler o) => URIHandlerK o+type instance ParentTypes URIHandler = URIHandlerParentTypes+type URIHandlerParentTypes = '[]++-- method URIHandler::get_protocols+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_handler_get_protocols" gst_uri_handler_get_protocols :: +    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"+    IO (Ptr CString)+++uRIHandlerGetProtocols ::+    (MonadIO m, URIHandlerK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+uRIHandlerGetProtocols _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_uri_handler_get_protocols _obj'+    checkUnexpectedReturnNULL "gst_uri_handler_get_protocols" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++data URIHandlerGetProtocolsMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerGetProtocolsMethodInfo a signature where+    overloadedMethod _ = uRIHandlerGetProtocols++-- method URIHandler::get_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_handler_get_uri" gst_uri_handler_get_uri :: +    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"+    IO CString+++uRIHandlerGetUri ::+    (MonadIO m, URIHandlerK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+uRIHandlerGetUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_uri_handler_get_uri _obj'+    checkUnexpectedReturnNULL "gst_uri_handler_get_uri" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data URIHandlerGetUriMethodInfo+instance (signature ~ (m T.Text), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerGetUriMethodInfo a signature where+    overloadedMethod _ = uRIHandlerGetUri++-- method URIHandler::get_uri_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "URIType"+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_handler_get_uri_type" gst_uri_handler_get_uri_type :: +    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"+    IO CUInt+++uRIHandlerGetUriType ::+    (MonadIO m, URIHandlerK a) =>+    a                                       -- _obj+    -> m URIType                            -- result+uRIHandlerGetUriType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_uri_handler_get_uri_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data URIHandlerGetUriTypeMethodInfo+instance (signature ~ (m URIType), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerGetUriTypeMethodInfo a signature where+    overloadedMethod _ = uRIHandlerGetUriType++-- method URIHandler::set_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : True+-- Skip return : False++foreign import ccall "gst_uri_handler_set_uri" gst_uri_handler_set_uri :: +    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"+    CString ->                              -- uri : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO CInt+++uRIHandlerSetUri ::+    (MonadIO m, URIHandlerK a) =>+    a                                       -- _obj+    -> T.Text                               -- uri+    -> m ()                                 -- result+uRIHandlerSetUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    uri' <- textToCString uri+    onException (do+        _ <- propagateGError $ gst_uri_handler_set_uri _obj' uri'+        touchManagedPtr _obj+        freeMem uri'+        return ()+     ) (do+        freeMem uri'+     )++data URIHandlerSetUriMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerSetUriMethodInfo a signature where+    overloadedMethod _ = uRIHandlerSetUri++
+ GI/Gst/Interfaces/URIHandler.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gst.Interfaces.URIHandler 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++newtype URIHandler = URIHandler (ForeignPtr URIHandler)+class ForeignPtrNewtype a => URIHandlerK a+instance (ForeignPtrNewtype o, IsDescendantOf URIHandler o) => URIHandlerK o+data URIHandlerGetProtocolsMethodInfo+data URIHandlerGetUriMethodInfo+data URIHandlerGetUriTypeMethodInfo+data URIHandlerSetUriMethodInfo
+ GI/Gst/Objects.hs view
@@ -0,0 +1,77 @@+++{- |+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.Objects+    (     module GI.Gst.Objects.Allocator         ,+    module GI.Gst.Objects.Bin               ,+    module GI.Gst.Objects.BufferPool        ,+    module GI.Gst.Objects.Bus               ,+    module GI.Gst.Objects.Clock             ,+    module GI.Gst.Objects.ControlBinding    ,+    module GI.Gst.Objects.ControlSource     ,+    module GI.Gst.Objects.Device            ,+    module GI.Gst.Objects.DeviceMonitor     ,+    module GI.Gst.Objects.DeviceProvider    ,+    module GI.Gst.Objects.DeviceProviderFactory,+    module GI.Gst.Objects.Element           ,+    module GI.Gst.Objects.ElementFactory    ,+    module GI.Gst.Objects.GhostPad          ,+    module GI.Gst.Objects.Object            ,+    module GI.Gst.Objects.Pad               ,+    module GI.Gst.Objects.PadTemplate       ,+    module GI.Gst.Objects.Pipeline          ,+    module GI.Gst.Objects.Plugin            ,+    module GI.Gst.Objects.PluginFeature     ,+    module GI.Gst.Objects.ProxyPad          ,+    module GI.Gst.Objects.Registry          ,+    module GI.Gst.Objects.SystemClock       ,+    module GI.Gst.Objects.Task              ,+    module GI.Gst.Objects.TaskPool          ,+    module GI.Gst.Objects.TypeFindFactory   ,+++    ) where++import GI.Gst.Objects.Allocator+import GI.Gst.Objects.Bin+import GI.Gst.Objects.BufferPool+import GI.Gst.Objects.Bus+import GI.Gst.Objects.Clock+import GI.Gst.Objects.ControlBinding+import GI.Gst.Objects.ControlSource+import GI.Gst.Objects.Device+import GI.Gst.Objects.DeviceMonitor+import GI.Gst.Objects.DeviceProvider+import GI.Gst.Objects.DeviceProviderFactory+import GI.Gst.Objects.Element+import GI.Gst.Objects.ElementFactory+import GI.Gst.Objects.GhostPad+import GI.Gst.Objects.Object+import GI.Gst.Objects.Pad+import GI.Gst.Objects.PadTemplate+import GI.Gst.Objects.Pipeline+import GI.Gst.Objects.Plugin+import GI.Gst.Objects.PluginFeature+import GI.Gst.Objects.ProxyPad+import GI.Gst.Objects.Registry+import GI.Gst.Objects.SystemClock+import GI.Gst.Objects.Task+import GI.Gst.Objects.TaskPool+import GI.Gst.Objects.TypeFindFactory++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 GI.Gst.Callbacks++
+ GI/Gst/Objects/Allocator.hs view
@@ -0,0 +1,295 @@+++{- |+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.Objects.Allocator+    ( ++-- * Exported types+    Allocator(..)                           ,+    AllocatorK                              ,+    toAllocator                             ,+    noAllocator                             ,+++ -- * Methods+-- ** allocatorAlloc+    AllocatorAllocMethodInfo                ,+    allocatorAlloc                          ,+++-- ** allocatorFind+    allocatorFind                           ,+++-- ** allocatorFree+    AllocatorFreeMethodInfo                 ,+    allocatorFree                           ,+++-- ** allocatorRegister+    allocatorRegister                       ,+++-- ** allocatorSetDefault+    AllocatorSetDefaultMethodInfo           ,+    allocatorSetDefault                     ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Allocator = Allocator (ForeignPtr Allocator)+foreign import ccall "gst_allocator_get_type"+    c_gst_allocator_get_type :: IO GType++type instance ParentTypes Allocator = AllocatorParentTypes+type AllocatorParentTypes = '[Object, GObject.Object]++instance GObject Allocator where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_allocator_get_type+    ++class GObject o => AllocatorK o+instance (GObject o, IsDescendantOf Allocator o) => AllocatorK o++toAllocator :: AllocatorK o => o -> IO Allocator+toAllocator = unsafeCastTo Allocator++noAllocator :: Maybe Allocator+noAllocator = Nothing++type family ResolveAllocatorMethod (t :: Symbol) (o :: *) :: * where+    ResolveAllocatorMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveAllocatorMethod "alloc" o = AllocatorAllocMethodInfo+    ResolveAllocatorMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveAllocatorMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveAllocatorMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveAllocatorMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveAllocatorMethod "free" o = AllocatorFreeMethodInfo+    ResolveAllocatorMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveAllocatorMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveAllocatorMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveAllocatorMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveAllocatorMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveAllocatorMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveAllocatorMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveAllocatorMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveAllocatorMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveAllocatorMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveAllocatorMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveAllocatorMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveAllocatorMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveAllocatorMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveAllocatorMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveAllocatorMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveAllocatorMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveAllocatorMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveAllocatorMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveAllocatorMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveAllocatorMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveAllocatorMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveAllocatorMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveAllocatorMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveAllocatorMethod "getName" o = ObjectGetNameMethodInfo+    ResolveAllocatorMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveAllocatorMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveAllocatorMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveAllocatorMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveAllocatorMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveAllocatorMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveAllocatorMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveAllocatorMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveAllocatorMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveAllocatorMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveAllocatorMethod "setDefault" o = AllocatorSetDefaultMethodInfo+    ResolveAllocatorMethod "setName" o = ObjectSetNameMethodInfo+    ResolveAllocatorMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveAllocatorMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveAllocatorMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveAllocatorMethod t Allocator, MethodInfo info Allocator p) => IsLabelProxy t (Allocator -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveAllocatorMethod t Allocator, MethodInfo info Allocator p) => IsLabel t (Allocator -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList Allocator = AllocatorAttributeList+type AllocatorAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Allocator = AllocatorSignalList+type AllocatorSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Allocator::alloc+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocator_alloc" gst_allocator_alloc :: +    Ptr Allocator ->                        -- _obj : TInterface "Gst" "Allocator"+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"+    IO (Ptr Memory)+++allocatorAlloc ::+    (MonadIO m, AllocatorK a) =>+    a                                       -- _obj+    -> Word64                               -- size+    -> Maybe (AllocationParams)             -- params+    -> m Memory                             -- result+allocatorAlloc _obj size params = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParams <- case params of+        Nothing -> return nullPtr+        Just jParams -> do+            let jParams' = unsafeManagedPtrGetPtr jParams+            return jParams'+    result <- gst_allocator_alloc _obj' size maybeParams+    checkUnexpectedReturnNULL "gst_allocator_alloc" result+    result' <- (wrapBoxed Memory) result+    touchManagedPtr _obj+    whenJust params touchManagedPtr+    return result'++data AllocatorAllocMethodInfo+instance (signature ~ (Word64 -> Maybe (AllocationParams) -> m Memory), MonadIO m, AllocatorK a) => MethodInfo AllocatorAllocMethodInfo a signature where+    overloadedMethod _ = allocatorAlloc++-- method Allocator::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "memory", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocator_free" gst_allocator_free :: +    Ptr Allocator ->                        -- _obj : TInterface "Gst" "Allocator"+    Ptr Memory ->                           -- memory : TInterface "Gst" "Memory"+    IO ()+++allocatorFree ::+    (MonadIO m, AllocatorK a) =>+    a                                       -- _obj+    -> Memory                               -- memory+    -> m ()                                 -- result+allocatorFree _obj memory = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    memory' <- copyBoxed memory+    gst_allocator_free _obj' memory'+    touchManagedPtr _obj+    touchManagedPtr memory+    return ()++data AllocatorFreeMethodInfo+instance (signature ~ (Memory -> m ()), MonadIO m, AllocatorK a) => MethodInfo AllocatorFreeMethodInfo a signature where+    overloadedMethod _ = allocatorFree++-- method Allocator::set_default+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocator_set_default" gst_allocator_set_default :: +    Ptr Allocator ->                        -- _obj : TInterface "Gst" "Allocator"+    IO ()+++allocatorSetDefault ::+    (MonadIO m, AllocatorK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+allocatorSetDefault _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_allocator_set_default _obj'+    touchManagedPtr _obj+    return ()++data AllocatorSetDefaultMethodInfo+instance (signature ~ (m ()), MonadIO m, AllocatorK a) => MethodInfo AllocatorSetDefaultMethodInfo a signature where+    overloadedMethod _ = allocatorSetDefault++-- method Allocator::find+-- method type : MemberFunction+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Allocator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocator_find" gst_allocator_find :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Allocator)+++allocatorFind ::+    (MonadIO m) =>+    Maybe (T.Text)                          -- name+    -> m Allocator                          -- result+allocatorFind name = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_allocator_find maybeName+    checkUnexpectedReturnNULL "gst_allocator_find" result+    result' <- (wrapObject Allocator) result+    freeMem maybeName+    return result'++-- method Allocator::register+-- method type : MemberFunction+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocator_register" gst_allocator_register :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"+    IO ()+++allocatorRegister ::+    (MonadIO m, AllocatorK a) =>+    T.Text                                  -- name+    -> a                                    -- allocator+    -> m ()                                 -- result+allocatorRegister name allocator = liftIO $ do+    name' <- textToCString name+    allocator' <- refObject allocator+    gst_allocator_register name' allocator'+    touchManagedPtr allocator+    freeMem name'+    return ()++
+ GI/Gst/Objects/Allocator.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gst.Objects.Allocator 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++newtype Allocator = Allocator (ForeignPtr Allocator)+instance GObject Allocator where+class GObject o => AllocatorK o+instance (GObject o, IsDescendantOf Allocator o) => AllocatorK o+data AllocatorAllocMethodInfo+data AllocatorFreeMethodInfo+data AllocatorSetDefaultMethodInfo
+ GI/Gst/Objects/Bin.hs view
@@ -0,0 +1,956 @@+++{- |+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.Objects.Bin+    ( ++-- * Exported types+    Bin(..)                                 ,+    BinK                                    ,+    toBin                                   ,+    noBin                                   ,+++ -- * Methods+-- ** binAdd+    BinAddMethodInfo                        ,+    binAdd                                  ,+++-- ** binFindUnlinkedPad+    BinFindUnlinkedPadMethodInfo            ,+    binFindUnlinkedPad                      ,+++-- ** binGetByInterface+    BinGetByInterfaceMethodInfo             ,+    binGetByInterface                       ,+++-- ** binGetByName+    BinGetByNameMethodInfo                  ,+    binGetByName                            ,+++-- ** binGetByNameRecurseUp+    BinGetByNameRecurseUpMethodInfo         ,+    binGetByNameRecurseUp                   ,+++-- ** binIterateAllByInterface+    BinIterateAllByInterfaceMethodInfo      ,+    binIterateAllByInterface                ,+++-- ** binIterateElements+    BinIterateElementsMethodInfo            ,+    binIterateElements                      ,+++-- ** binIterateRecurse+    BinIterateRecurseMethodInfo             ,+    binIterateRecurse                       ,+++-- ** binIterateSinks+    BinIterateSinksMethodInfo               ,+    binIterateSinks                         ,+++-- ** binIterateSorted+    BinIterateSortedMethodInfo              ,+    binIterateSorted                        ,+++-- ** binIterateSources+    BinIterateSourcesMethodInfo             ,+    binIterateSources                       ,+++-- ** binNew+    binNew                                  ,+++-- ** binRecalculateLatency+    BinRecalculateLatencyMethodInfo         ,+    binRecalculateLatency                   ,+++-- ** binRemove+    BinRemoveMethodInfo                     ,+    binRemove                               ,+++-- ** binSyncChildrenStates+    BinSyncChildrenStatesMethodInfo         ,+    binSyncChildrenStates                   ,+++++ -- * Properties+-- ** AsyncHandling+    BinAsyncHandlingPropertyInfo            ,+    constructBinAsyncHandling               ,+    getBinAsyncHandling                     ,+    setBinAsyncHandling                     ,+++-- ** MessageForward+    BinMessageForwardPropertyInfo           ,+    constructBinMessageForward              ,+    getBinMessageForward                    ,+    setBinMessageForward                    ,+++++ -- * Signals+-- ** DoLatency+    BinDoLatencyCallback                    ,+    BinDoLatencyCallbackC                   ,+    BinDoLatencySignalInfo                  ,+    afterBinDoLatency                       ,+    binDoLatencyCallbackWrapper             ,+    binDoLatencyClosure                     ,+    mkBinDoLatencyCallback                  ,+    noBinDoLatencyCallback                  ,+    onBinDoLatency                          ,+++-- ** ElementAdded+    BinElementAddedCallback                 ,+    BinElementAddedCallbackC                ,+    BinElementAddedSignalInfo               ,+    afterBinElementAdded                    ,+    binElementAddedCallbackWrapper          ,+    binElementAddedClosure                  ,+    mkBinElementAddedCallback               ,+    noBinElementAddedCallback               ,+    onBinElementAdded                       ,+++-- ** ElementRemoved+    BinElementRemovedCallback               ,+    BinElementRemovedCallbackC              ,+    BinElementRemovedSignalInfo             ,+    afterBinElementRemoved                  ,+    binElementRemovedCallbackWrapper        ,+    binElementRemovedClosure                ,+    mkBinElementRemovedCallback             ,+    noBinElementRemovedCallback             ,+    onBinElementRemoved                     ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Bin = Bin (ForeignPtr Bin)+foreign import ccall "gst_bin_get_type"+    c_gst_bin_get_type :: IO GType++type instance ParentTypes Bin = BinParentTypes+type BinParentTypes = '[Element, Object, GObject.Object, ChildProxy]++instance GObject Bin where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_bin_get_type+    ++class GObject o => BinK o+instance (GObject o, IsDescendantOf Bin o) => BinK o++toBin :: BinK o => o -> IO Bin+toBin = unsafeCastTo Bin++noBin :: Maybe Bin+noBin = Nothing++type family ResolveBinMethod (t :: Symbol) (o :: *) :: * where+    ResolveBinMethod "abortState" o = ElementAbortStateMethodInfo+    ResolveBinMethod "add" o = BinAddMethodInfo+    ResolveBinMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveBinMethod "addPad" o = ElementAddPadMethodInfo+    ResolveBinMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveBinMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveBinMethod "changeState" o = ElementChangeStateMethodInfo+    ResolveBinMethod "childAdded" o = ChildProxyChildAddedMethodInfo+    ResolveBinMethod "childRemoved" o = ChildProxyChildRemovedMethodInfo+    ResolveBinMethod "continueState" o = ElementContinueStateMethodInfo+    ResolveBinMethod "createAllPads" o = ElementCreateAllPadsMethodInfo+    ResolveBinMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveBinMethod "findUnlinkedPad" o = BinFindUnlinkedPadMethodInfo+    ResolveBinMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveBinMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveBinMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveBinMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveBinMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveBinMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveBinMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveBinMethod "isLockedState" o = ElementIsLockedStateMethodInfo+    ResolveBinMethod "iterateAllByInterface" o = BinIterateAllByInterfaceMethodInfo+    ResolveBinMethod "iterateElements" o = BinIterateElementsMethodInfo+    ResolveBinMethod "iteratePads" o = ElementIteratePadsMethodInfo+    ResolveBinMethod "iterateRecurse" o = BinIterateRecurseMethodInfo+    ResolveBinMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo+    ResolveBinMethod "iterateSinks" o = BinIterateSinksMethodInfo+    ResolveBinMethod "iterateSorted" o = BinIterateSortedMethodInfo+    ResolveBinMethod "iterateSources" o = BinIterateSourcesMethodInfo+    ResolveBinMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo+    ResolveBinMethod "link" o = ElementLinkMethodInfo+    ResolveBinMethod "linkFiltered" o = ElementLinkFilteredMethodInfo+    ResolveBinMethod "linkPads" o = ElementLinkPadsMethodInfo+    ResolveBinMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo+    ResolveBinMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo+    ResolveBinMethod "lookup" o = ChildProxyLookupMethodInfo+    ResolveBinMethod "lostState" o = ElementLostStateMethodInfo+    ResolveBinMethod "messageFull" o = ElementMessageFullMethodInfo+    ResolveBinMethod "noMorePads" o = ElementNoMorePadsMethodInfo+    ResolveBinMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveBinMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveBinMethod "postMessage" o = ElementPostMessageMethodInfo+    ResolveBinMethod "provideClock" o = ElementProvideClockMethodInfo+    ResolveBinMethod "query" o = ElementQueryMethodInfo+    ResolveBinMethod "queryConvert" o = ElementQueryConvertMethodInfo+    ResolveBinMethod "queryDuration" o = ElementQueryDurationMethodInfo+    ResolveBinMethod "queryPosition" o = ElementQueryPositionMethodInfo+    ResolveBinMethod "recalculateLatency" o = BinRecalculateLatencyMethodInfo+    ResolveBinMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveBinMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo+    ResolveBinMethod "remove" o = BinRemoveMethodInfo+    ResolveBinMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveBinMethod "removePad" o = ElementRemovePadMethodInfo+    ResolveBinMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveBinMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveBinMethod "requestPad" o = ElementRequestPadMethodInfo+    ResolveBinMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveBinMethod "seek" o = ElementSeekMethodInfo+    ResolveBinMethod "seekSimple" o = ElementSeekSimpleMethodInfo+    ResolveBinMethod "sendEvent" o = ElementSendEventMethodInfo+    ResolveBinMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveBinMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveBinMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveBinMethod "syncChildrenStates" o = BinSyncChildrenStatesMethodInfo+    ResolveBinMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo+    ResolveBinMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveBinMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveBinMethod "unlink" o = ElementUnlinkMethodInfo+    ResolveBinMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo+    ResolveBinMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveBinMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveBinMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo+    ResolveBinMethod "getBus" o = ElementGetBusMethodInfo+    ResolveBinMethod "getByInterface" o = BinGetByInterfaceMethodInfo+    ResolveBinMethod "getByName" o = BinGetByNameMethodInfo+    ResolveBinMethod "getByNameRecurseUp" o = BinGetByNameRecurseUpMethodInfo+    ResolveBinMethod "getChildByIndex" o = ChildProxyGetChildByIndexMethodInfo+    ResolveBinMethod "getChildByName" o = ChildProxyGetChildByNameMethodInfo+    ResolveBinMethod "getChildrenCount" o = ChildProxyGetChildrenCountMethodInfo+    ResolveBinMethod "getClock" o = ElementGetClockMethodInfo+    ResolveBinMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo+    ResolveBinMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo+    ResolveBinMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveBinMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveBinMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveBinMethod "getFactory" o = ElementGetFactoryMethodInfo+    ResolveBinMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveBinMethod "getName" o = ObjectGetNameMethodInfo+    ResolveBinMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveBinMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveBinMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveBinMethod "getRequestPad" o = ElementGetRequestPadMethodInfo+    ResolveBinMethod "getStartTime" o = ElementGetStartTimeMethodInfo+    ResolveBinMethod "getState" o = ElementGetStateMethodInfo+    ResolveBinMethod "getStaticPad" o = ElementGetStaticPadMethodInfo+    ResolveBinMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveBinMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveBinMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo+    ResolveBinMethod "setBus" o = ElementSetBusMethodInfo+    ResolveBinMethod "setClock" o = ElementSetClockMethodInfo+    ResolveBinMethod "setContext" o = ElementSetContextMethodInfo+    ResolveBinMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveBinMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveBinMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveBinMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveBinMethod "setLockedState" o = ElementSetLockedStateMethodInfo+    ResolveBinMethod "setName" o = ObjectSetNameMethodInfo+    ResolveBinMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveBinMethod "setStartTime" o = ElementSetStartTimeMethodInfo+    ResolveBinMethod "setState" o = ElementSetStateMethodInfo+    ResolveBinMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveBinMethod t Bin, MethodInfo info Bin p) => IsLabelProxy t (Bin -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveBinMethod t Bin, MethodInfo info Bin p) => IsLabel t (Bin -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Bin::do-latency+type BinDoLatencyCallback =+    IO Bool++noBinDoLatencyCallback :: Maybe BinDoLatencyCallback+noBinDoLatencyCallback = Nothing++type BinDoLatencyCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO CInt++foreign import ccall "wrapper"+    mkBinDoLatencyCallback :: BinDoLatencyCallbackC -> IO (FunPtr BinDoLatencyCallbackC)++binDoLatencyClosure :: BinDoLatencyCallback -> IO Closure+binDoLatencyClosure cb = newCClosure =<< mkBinDoLatencyCallback wrapped+    where wrapped = binDoLatencyCallbackWrapper cb++binDoLatencyCallbackWrapper ::+    BinDoLatencyCallback ->+    Ptr () ->+    Ptr () ->+    IO CInt+binDoLatencyCallbackWrapper _cb _ _ = do+    result <- _cb +    let result' = (fromIntegral . fromEnum) result+    return result'++onBinDoLatency :: (GObject a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId+onBinDoLatency obj cb = liftIO $ connectBinDoLatency obj cb SignalConnectBefore+afterBinDoLatency :: (GObject a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId+afterBinDoLatency obj cb = connectBinDoLatency obj cb SignalConnectAfter++connectBinDoLatency :: (GObject a, MonadIO m) =>+                       a -> BinDoLatencyCallback -> SignalConnectMode -> m SignalHandlerId+connectBinDoLatency obj cb after = liftIO $ do+    cb' <- mkBinDoLatencyCallback (binDoLatencyCallbackWrapper cb)+    connectSignalFunPtr obj "do-latency" cb' after++-- signal Bin::element-added+type BinElementAddedCallback =+    Element ->+    IO ()++noBinElementAddedCallback :: Maybe BinElementAddedCallback+noBinElementAddedCallback = Nothing++type BinElementAddedCallbackC =+    Ptr () ->                               -- object+    Ptr Element ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkBinElementAddedCallback :: BinElementAddedCallbackC -> IO (FunPtr BinElementAddedCallbackC)++binElementAddedClosure :: BinElementAddedCallback -> IO Closure+binElementAddedClosure cb = newCClosure =<< mkBinElementAddedCallback wrapped+    where wrapped = binElementAddedCallbackWrapper cb++binElementAddedCallbackWrapper ::+    BinElementAddedCallback ->+    Ptr () ->+    Ptr Element ->+    Ptr () ->+    IO ()+binElementAddedCallbackWrapper _cb _ element _ = do+    element' <- (newObject Element) element+    _cb  element'++onBinElementAdded :: (GObject a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId+onBinElementAdded obj cb = liftIO $ connectBinElementAdded obj cb SignalConnectBefore+afterBinElementAdded :: (GObject a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId+afterBinElementAdded obj cb = connectBinElementAdded obj cb SignalConnectAfter++connectBinElementAdded :: (GObject a, MonadIO m) =>+                          a -> BinElementAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectBinElementAdded obj cb after = liftIO $ do+    cb' <- mkBinElementAddedCallback (binElementAddedCallbackWrapper cb)+    connectSignalFunPtr obj "element-added" cb' after++-- signal Bin::element-removed+type BinElementRemovedCallback =+    Element ->+    IO ()++noBinElementRemovedCallback :: Maybe BinElementRemovedCallback+noBinElementRemovedCallback = Nothing++type BinElementRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr Element ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkBinElementRemovedCallback :: BinElementRemovedCallbackC -> IO (FunPtr BinElementRemovedCallbackC)++binElementRemovedClosure :: BinElementRemovedCallback -> IO Closure+binElementRemovedClosure cb = newCClosure =<< mkBinElementRemovedCallback wrapped+    where wrapped = binElementRemovedCallbackWrapper cb++binElementRemovedCallbackWrapper ::+    BinElementRemovedCallback ->+    Ptr () ->+    Ptr Element ->+    Ptr () ->+    IO ()+binElementRemovedCallbackWrapper _cb _ element _ = do+    element' <- (newObject Element) element+    _cb  element'++onBinElementRemoved :: (GObject a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId+onBinElementRemoved obj cb = liftIO $ connectBinElementRemoved obj cb SignalConnectBefore+afterBinElementRemoved :: (GObject a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId+afterBinElementRemoved obj cb = connectBinElementRemoved obj cb SignalConnectAfter++connectBinElementRemoved :: (GObject a, MonadIO m) =>+                            a -> BinElementRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectBinElementRemoved obj cb after = liftIO $ do+    cb' <- mkBinElementRemovedCallback (binElementRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "element-removed" cb' after++-- VVV Prop "async-handling"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getBinAsyncHandling :: (MonadIO m, BinK o) => o -> m Bool+getBinAsyncHandling obj = liftIO $ getObjectPropertyBool obj "async-handling"++setBinAsyncHandling :: (MonadIO m, BinK o) => o -> Bool -> m ()+setBinAsyncHandling obj val = liftIO $ setObjectPropertyBool obj "async-handling" val++constructBinAsyncHandling :: Bool -> IO ([Char], GValue)+constructBinAsyncHandling val = constructObjectPropertyBool "async-handling" val++data BinAsyncHandlingPropertyInfo+instance AttrInfo BinAsyncHandlingPropertyInfo where+    type AttrAllowedOps BinAsyncHandlingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BinAsyncHandlingPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint BinAsyncHandlingPropertyInfo = BinK+    type AttrGetType BinAsyncHandlingPropertyInfo = Bool+    type AttrLabel BinAsyncHandlingPropertyInfo = "async-handling"+    attrGet _ = getBinAsyncHandling+    attrSet _ = setBinAsyncHandling+    attrConstruct _ = constructBinAsyncHandling++-- VVV Prop "message-forward"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getBinMessageForward :: (MonadIO m, BinK o) => o -> m Bool+getBinMessageForward obj = liftIO $ getObjectPropertyBool obj "message-forward"++setBinMessageForward :: (MonadIO m, BinK o) => o -> Bool -> m ()+setBinMessageForward obj val = liftIO $ setObjectPropertyBool obj "message-forward" val++constructBinMessageForward :: Bool -> IO ([Char], GValue)+constructBinMessageForward val = constructObjectPropertyBool "message-forward" val++data BinMessageForwardPropertyInfo+instance AttrInfo BinMessageForwardPropertyInfo where+    type AttrAllowedOps BinMessageForwardPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint BinMessageForwardPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint BinMessageForwardPropertyInfo = BinK+    type AttrGetType BinMessageForwardPropertyInfo = Bool+    type AttrLabel BinMessageForwardPropertyInfo = "message-forward"+    attrGet _ = getBinMessageForward+    attrSet _ = setBinMessageForward+    attrConstruct _ = constructBinMessageForward++type instance AttributeList Bin = BinAttributeList+type BinAttributeList = ('[ '("asyncHandling", BinAsyncHandlingPropertyInfo), '("messageForward", BinMessageForwardPropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++data BinDoLatencySignalInfo+instance SignalInfo BinDoLatencySignalInfo where+    type HaskellCallbackType BinDoLatencySignalInfo = BinDoLatencyCallback+    connectSignal _ = connectBinDoLatency++data BinElementAddedSignalInfo+instance SignalInfo BinElementAddedSignalInfo where+    type HaskellCallbackType BinElementAddedSignalInfo = BinElementAddedCallback+    connectSignal _ = connectBinElementAdded++data BinElementRemovedSignalInfo+instance SignalInfo BinElementRemovedSignalInfo where+    type HaskellCallbackType BinElementRemovedSignalInfo = BinElementRemovedCallback+    connectSignal _ = connectBinElementRemoved++type instance SignalList Bin = BinSignalList+type BinSignalList = ('[ '("childAdded", ChildProxyChildAddedSignalInfo), '("childRemoved", ChildProxyChildRemovedSignalInfo), '("deepNotify", ObjectDeepNotifySignalInfo), '("doLatency", BinDoLatencySignalInfo), '("elementAdded", BinElementAddedSignalInfo), '("elementRemoved", BinElementRemovedSignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++-- method Bin::new+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Bin"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_new" gst_bin_new :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Bin)+++binNew ::+    (MonadIO m) =>+    Maybe (T.Text)                          -- name+    -> m Bin                                -- result+binNew name = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_bin_new maybeName+    checkUnexpectedReturnNULL "gst_bin_new" result+    result' <- (newObject Bin) result+    freeMem maybeName+    return result'++-- method Bin::add+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_add" gst_bin_add :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    Ptr Element ->                          -- element : TInterface "Gst" "Element"+    IO CInt+++binAdd ::+    (MonadIO m, BinK a, ElementK b) =>+    a                                       -- _obj+    -> b                                    -- element+    -> m Bool                               -- result+binAdd _obj element = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    element' <- refObject element+    result <- gst_bin_add _obj' element'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr element+    return result'++data BinAddMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, BinK a, ElementK b) => MethodInfo BinAddMethodInfo a signature where+    overloadedMethod _ = binAdd++-- method Bin::find_unlinked_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_find_unlinked_pad" gst_bin_find_unlinked_pad :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"+    IO (Ptr Pad)+++binFindUnlinkedPad ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> PadDirection                         -- direction+    -> m Pad                                -- result+binFindUnlinkedPad _obj direction = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let direction' = (fromIntegral . fromEnum) direction+    result <- gst_bin_find_unlinked_pad _obj' direction'+    checkUnexpectedReturnNULL "gst_bin_find_unlinked_pad" result+    result' <- (wrapObject Pad) result+    touchManagedPtr _obj+    return result'++data BinFindUnlinkedPadMethodInfo+instance (signature ~ (PadDirection -> m Pad), MonadIO m, BinK a) => MethodInfo BinFindUnlinkedPadMethodInfo a signature where+    overloadedMethod _ = binFindUnlinkedPad++-- method Bin::get_by_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_get_by_interface" gst_bin_get_by_interface :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    CGType ->                               -- iface : TBasicType TGType+    IO (Ptr Element)+++binGetByInterface ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> GType                                -- iface+    -> m Element                            -- result+binGetByInterface _obj iface = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iface' = gtypeToCGType iface+    result <- gst_bin_get_by_interface _obj' iface'+    checkUnexpectedReturnNULL "gst_bin_get_by_interface" result+    result' <- (wrapObject Element) result+    touchManagedPtr _obj+    return result'++data BinGetByInterfaceMethodInfo+instance (signature ~ (GType -> m Element), MonadIO m, BinK a) => MethodInfo BinGetByInterfaceMethodInfo a signature where+    overloadedMethod _ = binGetByInterface++-- method Bin::get_by_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_get_by_name" gst_bin_get_by_name :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Element)+++binGetByName ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Element                            -- result+binGetByName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_bin_get_by_name _obj' name'+    checkUnexpectedReturnNULL "gst_bin_get_by_name" result+    result' <- (wrapObject Element) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data BinGetByNameMethodInfo+instance (signature ~ (T.Text -> m Element), MonadIO m, BinK a) => MethodInfo BinGetByNameMethodInfo a signature where+    overloadedMethod _ = binGetByName++-- method Bin::get_by_name_recurse_up+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_get_by_name_recurse_up" gst_bin_get_by_name_recurse_up :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Element)+++binGetByNameRecurseUp ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Element                            -- result+binGetByNameRecurseUp _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_bin_get_by_name_recurse_up _obj' name'+    checkUnexpectedReturnNULL "gst_bin_get_by_name_recurse_up" result+    result' <- (wrapObject Element) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data BinGetByNameRecurseUpMethodInfo+instance (signature ~ (T.Text -> m Element), MonadIO m, BinK a) => MethodInfo BinGetByNameRecurseUpMethodInfo a signature where+    overloadedMethod _ = binGetByNameRecurseUp++-- method Bin::iterate_all_by_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_iterate_all_by_interface" gst_bin_iterate_all_by_interface :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    CGType ->                               -- iface : TBasicType TGType+    IO (Ptr Iterator)+++binIterateAllByInterface ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> GType                                -- iface+    -> m Iterator                           -- result+binIterateAllByInterface _obj iface = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let iface' = gtypeToCGType iface+    result <- gst_bin_iterate_all_by_interface _obj' iface'+    checkUnexpectedReturnNULL "gst_bin_iterate_all_by_interface" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data BinIterateAllByInterfaceMethodInfo+instance (signature ~ (GType -> m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateAllByInterfaceMethodInfo a signature where+    overloadedMethod _ = binIterateAllByInterface++-- method Bin::iterate_elements+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_iterate_elements" gst_bin_iterate_elements :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    IO (Ptr Iterator)+++binIterateElements ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+binIterateElements _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bin_iterate_elements _obj'+    checkUnexpectedReturnNULL "gst_bin_iterate_elements" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data BinIterateElementsMethodInfo+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateElementsMethodInfo a signature where+    overloadedMethod _ = binIterateElements++-- method Bin::iterate_recurse+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_iterate_recurse" gst_bin_iterate_recurse :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    IO (Ptr Iterator)+++binIterateRecurse ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+binIterateRecurse _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bin_iterate_recurse _obj'+    checkUnexpectedReturnNULL "gst_bin_iterate_recurse" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data BinIterateRecurseMethodInfo+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateRecurseMethodInfo a signature where+    overloadedMethod _ = binIterateRecurse++-- method Bin::iterate_sinks+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_iterate_sinks" gst_bin_iterate_sinks :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    IO (Ptr Iterator)+++binIterateSinks ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+binIterateSinks _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bin_iterate_sinks _obj'+    checkUnexpectedReturnNULL "gst_bin_iterate_sinks" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data BinIterateSinksMethodInfo+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateSinksMethodInfo a signature where+    overloadedMethod _ = binIterateSinks++-- method Bin::iterate_sorted+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_iterate_sorted" gst_bin_iterate_sorted :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    IO (Ptr Iterator)+++binIterateSorted ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+binIterateSorted _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bin_iterate_sorted _obj'+    checkUnexpectedReturnNULL "gst_bin_iterate_sorted" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data BinIterateSortedMethodInfo+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateSortedMethodInfo a signature where+    overloadedMethod _ = binIterateSorted++-- method Bin::iterate_sources+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_iterate_sources" gst_bin_iterate_sources :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    IO (Ptr Iterator)+++binIterateSources ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+binIterateSources _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bin_iterate_sources _obj'+    checkUnexpectedReturnNULL "gst_bin_iterate_sources" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data BinIterateSourcesMethodInfo+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateSourcesMethodInfo a signature where+    overloadedMethod _ = binIterateSources++-- method Bin::recalculate_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_recalculate_latency" gst_bin_recalculate_latency :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    IO CInt+++binRecalculateLatency ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+binRecalculateLatency _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bin_recalculate_latency _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BinRecalculateLatencyMethodInfo+instance (signature ~ (m Bool), MonadIO m, BinK a) => MethodInfo BinRecalculateLatencyMethodInfo a signature where+    overloadedMethod _ = binRecalculateLatency++-- method Bin::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_remove" gst_bin_remove :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    Ptr Element ->                          -- element : TInterface "Gst" "Element"+    IO CInt+++binRemove ::+    (MonadIO m, BinK a, ElementK b) =>+    a                                       -- _obj+    -> b                                    -- element+    -> m Bool                               -- result+binRemove _obj element = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let element' = unsafeManagedPtrCastPtr element+    result <- gst_bin_remove _obj' element'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr element+    return result'++data BinRemoveMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, BinK a, ElementK b) => MethodInfo BinRemoveMethodInfo a signature where+    overloadedMethod _ = binRemove++-- method Bin::sync_children_states+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bin_sync_children_states" gst_bin_sync_children_states :: +    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"+    IO CInt+++binSyncChildrenStates ::+    (MonadIO m, BinK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+binSyncChildrenStates _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bin_sync_children_states _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BinSyncChildrenStatesMethodInfo+instance (signature ~ (m Bool), MonadIO m, BinK a) => MethodInfo BinSyncChildrenStatesMethodInfo a signature where+    overloadedMethod _ = binSyncChildrenStates++
+ GI/Gst/Objects/Bin.hs-boot view
@@ -0,0 +1,32 @@+module GI.Gst.Objects.Bin 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++newtype Bin = Bin (ForeignPtr Bin)+instance GObject Bin where+class GObject o => BinK o+instance (GObject o, IsDescendantOf Bin o) => BinK o+data BinAsyncHandlingPropertyInfo+data BinMessageForwardPropertyInfo+data BinDoLatencySignalInfo+data BinElementAddedSignalInfo+data BinElementRemovedSignalInfo+data BinAddMethodInfo+data BinFindUnlinkedPadMethodInfo+data BinGetByInterfaceMethodInfo+data BinGetByNameMethodInfo+data BinGetByNameRecurseUpMethodInfo+data BinIterateAllByInterfaceMethodInfo+data BinIterateElementsMethodInfo+data BinIterateRecurseMethodInfo+data BinIterateSinksMethodInfo+data BinIterateSortedMethodInfo+data BinIterateSourcesMethodInfo+data BinRecalculateLatencyMethodInfo+data BinRemoveMethodInfo+data BinSyncChildrenStatesMethodInfo
+ GI/Gst/Objects/BufferPool.hs view
@@ -0,0 +1,794 @@+++{- |+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.Objects.BufferPool+    ( ++-- * Exported types+    BufferPool(..)                          ,+    BufferPoolK                             ,+    toBufferPool                            ,+    noBufferPool                            ,+++ -- * Methods+-- ** bufferPoolAcquireBuffer+    BufferPoolAcquireBufferMethodInfo       ,+    bufferPoolAcquireBuffer                 ,+++-- ** bufferPoolConfigAddOption+    bufferPoolConfigAddOption               ,+++-- ** bufferPoolConfigGetAllocator+    bufferPoolConfigGetAllocator            ,+++-- ** bufferPoolConfigGetOption+    bufferPoolConfigGetOption               ,+++-- ** bufferPoolConfigGetParams+    bufferPoolConfigGetParams               ,+++-- ** bufferPoolConfigHasOption+    bufferPoolConfigHasOption               ,+++-- ** bufferPoolConfigNOptions+    bufferPoolConfigNOptions                ,+++-- ** bufferPoolConfigSetAllocator+    bufferPoolConfigSetAllocator            ,+++-- ** bufferPoolConfigSetParams+    bufferPoolConfigSetParams               ,+++-- ** bufferPoolConfigValidateParams+    bufferPoolConfigValidateParams          ,+++-- ** bufferPoolGetConfig+    BufferPoolGetConfigMethodInfo           ,+    bufferPoolGetConfig                     ,+++-- ** bufferPoolGetOptions+    BufferPoolGetOptionsMethodInfo          ,+    bufferPoolGetOptions                    ,+++-- ** bufferPoolHasOption+    BufferPoolHasOptionMethodInfo           ,+    bufferPoolHasOption                     ,+++-- ** bufferPoolIsActive+    BufferPoolIsActiveMethodInfo            ,+    bufferPoolIsActive                      ,+++-- ** bufferPoolNew+    bufferPoolNew                           ,+++-- ** bufferPoolReleaseBuffer+    BufferPoolReleaseBufferMethodInfo       ,+    bufferPoolReleaseBuffer                 ,+++-- ** bufferPoolSetActive+    BufferPoolSetActiveMethodInfo           ,+    bufferPoolSetActive                     ,+++-- ** bufferPoolSetConfig+    BufferPoolSetConfigMethodInfo           ,+    bufferPoolSetConfig                     ,+++-- ** bufferPoolSetFlushing+    BufferPoolSetFlushingMethodInfo         ,+    bufferPoolSetFlushing                   ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype BufferPool = BufferPool (ForeignPtr BufferPool)+foreign import ccall "gst_buffer_pool_get_type"+    c_gst_buffer_pool_get_type :: IO GType++type instance ParentTypes BufferPool = BufferPoolParentTypes+type BufferPoolParentTypes = '[Object, GObject.Object]++instance GObject BufferPool where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_buffer_pool_get_type+    ++class GObject o => BufferPoolK o+instance (GObject o, IsDescendantOf BufferPool o) => BufferPoolK o++toBufferPool :: BufferPoolK o => o -> IO BufferPool+toBufferPool = unsafeCastTo BufferPool++noBufferPool :: Maybe BufferPool+noBufferPool = Nothing++type family ResolveBufferPoolMethod (t :: Symbol) (o :: *) :: * where+    ResolveBufferPoolMethod "acquireBuffer" o = BufferPoolAcquireBufferMethodInfo+    ResolveBufferPoolMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveBufferPoolMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveBufferPoolMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveBufferPoolMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveBufferPoolMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveBufferPoolMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveBufferPoolMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveBufferPoolMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveBufferPoolMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveBufferPoolMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveBufferPoolMethod "hasOption" o = BufferPoolHasOptionMethodInfo+    ResolveBufferPoolMethod "isActive" o = BufferPoolIsActiveMethodInfo+    ResolveBufferPoolMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveBufferPoolMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveBufferPoolMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveBufferPoolMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveBufferPoolMethod "releaseBuffer" o = BufferPoolReleaseBufferMethodInfo+    ResolveBufferPoolMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveBufferPoolMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveBufferPoolMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveBufferPoolMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveBufferPoolMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveBufferPoolMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveBufferPoolMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveBufferPoolMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveBufferPoolMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveBufferPoolMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveBufferPoolMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveBufferPoolMethod "getConfig" o = BufferPoolGetConfigMethodInfo+    ResolveBufferPoolMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveBufferPoolMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveBufferPoolMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveBufferPoolMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveBufferPoolMethod "getName" o = ObjectGetNameMethodInfo+    ResolveBufferPoolMethod "getOptions" o = BufferPoolGetOptionsMethodInfo+    ResolveBufferPoolMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveBufferPoolMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveBufferPoolMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveBufferPoolMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveBufferPoolMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveBufferPoolMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveBufferPoolMethod "setActive" o = BufferPoolSetActiveMethodInfo+    ResolveBufferPoolMethod "setConfig" o = BufferPoolSetConfigMethodInfo+    ResolveBufferPoolMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveBufferPoolMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveBufferPoolMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveBufferPoolMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveBufferPoolMethod "setFlushing" o = BufferPoolSetFlushingMethodInfo+    ResolveBufferPoolMethod "setName" o = ObjectSetNameMethodInfo+    ResolveBufferPoolMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveBufferPoolMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveBufferPoolMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveBufferPoolMethod t BufferPool, MethodInfo info BufferPool p) => IsLabelProxy t (BufferPool -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveBufferPoolMethod t BufferPool, MethodInfo info BufferPool p) => IsLabel t (BufferPool -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList BufferPool = BufferPoolAttributeList+type BufferPoolAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList BufferPool = BufferPoolSignalList+type BufferPoolSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method BufferPool::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "BufferPool"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_new" gst_buffer_pool_new :: +    IO (Ptr BufferPool)+++bufferPoolNew ::+    (MonadIO m) =>+    m BufferPool                            -- result+bufferPoolNew  = liftIO $ do+    result <- gst_buffer_pool_new+    checkUnexpectedReturnNULL "gst_buffer_pool_new" result+    result' <- (newObject BufferPool) result+    return result'++-- method BufferPool::acquire_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "BufferPoolAcquireParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_acquire_buffer" gst_buffer_pool_acquire_buffer :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    Ptr BufferPoolAcquireParams ->          -- params : TInterface "Gst" "BufferPoolAcquireParams"+    IO CUInt+++bufferPoolAcquireBuffer ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> Maybe (BufferPoolAcquireParams)      -- params+    -> m (FlowReturn,Buffer)                -- result+bufferPoolAcquireBuffer _obj params = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)+    maybeParams <- case params of+        Nothing -> return nullPtr+        Just jParams -> do+            let jParams' = unsafeManagedPtrGetPtr jParams+            return jParams'+    result <- gst_buffer_pool_acquire_buffer _obj' buffer maybeParams+    let result' = (toEnum . fromIntegral) result+    buffer' <- (wrapBoxed Buffer) buffer+    touchManagedPtr _obj+    whenJust params touchManagedPtr+    return (result', buffer')++data BufferPoolAcquireBufferMethodInfo+instance (signature ~ (Maybe (BufferPoolAcquireParams) -> m (FlowReturn,Buffer)), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolAcquireBufferMethodInfo a signature where+    overloadedMethod _ = bufferPoolAcquireBuffer++-- method BufferPool::get_config+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_get_config" gst_buffer_pool_get_config :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    IO (Ptr Structure)+++bufferPoolGetConfig ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> m Structure                          -- result+bufferPoolGetConfig _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_buffer_pool_get_config _obj'+    checkUnexpectedReturnNULL "gst_buffer_pool_get_config" result+    result' <- (wrapBoxed Structure) result+    touchManagedPtr _obj+    return result'++data BufferPoolGetConfigMethodInfo+instance (signature ~ (m Structure), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolGetConfigMethodInfo a signature where+    overloadedMethod _ = bufferPoolGetConfig++-- method BufferPool::get_options+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_get_options" gst_buffer_pool_get_options :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    IO (Ptr CString)+++bufferPoolGetOptions ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+bufferPoolGetOptions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_buffer_pool_get_options _obj'+    checkUnexpectedReturnNULL "gst_buffer_pool_get_options" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++data BufferPoolGetOptionsMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolGetOptionsMethodInfo a signature where+    overloadedMethod _ = bufferPoolGetOptions++-- method BufferPool::has_option+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_has_option" gst_buffer_pool_has_option :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    CString ->                              -- option : TBasicType TUTF8+    IO CInt+++bufferPoolHasOption ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> T.Text                               -- option+    -> m Bool                               -- result+bufferPoolHasOption _obj option = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    option' <- textToCString option+    result <- gst_buffer_pool_has_option _obj' option'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem option'+    return result'++data BufferPoolHasOptionMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolHasOptionMethodInfo a signature where+    overloadedMethod _ = bufferPoolHasOption++-- method BufferPool::is_active+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_is_active" gst_buffer_pool_is_active :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    IO CInt+++bufferPoolIsActive ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+bufferPoolIsActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_buffer_pool_is_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BufferPoolIsActiveMethodInfo+instance (signature ~ (m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolIsActiveMethodInfo a signature where+    overloadedMethod _ = bufferPoolIsActive++-- method BufferPool::release_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_release_buffer" gst_buffer_pool_release_buffer :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO ()+++bufferPoolReleaseBuffer ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> Buffer                               -- buffer+    -> m ()                                 -- result+bufferPoolReleaseBuffer _obj buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- copyBoxed buffer+    gst_buffer_pool_release_buffer _obj' buffer'+    touchManagedPtr _obj+    touchManagedPtr buffer+    return ()++data BufferPoolReleaseBufferMethodInfo+instance (signature ~ (Buffer -> m ()), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolReleaseBufferMethodInfo a signature where+    overloadedMethod _ = bufferPoolReleaseBuffer++-- method BufferPool::set_active+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_set_active" gst_buffer_pool_set_active :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++bufferPoolSetActive ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> Bool                                 -- active+    -> m Bool                               -- result+bufferPoolSetActive _obj active = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let active' = (fromIntegral . fromEnum) active+    result <- gst_buffer_pool_set_active _obj' active'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BufferPoolSetActiveMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolSetActiveMethodInfo a signature where+    overloadedMethod _ = bufferPoolSetActive++-- method BufferPool::set_config+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_set_config" gst_buffer_pool_set_config :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    IO CInt+++bufferPoolSetConfig ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> Structure                            -- config+    -> m Bool                               -- result+bufferPoolSetConfig _obj config = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    config' <- copyBoxed config+    result <- gst_buffer_pool_set_config _obj' config'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr config+    return result'++data BufferPoolSetConfigMethodInfo+instance (signature ~ (Structure -> m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolSetConfigMethodInfo a signature where+    overloadedMethod _ = bufferPoolSetConfig++-- method BufferPool::set_flushing+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_set_flushing" gst_buffer_pool_set_flushing :: +    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"+    CInt ->                                 -- flushing : TBasicType TBoolean+    IO ()+++bufferPoolSetFlushing ::+    (MonadIO m, BufferPoolK a) =>+    a                                       -- _obj+    -> Bool                                 -- flushing+    -> m ()                                 -- result+bufferPoolSetFlushing _obj flushing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flushing' = (fromIntegral . fromEnum) flushing+    gst_buffer_pool_set_flushing _obj' flushing'+    touchManagedPtr _obj+    return ()++data BufferPoolSetFlushingMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolSetFlushingMethodInfo a signature where+    overloadedMethod _ = bufferPoolSetFlushing++-- method BufferPool::config_add_option+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_add_option" gst_buffer_pool_config_add_option :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    CString ->                              -- option : TBasicType TUTF8+    IO ()+++bufferPoolConfigAddOption ::+    (MonadIO m) =>+    Structure                               -- config+    -> T.Text                               -- option+    -> m ()                                 -- result+bufferPoolConfigAddOption config option = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    option' <- textToCString option+    gst_buffer_pool_config_add_option config' option'+    touchManagedPtr config+    freeMem option'+    return ()++-- method BufferPool::config_get_allocator+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_get_allocator" gst_buffer_pool_config_get_allocator :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    Ptr (Ptr Allocator) ->                  -- allocator : TInterface "Gst" "Allocator"+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"+    IO CInt+++bufferPoolConfigGetAllocator ::+    (MonadIO m) =>+    Structure                               -- config+    -> m (Bool,Allocator,AllocationParams)  -- result+bufferPoolConfigGetAllocator config = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    allocator <- allocMem :: IO (Ptr (Ptr Allocator))+    params <- callocBoxedBytes 64 :: IO (Ptr AllocationParams)+    result <- gst_buffer_pool_config_get_allocator config' allocator params+    let result' = (/= 0) result+    allocator' <- peek allocator+    allocator'' <- (newObject Allocator) allocator'+    params' <- (wrapBoxed AllocationParams) params+    touchManagedPtr config+    freeMem allocator+    return (result', allocator'', params')++-- method BufferPool::config_get_option+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_get_option" gst_buffer_pool_config_get_option :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    Word32 ->                               -- index : TBasicType TUInt32+    IO CString+++bufferPoolConfigGetOption ::+    (MonadIO m) =>+    Structure                               -- config+    -> Word32                               -- index+    -> m T.Text                             -- result+bufferPoolConfigGetOption config index = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    result <- gst_buffer_pool_config_get_option config' index+    checkUnexpectedReturnNULL "gst_buffer_pool_config_get_option" result+    result' <- cstringToText result+    touchManagedPtr config+    return result'++-- method BufferPool::config_get_params+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_get_params" gst_buffer_pool_config_get_params :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    Ptr Word32 ->                           -- size : TBasicType TUInt32+    Ptr Word32 ->                           -- min_buffers : TBasicType TUInt32+    Ptr Word32 ->                           -- max_buffers : TBasicType TUInt32+    IO CInt+++bufferPoolConfigGetParams ::+    (MonadIO m) =>+    Structure                               -- config+    -> m (Bool,Caps,Word32,Word32,Word32)   -- result+bufferPoolConfigGetParams config = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)+    size <- allocMem :: IO (Ptr Word32)+    minBuffers <- allocMem :: IO (Ptr Word32)+    maxBuffers <- allocMem :: IO (Ptr Word32)+    result <- gst_buffer_pool_config_get_params config' caps size minBuffers maxBuffers+    let result' = (/= 0) result+    caps' <- (wrapBoxed Caps) caps+    size' <- peek size+    minBuffers' <- peek minBuffers+    maxBuffers' <- peek maxBuffers+    touchManagedPtr config+    freeMem size+    freeMem minBuffers+    freeMem maxBuffers+    return (result', caps', size', minBuffers', maxBuffers')++-- method BufferPool::config_has_option+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_has_option" gst_buffer_pool_config_has_option :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    CString ->                              -- option : TBasicType TUTF8+    IO CInt+++bufferPoolConfigHasOption ::+    (MonadIO m) =>+    Structure                               -- config+    -> T.Text                               -- option+    -> m Bool                               -- result+bufferPoolConfigHasOption config option = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    option' <- textToCString option+    result <- gst_buffer_pool_config_has_option config' option'+    let result' = (/= 0) result+    touchManagedPtr config+    freeMem option'+    return result'++-- method BufferPool::config_n_options+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_n_options" gst_buffer_pool_config_n_options :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    IO Word32+++bufferPoolConfigNOptions ::+    (MonadIO m) =>+    Structure                               -- config+    -> m Word32                             -- result+bufferPoolConfigNOptions config = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    result <- gst_buffer_pool_config_n_options config'+    touchManagedPtr config+    return result++-- method BufferPool::config_set_allocator+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_set_allocator" gst_buffer_pool_config_set_allocator :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"+    IO ()+++bufferPoolConfigSetAllocator ::+    (MonadIO m, AllocatorK a) =>+    Structure                               -- config+    -> Maybe (a)                            -- allocator+    -> Maybe (AllocationParams)             -- params+    -> m ()                                 -- result+bufferPoolConfigSetAllocator config allocator params = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    maybeAllocator <- case allocator of+        Nothing -> return nullPtr+        Just jAllocator -> do+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator+            return jAllocator'+    maybeParams <- case params of+        Nothing -> return nullPtr+        Just jParams -> do+            let jParams' = unsafeManagedPtrGetPtr jParams+            return jParams'+    gst_buffer_pool_config_set_allocator config' maybeAllocator maybeParams+    touchManagedPtr config+    whenJust allocator touchManagedPtr+    whenJust params touchManagedPtr+    return ()++-- method BufferPool::config_set_params+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_set_params" gst_buffer_pool_config_set_params :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    Word32 ->                               -- size : TBasicType TUInt32+    Word32 ->                               -- min_buffers : TBasicType TUInt32+    Word32 ->                               -- max_buffers : TBasicType TUInt32+    IO ()+++bufferPoolConfigSetParams ::+    (MonadIO m) =>+    Structure                               -- config+    -> Caps                                 -- caps+    -> Word32                               -- size+    -> Word32                               -- minBuffers+    -> Word32                               -- maxBuffers+    -> m ()                                 -- result+bufferPoolConfigSetParams config caps size minBuffers maxBuffers = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    let caps' = unsafeManagedPtrGetPtr caps+    gst_buffer_pool_config_set_params config' caps' size minBuffers maxBuffers+    touchManagedPtr config+    touchManagedPtr caps+    return ()++-- method BufferPool::config_validate_params+-- method type : MemberFunction+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_pool_config_validate_params" gst_buffer_pool_config_validate_params :: +    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    Word32 ->                               -- size : TBasicType TUInt32+    Word32 ->                               -- min_buffers : TBasicType TUInt32+    Word32 ->                               -- max_buffers : TBasicType TUInt32+    IO CInt+++bufferPoolConfigValidateParams ::+    (MonadIO m) =>+    Structure                               -- config+    -> Caps                                 -- caps+    -> Word32                               -- size+    -> Word32                               -- minBuffers+    -> Word32                               -- maxBuffers+    -> m Bool                               -- result+bufferPoolConfigValidateParams config caps size minBuffers maxBuffers = liftIO $ do+    let config' = unsafeManagedPtrGetPtr config+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_buffer_pool_config_validate_params config' caps' size minBuffers maxBuffers+    let result' = (/= 0) result+    touchManagedPtr config+    touchManagedPtr caps+    return result'++
+ GI/Gst/Objects/BufferPool.hs-boot view
@@ -0,0 +1,22 @@+module GI.Gst.Objects.BufferPool 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++newtype BufferPool = BufferPool (ForeignPtr BufferPool)+instance GObject BufferPool where+class GObject o => BufferPoolK o+instance (GObject o, IsDescendantOf BufferPool o) => BufferPoolK o+data BufferPoolAcquireBufferMethodInfo+data BufferPoolGetConfigMethodInfo+data BufferPoolGetOptionsMethodInfo+data BufferPoolHasOptionMethodInfo+data BufferPoolIsActiveMethodInfo+data BufferPoolReleaseBufferMethodInfo+data BufferPoolSetActiveMethodInfo+data BufferPoolSetConfigMethodInfo+data BufferPoolSetFlushingMethodInfo
+ GI/Gst/Objects/Bus.hs view
@@ -0,0 +1,1024 @@+++{- |+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.Objects.Bus+    ( ++-- * Exported types+    Bus(..)                                 ,+    BusK                                    ,+    toBus                                   ,+    noBus                                   ,+++ -- * Methods+-- ** busAddSignalWatch+    BusAddSignalWatchMethodInfo             ,+    busAddSignalWatch                       ,+++-- ** busAddSignalWatchFull+    BusAddSignalWatchFullMethodInfo         ,+    busAddSignalWatchFull                   ,+++-- ** busAddWatch+    BusAddWatchMethodInfo                   ,+    busAddWatch                             ,+++-- ** busAsyncSignalFunc+    BusAsyncSignalFuncMethodInfo            ,+    busAsyncSignalFunc                      ,+++-- ** busCreateWatch+    BusCreateWatchMethodInfo                ,+    busCreateWatch                          ,+++-- ** busDisableSyncMessageEmission+    BusDisableSyncMessageEmissionMethodInfo ,+    busDisableSyncMessageEmission           ,+++-- ** busEnableSyncMessageEmission+    BusEnableSyncMessageEmissionMethodInfo  ,+    busEnableSyncMessageEmission            ,+++-- ** busHavePending+    BusHavePendingMethodInfo                ,+    busHavePending                          ,+++-- ** busNew+    busNew                                  ,+++-- ** busPeek+    BusPeekMethodInfo                       ,+    busPeek                                 ,+++-- ** busPoll+    BusPollMethodInfo                       ,+    busPoll                                 ,+++-- ** busPop+    BusPopMethodInfo                        ,+    busPop                                  ,+++-- ** busPopFiltered+    BusPopFilteredMethodInfo                ,+    busPopFiltered                          ,+++-- ** busPost+    BusPostMethodInfo                       ,+    busPost                                 ,+++-- ** busRemoveSignalWatch+    BusRemoveSignalWatchMethodInfo          ,+    busRemoveSignalWatch                    ,+++-- ** busRemoveWatch+    BusRemoveWatchMethodInfo                ,+    busRemoveWatch                          ,+++-- ** busSetFlushing+    BusSetFlushingMethodInfo                ,+    busSetFlushing                          ,+++-- ** busSetSyncHandler+    BusSetSyncHandlerMethodInfo             ,+    busSetSyncHandler                       ,+++-- ** busSyncSignalHandler+    BusSyncSignalHandlerMethodInfo          ,+    busSyncSignalHandler                    ,+++-- ** busTimedPop+    BusTimedPopMethodInfo                   ,+    busTimedPop                             ,+++-- ** busTimedPopFiltered+    BusTimedPopFilteredMethodInfo           ,+    busTimedPopFiltered                     ,+++++ -- * Properties+-- ** EnableAsync+    BusEnableAsyncPropertyInfo              ,+    constructBusEnableAsync                 ,+++++ -- * Signals+-- ** Message+    BusMessageCallback                      ,+    BusMessageCallbackC                     ,+    BusMessageSignalInfo                    ,+    afterBusMessage                         ,+    busMessageCallbackWrapper               ,+    busMessageClosure                       ,+    mkBusMessageCallback                    ,+    noBusMessageCallback                    ,+    onBusMessage                            ,+++-- ** SyncMessage+    BusSyncMessageCallback                  ,+    BusSyncMessageCallbackC                 ,+    BusSyncMessageSignalInfo                ,+    afterBusSyncMessage                     ,+    busSyncMessageCallbackWrapper           ,+    busSyncMessageClosure                   ,+    mkBusSyncMessageCallback                ,+    noBusSyncMessageCallback                ,+    onBusSyncMessage                        ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Bus = Bus (ForeignPtr Bus)+foreign import ccall "gst_bus_get_type"+    c_gst_bus_get_type :: IO GType++type instance ParentTypes Bus = BusParentTypes+type BusParentTypes = '[Object, GObject.Object]++instance GObject Bus where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_bus_get_type+    ++class GObject o => BusK o+instance (GObject o, IsDescendantOf Bus o) => BusK o++toBus :: BusK o => o -> IO Bus+toBus = unsafeCastTo Bus++noBus :: Maybe Bus+noBus = Nothing++type family ResolveBusMethod (t :: Symbol) (o :: *) :: * where+    ResolveBusMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveBusMethod "addSignalWatch" o = BusAddSignalWatchMethodInfo+    ResolveBusMethod "addSignalWatchFull" o = BusAddSignalWatchFullMethodInfo+    ResolveBusMethod "addWatch" o = BusAddWatchMethodInfo+    ResolveBusMethod "asyncSignalFunc" o = BusAsyncSignalFuncMethodInfo+    ResolveBusMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveBusMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveBusMethod "createWatch" o = BusCreateWatchMethodInfo+    ResolveBusMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveBusMethod "disableSyncMessageEmission" o = BusDisableSyncMessageEmissionMethodInfo+    ResolveBusMethod "enableSyncMessageEmission" o = BusEnableSyncMessageEmissionMethodInfo+    ResolveBusMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveBusMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveBusMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveBusMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveBusMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveBusMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveBusMethod "havePending" o = BusHavePendingMethodInfo+    ResolveBusMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveBusMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveBusMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveBusMethod "peek" o = BusPeekMethodInfo+    ResolveBusMethod "poll" o = BusPollMethodInfo+    ResolveBusMethod "pop" o = BusPopMethodInfo+    ResolveBusMethod "popFiltered" o = BusPopFilteredMethodInfo+    ResolveBusMethod "post" o = BusPostMethodInfo+    ResolveBusMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveBusMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveBusMethod "removeSignalWatch" o = BusRemoveSignalWatchMethodInfo+    ResolveBusMethod "removeWatch" o = BusRemoveWatchMethodInfo+    ResolveBusMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveBusMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveBusMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveBusMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveBusMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveBusMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveBusMethod "syncSignalHandler" o = BusSyncSignalHandlerMethodInfo+    ResolveBusMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveBusMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveBusMethod "timedPop" o = BusTimedPopMethodInfo+    ResolveBusMethod "timedPopFiltered" o = BusTimedPopFilteredMethodInfo+    ResolveBusMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveBusMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveBusMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveBusMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveBusMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveBusMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveBusMethod "getName" o = ObjectGetNameMethodInfo+    ResolveBusMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveBusMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveBusMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveBusMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveBusMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveBusMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveBusMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveBusMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveBusMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveBusMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveBusMethod "setFlushing" o = BusSetFlushingMethodInfo+    ResolveBusMethod "setName" o = ObjectSetNameMethodInfo+    ResolveBusMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveBusMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveBusMethod "setSyncHandler" o = BusSetSyncHandlerMethodInfo+    ResolveBusMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveBusMethod t Bus, MethodInfo info Bus p) => IsLabelProxy t (Bus -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveBusMethod t Bus, MethodInfo info Bus p) => IsLabel t (Bus -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Bus::message+type BusMessageCallback =+    Message ->+    IO ()++noBusMessageCallback :: Maybe BusMessageCallback+noBusMessageCallback = Nothing++type BusMessageCallbackC =+    Ptr () ->                               -- object+    Ptr Message ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkBusMessageCallback :: BusMessageCallbackC -> IO (FunPtr BusMessageCallbackC)++busMessageClosure :: BusMessageCallback -> IO Closure+busMessageClosure cb = newCClosure =<< mkBusMessageCallback wrapped+    where wrapped = busMessageCallbackWrapper cb++busMessageCallbackWrapper ::+    BusMessageCallback ->+    Ptr () ->+    Ptr Message ->+    Ptr () ->+    IO ()+busMessageCallbackWrapper _cb _ message _ = do+    message' <- (newBoxed Message) message+    _cb  message'++onBusMessage :: (GObject a, MonadIO m) => a -> BusMessageCallback -> m SignalHandlerId+onBusMessage obj cb = liftIO $ connectBusMessage obj cb SignalConnectBefore+afterBusMessage :: (GObject a, MonadIO m) => a -> BusMessageCallback -> m SignalHandlerId+afterBusMessage obj cb = connectBusMessage obj cb SignalConnectAfter++connectBusMessage :: (GObject a, MonadIO m) =>+                     a -> BusMessageCallback -> SignalConnectMode -> m SignalHandlerId+connectBusMessage obj cb after = liftIO $ do+    cb' <- mkBusMessageCallback (busMessageCallbackWrapper cb)+    connectSignalFunPtr obj "message" cb' after++-- signal Bus::sync-message+type BusSyncMessageCallback =+    Message ->+    IO ()++noBusSyncMessageCallback :: Maybe BusSyncMessageCallback+noBusSyncMessageCallback = Nothing++type BusSyncMessageCallbackC =+    Ptr () ->                               -- object+    Ptr Message ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkBusSyncMessageCallback :: BusSyncMessageCallbackC -> IO (FunPtr BusSyncMessageCallbackC)++busSyncMessageClosure :: BusSyncMessageCallback -> IO Closure+busSyncMessageClosure cb = newCClosure =<< mkBusSyncMessageCallback wrapped+    where wrapped = busSyncMessageCallbackWrapper cb++busSyncMessageCallbackWrapper ::+    BusSyncMessageCallback ->+    Ptr () ->+    Ptr Message ->+    Ptr () ->+    IO ()+busSyncMessageCallbackWrapper _cb _ message _ = do+    message' <- (newBoxed Message) message+    _cb  message'++onBusSyncMessage :: (GObject a, MonadIO m) => a -> BusSyncMessageCallback -> m SignalHandlerId+onBusSyncMessage obj cb = liftIO $ connectBusSyncMessage obj cb SignalConnectBefore+afterBusSyncMessage :: (GObject a, MonadIO m) => a -> BusSyncMessageCallback -> m SignalHandlerId+afterBusSyncMessage obj cb = connectBusSyncMessage obj cb SignalConnectAfter++connectBusSyncMessage :: (GObject a, MonadIO m) =>+                         a -> BusSyncMessageCallback -> SignalConnectMode -> m SignalHandlerId+connectBusSyncMessage obj cb after = liftIO $ do+    cb' <- mkBusSyncMessageCallback (busSyncMessageCallbackWrapper cb)+    connectSignalFunPtr obj "sync-message" cb' after++-- VVV Prop "enable-async"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyWritable,PropertyConstructOnly]++constructBusEnableAsync :: Bool -> IO ([Char], GValue)+constructBusEnableAsync val = constructObjectPropertyBool "enable-async" val++data BusEnableAsyncPropertyInfo+instance AttrInfo BusEnableAsyncPropertyInfo where+    type AttrAllowedOps BusEnableAsyncPropertyInfo = '[ 'AttrConstruct]+    type AttrSetTypeConstraint BusEnableAsyncPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint BusEnableAsyncPropertyInfo = BusK+    type AttrGetType BusEnableAsyncPropertyInfo = ()+    type AttrLabel BusEnableAsyncPropertyInfo = "enable-async"+    attrGet _ = undefined+    attrSet _ = undefined+    attrConstruct _ = constructBusEnableAsync++type instance AttributeList Bus = BusAttributeList+type BusAttributeList = ('[ '("enableAsync", BusEnableAsyncPropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++data BusMessageSignalInfo+instance SignalInfo BusMessageSignalInfo where+    type HaskellCallbackType BusMessageSignalInfo = BusMessageCallback+    connectSignal _ = connectBusMessage++data BusSyncMessageSignalInfo+instance SignalInfo BusSyncMessageSignalInfo where+    type HaskellCallbackType BusSyncMessageSignalInfo = BusSyncMessageCallback+    connectSignal _ = connectBusSyncMessage++type instance SignalList Bus = BusSignalList+type BusSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("message", BusMessageSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("syncMessage", BusSyncMessageSignalInfo)] :: [(Symbol, *)])++-- method Bus::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Bus"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_new" gst_bus_new :: +    IO (Ptr Bus)+++busNew ::+    (MonadIO m) =>+    m Bus                                   -- result+busNew  = liftIO $ do+    result <- gst_bus_new+    checkUnexpectedReturnNULL "gst_bus_new" result+    result' <- (wrapObject Bus) result+    return result'++-- method Bus::add_signal_watch+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_add_signal_watch" gst_bus_add_signal_watch :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO ()+++busAddSignalWatch ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+busAddSignalWatch _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_bus_add_signal_watch _obj'+    touchManagedPtr _obj+    return ()++data BusAddSignalWatchMethodInfo+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusAddSignalWatchMethodInfo a signature where+    overloadedMethod _ = busAddSignalWatch++-- method Bus::add_signal_watch_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_add_signal_watch_full" gst_bus_add_signal_watch_full :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    Int32 ->                                -- priority : TBasicType TInt32+    IO ()+++busAddSignalWatchFull ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Int32                                -- priority+    -> m ()                                 -- result+busAddSignalWatchFull _obj priority = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_bus_add_signal_watch_full _obj' priority+    touchManagedPtr _obj+    return ()++data BusAddSignalWatchFullMethodInfo+instance (signature ~ (Int32 -> m ()), MonadIO m, BusK a) => MethodInfo BusAddSignalWatchFullMethodInfo a signature where+    overloadedMethod _ = busAddSignalWatchFull++-- method Bus::add_watch+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BusFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_add_watch_full" gst_bus_add_watch_full :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    Int32 ->                                -- priority : TBasicType TInt32+    FunPtr BusFuncC ->                      -- func : TInterface "Gst" "BusFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO Word32+++busAddWatch ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Int32                                -- priority+    -> BusFunc                              -- func+    -> m Word32                             -- result+busAddWatch _obj priority func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkBusFunc (busFuncWrapper Nothing func)+    let userData = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    result <- gst_bus_add_watch_full _obj' priority func' userData notify+    touchManagedPtr _obj+    return result++data BusAddWatchMethodInfo+instance (signature ~ (Int32 -> BusFunc -> m Word32), MonadIO m, BusK a) => MethodInfo BusAddWatchMethodInfo a signature where+    overloadedMethod _ = busAddWatch++-- method Bus::async_signal_func+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_async_signal_func" gst_bus_async_signal_func :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    Ptr Message ->                          -- message : TInterface "Gst" "Message"+    Ptr () ->                               -- data : TBasicType TVoid+    IO CInt+++busAsyncSignalFunc ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Message                              -- message+    -> Ptr ()                               -- data_+    -> m Bool                               -- result+busAsyncSignalFunc _obj message data_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let message' = unsafeManagedPtrGetPtr message+    result <- gst_bus_async_signal_func _obj' message' data_+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr message+    return result'++data BusAsyncSignalFuncMethodInfo+instance (signature ~ (Message -> Ptr () -> m Bool), MonadIO m, BusK a) => MethodInfo BusAsyncSignalFuncMethodInfo a signature where+    overloadedMethod _ = busAsyncSignalFunc++-- method Bus::create_watch+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GLib" "Source"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_create_watch" gst_bus_create_watch :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO (Ptr GLib.Source)+++busCreateWatch ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m GLib.Source                        -- result+busCreateWatch _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bus_create_watch _obj'+    checkUnexpectedReturnNULL "gst_bus_create_watch" result+    result' <- (wrapBoxed GLib.Source) result+    touchManagedPtr _obj+    return result'++data BusCreateWatchMethodInfo+instance (signature ~ (m GLib.Source), MonadIO m, BusK a) => MethodInfo BusCreateWatchMethodInfo a signature where+    overloadedMethod _ = busCreateWatch++-- method Bus::disable_sync_message_emission+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_disable_sync_message_emission" gst_bus_disable_sync_message_emission :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO ()+++busDisableSyncMessageEmission ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+busDisableSyncMessageEmission _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_bus_disable_sync_message_emission _obj'+    touchManagedPtr _obj+    return ()++data BusDisableSyncMessageEmissionMethodInfo+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusDisableSyncMessageEmissionMethodInfo a signature where+    overloadedMethod _ = busDisableSyncMessageEmission++-- method Bus::enable_sync_message_emission+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_enable_sync_message_emission" gst_bus_enable_sync_message_emission :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO ()+++busEnableSyncMessageEmission ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+busEnableSyncMessageEmission _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_bus_enable_sync_message_emission _obj'+    touchManagedPtr _obj+    return ()++data BusEnableSyncMessageEmissionMethodInfo+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusEnableSyncMessageEmissionMethodInfo a signature where+    overloadedMethod _ = busEnableSyncMessageEmission++-- method Bus::have_pending+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_have_pending" gst_bus_have_pending :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO CInt+++busHavePending ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+busHavePending _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bus_have_pending _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BusHavePendingMethodInfo+instance (signature ~ (m Bool), MonadIO m, BusK a) => MethodInfo BusHavePendingMethodInfo a signature where+    overloadedMethod _ = busHavePending++-- method Bus::peek+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_peek" gst_bus_peek :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO (Ptr Message)+++busPeek ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m Message                            -- result+busPeek _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bus_peek _obj'+    checkUnexpectedReturnNULL "gst_bus_peek" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr _obj+    return result'++data BusPeekMethodInfo+instance (signature ~ (m Message), MonadIO m, BusK a) => MethodInfo BusPeekMethodInfo a signature where+    overloadedMethod _ = busPeek++-- method Bus::poll+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "events", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_poll" gst_bus_poll :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    CUInt ->                                -- events : TInterface "Gst" "MessageType"+    Word64 ->                               -- timeout : TBasicType TUInt64+    IO (Ptr Message)+++busPoll ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> [MessageType]                        -- events+    -> Word64                               -- timeout+    -> m Message                            -- result+busPoll _obj events timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let events' = gflagsToWord events+    result <- gst_bus_poll _obj' events' timeout+    checkUnexpectedReturnNULL "gst_bus_poll" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr _obj+    return result'++data BusPollMethodInfo+instance (signature ~ ([MessageType] -> Word64 -> m Message), MonadIO m, BusK a) => MethodInfo BusPollMethodInfo a signature where+    overloadedMethod _ = busPoll++-- method Bus::pop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_pop" gst_bus_pop :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO (Ptr Message)+++busPop ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m Message                            -- result+busPop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bus_pop _obj'+    checkUnexpectedReturnNULL "gst_bus_pop" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr _obj+    return result'++data BusPopMethodInfo+instance (signature ~ (m Message), MonadIO m, BusK a) => MethodInfo BusPopMethodInfo a signature where+    overloadedMethod _ = busPop++-- method Bus::pop_filtered+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_pop_filtered" gst_bus_pop_filtered :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    CUInt ->                                -- types : TInterface "Gst" "MessageType"+    IO (Ptr Message)+++busPopFiltered ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> [MessageType]                        -- types+    -> m Message                            -- result+busPopFiltered _obj types = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let types' = gflagsToWord types+    result <- gst_bus_pop_filtered _obj' types'+    checkUnexpectedReturnNULL "gst_bus_pop_filtered" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr _obj+    return result'++data BusPopFilteredMethodInfo+instance (signature ~ ([MessageType] -> m Message), MonadIO m, BusK a) => MethodInfo BusPopFilteredMethodInfo a signature where+    overloadedMethod _ = busPopFiltered++-- method Bus::post+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_post" gst_bus_post :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    Ptr Message ->                          -- message : TInterface "Gst" "Message"+    IO CInt+++busPost ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Message                              -- message+    -> m Bool                               -- result+busPost _obj message = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    message' <- copyBoxed message+    result <- gst_bus_post _obj' message'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr message+    return result'++data BusPostMethodInfo+instance (signature ~ (Message -> m Bool), MonadIO m, BusK a) => MethodInfo BusPostMethodInfo a signature where+    overloadedMethod _ = busPost++-- method Bus::remove_signal_watch+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_remove_signal_watch" gst_bus_remove_signal_watch :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO ()+++busRemoveSignalWatch ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+busRemoveSignalWatch _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_bus_remove_signal_watch _obj'+    touchManagedPtr _obj+    return ()++data BusRemoveSignalWatchMethodInfo+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusRemoveSignalWatchMethodInfo a signature where+    overloadedMethod _ = busRemoveSignalWatch++-- method Bus::remove_watch+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_remove_watch" gst_bus_remove_watch :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    IO CInt+++busRemoveWatch ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+busRemoveWatch _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bus_remove_watch _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BusRemoveWatchMethodInfo+instance (signature ~ (m Bool), MonadIO m, BusK a) => MethodInfo BusRemoveWatchMethodInfo a signature where+    overloadedMethod _ = busRemoveWatch++-- method Bus::set_flushing+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_set_flushing" gst_bus_set_flushing :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    CInt ->                                 -- flushing : TBasicType TBoolean+    IO ()+++busSetFlushing ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Bool                                 -- flushing+    -> m ()                                 -- result+busSetFlushing _obj flushing = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let flushing' = (fromIntegral . fromEnum) flushing+    gst_bus_set_flushing _obj' flushing'+    touchManagedPtr _obj+    return ()++data BusSetFlushingMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, BusK a) => MethodInfo BusSetFlushingMethodInfo a signature where+    overloadedMethod _ = busSetFlushing++-- method Bus::set_sync_handler+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BusSyncHandler", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_set_sync_handler" gst_bus_set_sync_handler :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    FunPtr BusSyncHandlerC ->               -- func : TInterface "Gst" "BusSyncHandler"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++busSetSyncHandler ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Maybe (BusSyncHandler)               -- func+    -> m ()                                 -- result+busSetSyncHandler _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFunc <- case func of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jFunc -> do+            jFunc' <- mkBusSyncHandler (busSyncHandlerWrapper Nothing jFunc)+            return jFunc'+    let userData = castFunPtrToPtr maybeFunc+    let notify = safeFreeFunPtrPtr+    gst_bus_set_sync_handler _obj' maybeFunc userData notify+    touchManagedPtr _obj+    return ()++data BusSetSyncHandlerMethodInfo+instance (signature ~ (Maybe (BusSyncHandler) -> m ()), MonadIO m, BusK a) => MethodInfo BusSetSyncHandlerMethodInfo a signature where+    overloadedMethod _ = busSetSyncHandler++-- method Bus::sync_signal_handler+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "BusSyncReply"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_sync_signal_handler" gst_bus_sync_signal_handler :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    Ptr Message ->                          -- message : TInterface "Gst" "Message"+    Ptr () ->                               -- data : TBasicType TVoid+    IO CUInt+++busSyncSignalHandler ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Message                              -- message+    -> Ptr ()                               -- data_+    -> m BusSyncReply                       -- result+busSyncSignalHandler _obj message data_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let message' = unsafeManagedPtrGetPtr message+    result <- gst_bus_sync_signal_handler _obj' message' data_+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr message+    return result'++data BusSyncSignalHandlerMethodInfo+instance (signature ~ (Message -> Ptr () -> m BusSyncReply), MonadIO m, BusK a) => MethodInfo BusSyncSignalHandlerMethodInfo a signature where+    overloadedMethod _ = busSyncSignalHandler++-- method Bus::timed_pop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_timed_pop" gst_bus_timed_pop :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    Word64 ->                               -- timeout : TBasicType TUInt64+    IO (Ptr Message)+++busTimedPop ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Word64                               -- timeout+    -> m Message                            -- result+busTimedPop _obj timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_bus_timed_pop _obj' timeout+    checkUnexpectedReturnNULL "gst_bus_timed_pop" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr _obj+    return result'++data BusTimedPopMethodInfo+instance (signature ~ (Word64 -> m Message), MonadIO m, BusK a) => MethodInfo BusTimedPopMethodInfo a signature where+    overloadedMethod _ = busTimedPop++-- method Bus::timed_pop_filtered+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_bus_timed_pop_filtered" gst_bus_timed_pop_filtered :: +    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"+    Word64 ->                               -- timeout : TBasicType TUInt64+    CUInt ->                                -- types : TInterface "Gst" "MessageType"+    IO (Ptr Message)+++busTimedPopFiltered ::+    (MonadIO m, BusK a) =>+    a                                       -- _obj+    -> Word64                               -- timeout+    -> [MessageType]                        -- types+    -> m Message                            -- result+busTimedPopFiltered _obj timeout types = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let types' = gflagsToWord types+    result <- gst_bus_timed_pop_filtered _obj' timeout types'+    checkUnexpectedReturnNULL "gst_bus_timed_pop_filtered" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr _obj+    return result'++data BusTimedPopFilteredMethodInfo+instance (signature ~ (Word64 -> [MessageType] -> m Message), MonadIO m, BusK a) => MethodInfo BusTimedPopFilteredMethodInfo a signature where+    overloadedMethod _ = busTimedPopFiltered++
+ GI/Gst/Objects/Bus.hs-boot view
@@ -0,0 +1,36 @@+module GI.Gst.Objects.Bus 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++newtype Bus = Bus (ForeignPtr Bus)+instance GObject Bus where+class GObject o => BusK o+instance (GObject o, IsDescendantOf Bus o) => BusK o+data BusEnableAsyncPropertyInfo+data BusMessageSignalInfo+data BusSyncMessageSignalInfo+data BusAddSignalWatchMethodInfo+data BusAddSignalWatchFullMethodInfo+data BusAddWatchMethodInfo+data BusAsyncSignalFuncMethodInfo+data BusCreateWatchMethodInfo+data BusDisableSyncMessageEmissionMethodInfo+data BusEnableSyncMessageEmissionMethodInfo+data BusHavePendingMethodInfo+data BusPeekMethodInfo+data BusPollMethodInfo+data BusPopMethodInfo+data BusPopFilteredMethodInfo+data BusPostMethodInfo+data BusRemoveSignalWatchMethodInfo+data BusRemoveWatchMethodInfo+data BusSetFlushingMethodInfo+data BusSetSyncHandlerMethodInfo+data BusSyncSignalHandlerMethodInfo+data BusTimedPopMethodInfo+data BusTimedPopFilteredMethodInfo
+ GI/Gst/Objects/Clock.hs view
@@ -0,0 +1,1305 @@+++{- |+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.Objects.Clock+    ( ++-- * Exported types+    Clock(..)                               ,+    ClockK                                  ,+    toClock                                 ,+    noClock                                 ,+++ -- * Methods+-- ** clockAddObservation+    ClockAddObservationMethodInfo           ,+    clockAddObservation                     ,+++-- ** clockAddObservationUnapplied+    ClockAddObservationUnappliedMethodInfo  ,+    clockAddObservationUnapplied            ,+++-- ** clockAdjustUnlocked+    ClockAdjustUnlockedMethodInfo           ,+    clockAdjustUnlocked                     ,+++-- ** clockAdjustWithCalibration+    ClockAdjustWithCalibrationMethodInfo    ,+    clockAdjustWithCalibration              ,+++-- ** clockGetCalibration+    ClockGetCalibrationMethodInfo           ,+    clockGetCalibration                     ,+++-- ** clockGetInternalTime+    ClockGetInternalTimeMethodInfo          ,+    clockGetInternalTime                    ,+++-- ** clockGetMaster+    ClockGetMasterMethodInfo                ,+    clockGetMaster                          ,+++-- ** clockGetResolution+    ClockGetResolutionMethodInfo            ,+    clockGetResolution                      ,+++-- ** clockGetTime+    ClockGetTimeMethodInfo                  ,+    clockGetTime                            ,+++-- ** clockGetTimeout+    ClockGetTimeoutMethodInfo               ,+    clockGetTimeout                         ,+++-- ** clockIdCompareFunc+    clockIdCompareFunc                      ,+++-- ** clockIdGetTime+    clockIdGetTime                          ,+++-- ** clockIdRef+    clockIdRef                              ,+++-- ** clockIdUnref+    clockIdUnref                            ,+++-- ** clockIdUnschedule+    clockIdUnschedule                       ,+++-- ** clockIdWait+    clockIdWait                             ,+++-- ** clockIdWaitAsync+    clockIdWaitAsync                        ,+++-- ** clockIsSynced+    ClockIsSyncedMethodInfo                 ,+    clockIsSynced                           ,+++-- ** clockNewPeriodicId+    ClockNewPeriodicIdMethodInfo            ,+    clockNewPeriodicId                      ,+++-- ** clockNewSingleShotId+    ClockNewSingleShotIdMethodInfo          ,+    clockNewSingleShotId                    ,+++-- ** clockPeriodicIdReinit+    ClockPeriodicIdReinitMethodInfo         ,+    clockPeriodicIdReinit                   ,+++-- ** clockSetCalibration+    ClockSetCalibrationMethodInfo           ,+    clockSetCalibration                     ,+++-- ** clockSetMaster+    ClockSetMasterMethodInfo                ,+    clockSetMaster                          ,+++-- ** clockSetResolution+    ClockSetResolutionMethodInfo            ,+    clockSetResolution                      ,+++-- ** clockSetSynced+    ClockSetSyncedMethodInfo                ,+    clockSetSynced                          ,+++-- ** clockSetTimeout+    ClockSetTimeoutMethodInfo               ,+    clockSetTimeout                         ,+++-- ** clockSingleShotIdReinit+    ClockSingleShotIdReinitMethodInfo       ,+    clockSingleShotIdReinit                 ,+++-- ** clockUnadjustUnlocked+    ClockUnadjustUnlockedMethodInfo         ,+    clockUnadjustUnlocked                   ,+++-- ** clockWaitForSync+    ClockWaitForSyncMethodInfo              ,+    clockWaitForSync                        ,+++++ -- * Properties+-- ** Timeout+    ClockTimeoutPropertyInfo                ,+    constructClockTimeout                   ,+    getClockTimeout                         ,+    setClockTimeout                         ,+++-- ** WindowSize+    ClockWindowSizePropertyInfo             ,+    constructClockWindowSize                ,+    getClockWindowSize                      ,+    setClockWindowSize                      ,+++-- ** WindowThreshold+    ClockWindowThresholdPropertyInfo        ,+    constructClockWindowThreshold           ,+    getClockWindowThreshold                 ,+    setClockWindowThreshold                 ,+++++ -- * Signals+-- ** Synced+    ClockSyncedCallback                     ,+    ClockSyncedCallbackC                    ,+    ClockSyncedSignalInfo                   ,+    afterClockSynced                        ,+    clockSyncedCallbackWrapper              ,+    clockSyncedClosure                      ,+    mkClockSyncedCallback                   ,+    noClockSyncedCallback                   ,+    onClockSynced                           ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Clock = Clock (ForeignPtr Clock)+foreign import ccall "gst_clock_get_type"+    c_gst_clock_get_type :: IO GType++type instance ParentTypes Clock = ClockParentTypes+type ClockParentTypes = '[Object, GObject.Object]++instance GObject Clock where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_clock_get_type+    ++class GObject o => ClockK o+instance (GObject o, IsDescendantOf Clock o) => ClockK o++toClock :: ClockK o => o -> IO Clock+toClock = unsafeCastTo Clock++noClock :: Maybe Clock+noClock = Nothing++type family ResolveClockMethod (t :: Symbol) (o :: *) :: * where+    ResolveClockMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveClockMethod "addObservation" o = ClockAddObservationMethodInfo+    ResolveClockMethod "addObservationUnapplied" o = ClockAddObservationUnappliedMethodInfo+    ResolveClockMethod "adjustUnlocked" o = ClockAdjustUnlockedMethodInfo+    ResolveClockMethod "adjustWithCalibration" o = ClockAdjustWithCalibrationMethodInfo+    ResolveClockMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveClockMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveClockMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveClockMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveClockMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveClockMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveClockMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveClockMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveClockMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveClockMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveClockMethod "isSynced" o = ClockIsSyncedMethodInfo+    ResolveClockMethod "newPeriodicId" o = ClockNewPeriodicIdMethodInfo+    ResolveClockMethod "newSingleShotId" o = ClockNewSingleShotIdMethodInfo+    ResolveClockMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveClockMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveClockMethod "periodicIdReinit" o = ClockPeriodicIdReinitMethodInfo+    ResolveClockMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveClockMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveClockMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveClockMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveClockMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveClockMethod "singleShotIdReinit" o = ClockSingleShotIdReinitMethodInfo+    ResolveClockMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveClockMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveClockMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveClockMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveClockMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveClockMethod "unadjustUnlocked" o = ClockUnadjustUnlockedMethodInfo+    ResolveClockMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveClockMethod "waitForSync" o = ClockWaitForSyncMethodInfo+    ResolveClockMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveClockMethod "getCalibration" o = ClockGetCalibrationMethodInfo+    ResolveClockMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveClockMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveClockMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveClockMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveClockMethod "getInternalTime" o = ClockGetInternalTimeMethodInfo+    ResolveClockMethod "getMaster" o = ClockGetMasterMethodInfo+    ResolveClockMethod "getName" o = ObjectGetNameMethodInfo+    ResolveClockMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveClockMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveClockMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveClockMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveClockMethod "getResolution" o = ClockGetResolutionMethodInfo+    ResolveClockMethod "getTime" o = ClockGetTimeMethodInfo+    ResolveClockMethod "getTimeout" o = ClockGetTimeoutMethodInfo+    ResolveClockMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveClockMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveClockMethod "setCalibration" o = ClockSetCalibrationMethodInfo+    ResolveClockMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveClockMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveClockMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveClockMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveClockMethod "setMaster" o = ClockSetMasterMethodInfo+    ResolveClockMethod "setName" o = ObjectSetNameMethodInfo+    ResolveClockMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveClockMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveClockMethod "setResolution" o = ClockSetResolutionMethodInfo+    ResolveClockMethod "setSynced" o = ClockSetSyncedMethodInfo+    ResolveClockMethod "setTimeout" o = ClockSetTimeoutMethodInfo+    ResolveClockMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveClockMethod t Clock, MethodInfo info Clock p) => IsLabelProxy t (Clock -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveClockMethod t Clock, MethodInfo info Clock p) => IsLabel t (Clock -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Clock::synced+type ClockSyncedCallback =+    Bool ->+    IO ()++noClockSyncedCallback :: Maybe ClockSyncedCallback+noClockSyncedCallback = Nothing++type ClockSyncedCallbackC =+    Ptr () ->                               -- object+    CInt ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkClockSyncedCallback :: ClockSyncedCallbackC -> IO (FunPtr ClockSyncedCallbackC)++clockSyncedClosure :: ClockSyncedCallback -> IO Closure+clockSyncedClosure cb = newCClosure =<< mkClockSyncedCallback wrapped+    where wrapped = clockSyncedCallbackWrapper cb++clockSyncedCallbackWrapper ::+    ClockSyncedCallback ->+    Ptr () ->+    CInt ->+    Ptr () ->+    IO ()+clockSyncedCallbackWrapper _cb _ synced _ = do+    let synced' = (/= 0) synced+    _cb  synced'++onClockSynced :: (GObject a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId+onClockSynced obj cb = liftIO $ connectClockSynced obj cb SignalConnectBefore+afterClockSynced :: (GObject a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId+afterClockSynced obj cb = connectClockSynced obj cb SignalConnectAfter++connectClockSynced :: (GObject a, MonadIO m) =>+                      a -> ClockSyncedCallback -> SignalConnectMode -> m SignalHandlerId+connectClockSynced obj cb after = liftIO $ do+    cb' <- mkClockSyncedCallback (clockSyncedCallbackWrapper cb)+    connectSignalFunPtr obj "synced" cb' after++-- VVV Prop "timeout"+   -- Type: TBasicType TUInt64+   -- Flags: [PropertyReadable,PropertyWritable]++getClockTimeout :: (MonadIO m, ClockK o) => o -> m Word64+getClockTimeout obj = liftIO $ getObjectPropertyUInt64 obj "timeout"++setClockTimeout :: (MonadIO m, ClockK o) => o -> Word64 -> m ()+setClockTimeout obj val = liftIO $ setObjectPropertyUInt64 obj "timeout" val++constructClockTimeout :: Word64 -> IO ([Char], GValue)+constructClockTimeout val = constructObjectPropertyUInt64 "timeout" val++data ClockTimeoutPropertyInfo+instance AttrInfo ClockTimeoutPropertyInfo where+    type AttrAllowedOps ClockTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ClockTimeoutPropertyInfo = (~) Word64+    type AttrBaseTypeConstraint ClockTimeoutPropertyInfo = ClockK+    type AttrGetType ClockTimeoutPropertyInfo = Word64+    type AttrLabel ClockTimeoutPropertyInfo = "timeout"+    attrGet _ = getClockTimeout+    attrSet _ = setClockTimeout+    attrConstruct _ = constructClockTimeout++-- VVV Prop "window-size"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getClockWindowSize :: (MonadIO m, ClockK o) => o -> m Int32+getClockWindowSize obj = liftIO $ getObjectPropertyCInt obj "window-size"++setClockWindowSize :: (MonadIO m, ClockK o) => o -> Int32 -> m ()+setClockWindowSize obj val = liftIO $ setObjectPropertyCInt obj "window-size" val++constructClockWindowSize :: Int32 -> IO ([Char], GValue)+constructClockWindowSize val = constructObjectPropertyCInt "window-size" val++data ClockWindowSizePropertyInfo+instance AttrInfo ClockWindowSizePropertyInfo where+    type AttrAllowedOps ClockWindowSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ClockWindowSizePropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ClockWindowSizePropertyInfo = ClockK+    type AttrGetType ClockWindowSizePropertyInfo = Int32+    type AttrLabel ClockWindowSizePropertyInfo = "window-size"+    attrGet _ = getClockWindowSize+    attrSet _ = setClockWindowSize+    attrConstruct _ = constructClockWindowSize++-- VVV Prop "window-threshold"+   -- Type: TBasicType TInt32+   -- Flags: [PropertyReadable,PropertyWritable]++getClockWindowThreshold :: (MonadIO m, ClockK o) => o -> m Int32+getClockWindowThreshold obj = liftIO $ getObjectPropertyCInt obj "window-threshold"++setClockWindowThreshold :: (MonadIO m, ClockK o) => o -> Int32 -> m ()+setClockWindowThreshold obj val = liftIO $ setObjectPropertyCInt obj "window-threshold" val++constructClockWindowThreshold :: Int32 -> IO ([Char], GValue)+constructClockWindowThreshold val = constructObjectPropertyCInt "window-threshold" val++data ClockWindowThresholdPropertyInfo+instance AttrInfo ClockWindowThresholdPropertyInfo where+    type AttrAllowedOps ClockWindowThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ClockWindowThresholdPropertyInfo = (~) Int32+    type AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo = ClockK+    type AttrGetType ClockWindowThresholdPropertyInfo = Int32+    type AttrLabel ClockWindowThresholdPropertyInfo = "window-threshold"+    attrGet _ = getClockWindowThreshold+    attrSet _ = setClockWindowThreshold+    attrConstruct _ = constructClockWindowThreshold++type instance AttributeList Clock = ClockAttributeList+type ClockAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("timeout", ClockTimeoutPropertyInfo), '("windowSize", ClockWindowSizePropertyInfo), '("windowThreshold", ClockWindowThresholdPropertyInfo)] :: [(Symbol, *)])++data ClockSyncedSignalInfo+instance SignalInfo ClockSyncedSignalInfo where+    type HaskellCallbackType ClockSyncedSignalInfo = ClockSyncedCallback+    connectSignal _ = connectClockSynced++type instance SignalList Clock = ClockSignalList+type ClockSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("synced", ClockSyncedSignalInfo)] :: [(Symbol, *)])++-- method Clock::add_observation+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "slave", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "master", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "r_squared", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_add_observation" gst_clock_add_observation :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- slave : TBasicType TUInt64+    Word64 ->                               -- master : TBasicType TUInt64+    Ptr CDouble ->                          -- r_squared : TBasicType TDouble+    IO CInt+++clockAddObservation ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- slave+    -> Word64                               -- master+    -> m (Bool,Double)                      -- result+clockAddObservation _obj slave master = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rSquared <- allocMem :: IO (Ptr CDouble)+    result <- gst_clock_add_observation _obj' slave master rSquared+    let result' = (/= 0) result+    rSquared' <- peek rSquared+    let rSquared'' = realToFrac rSquared'+    touchManagedPtr _obj+    freeMem rSquared+    return (result', rSquared'')++data ClockAddObservationMethodInfo+instance (signature ~ (Word64 -> Word64 -> m (Bool,Double)), MonadIO m, ClockK a) => MethodInfo ClockAddObservationMethodInfo a signature where+    overloadedMethod _ = clockAddObservation++-- method Clock::add_observation_unapplied+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "slave", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "master", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "r_squared", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_num", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_denom", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_add_observation_unapplied" gst_clock_add_observation_unapplied :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- slave : TBasicType TUInt64+    Word64 ->                               -- master : TBasicType TUInt64+    Ptr CDouble ->                          -- r_squared : TBasicType TDouble+    Ptr Word64 ->                           -- internal : TBasicType TUInt64+    Ptr Word64 ->                           -- external : TBasicType TUInt64+    Ptr Word64 ->                           -- rate_num : TBasicType TUInt64+    Ptr Word64 ->                           -- rate_denom : TBasicType TUInt64+    IO CInt+++clockAddObservationUnapplied ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- slave+    -> Word64                               -- master+    -> m (Bool,Double,Word64,Word64,Word64,Word64)-- result+clockAddObservationUnapplied _obj slave master = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    rSquared <- allocMem :: IO (Ptr CDouble)+    internal <- allocMem :: IO (Ptr Word64)+    external <- allocMem :: IO (Ptr Word64)+    rateNum <- allocMem :: IO (Ptr Word64)+    rateDenom <- allocMem :: IO (Ptr Word64)+    result <- gst_clock_add_observation_unapplied _obj' slave master rSquared internal external rateNum rateDenom+    let result' = (/= 0) result+    rSquared' <- peek rSquared+    let rSquared'' = realToFrac rSquared'+    internal' <- peek internal+    external' <- peek external+    rateNum' <- peek rateNum+    rateDenom' <- peek rateDenom+    touchManagedPtr _obj+    freeMem rSquared+    freeMem internal+    freeMem external+    freeMem rateNum+    freeMem rateDenom+    return (result', rSquared'', internal', external', rateNum', rateDenom')++data ClockAddObservationUnappliedMethodInfo+instance (signature ~ (Word64 -> Word64 -> m (Bool,Double,Word64,Word64,Word64,Word64)), MonadIO m, ClockK a) => MethodInfo ClockAddObservationUnappliedMethodInfo a signature where+    overloadedMethod _ = clockAddObservationUnapplied++-- method Clock::adjust_unlocked+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_adjust_unlocked" gst_clock_adjust_unlocked :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- internal : TBasicType TUInt64+    IO Word64+++clockAdjustUnlocked ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- internal+    -> m Word64                             -- result+clockAdjustUnlocked _obj internal = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_adjust_unlocked _obj' internal+    touchManagedPtr _obj+    return result++data ClockAdjustUnlockedMethodInfo+instance (signature ~ (Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockAdjustUnlockedMethodInfo a signature where+    overloadedMethod _ = clockAdjustUnlocked++-- method Clock::adjust_with_calibration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal_target", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cinternal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cexternal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cnum", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cdenom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_adjust_with_calibration" gst_clock_adjust_with_calibration :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- internal_target : TBasicType TUInt64+    Word64 ->                               -- cinternal : TBasicType TUInt64+    Word64 ->                               -- cexternal : TBasicType TUInt64+    Word64 ->                               -- cnum : TBasicType TUInt64+    Word64 ->                               -- cdenom : TBasicType TUInt64+    IO Word64+++clockAdjustWithCalibration ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- internalTarget+    -> Word64                               -- cinternal+    -> Word64                               -- cexternal+    -> Word64                               -- cnum+    -> Word64                               -- cdenom+    -> m Word64                             -- result+clockAdjustWithCalibration _obj internalTarget cinternal cexternal cnum cdenom = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_adjust_with_calibration _obj' internalTarget cinternal cexternal cnum cdenom+    touchManagedPtr _obj+    return result++data ClockAdjustWithCalibrationMethodInfo+instance (signature ~ (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockAdjustWithCalibrationMethodInfo a signature where+    overloadedMethod _ = clockAdjustWithCalibration++-- method Clock::get_calibration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_num", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_denom", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_get_calibration" gst_clock_get_calibration :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Ptr Word64 ->                           -- internal : TBasicType TUInt64+    Ptr Word64 ->                           -- external : TBasicType TUInt64+    Ptr Word64 ->                           -- rate_num : TBasicType TUInt64+    Ptr Word64 ->                           -- rate_denom : TBasicType TUInt64+    IO ()+++clockGetCalibration ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> m (Word64,Word64,Word64,Word64)      -- result+clockGetCalibration _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    internal <- allocMem :: IO (Ptr Word64)+    external <- allocMem :: IO (Ptr Word64)+    rateNum <- allocMem :: IO (Ptr Word64)+    rateDenom <- allocMem :: IO (Ptr Word64)+    gst_clock_get_calibration _obj' internal external rateNum rateDenom+    internal' <- peek internal+    external' <- peek external+    rateNum' <- peek rateNum+    rateDenom' <- peek rateDenom+    touchManagedPtr _obj+    freeMem internal+    freeMem external+    freeMem rateNum+    freeMem rateDenom+    return (internal', external', rateNum', rateDenom')++data ClockGetCalibrationMethodInfo+instance (signature ~ (m (Word64,Word64,Word64,Word64)), MonadIO m, ClockK a) => MethodInfo ClockGetCalibrationMethodInfo a signature where+    overloadedMethod _ = clockGetCalibration++-- method Clock::get_internal_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_get_internal_time" gst_clock_get_internal_time :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    IO Word64+++clockGetInternalTime ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+clockGetInternalTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_get_internal_time _obj'+    touchManagedPtr _obj+    return result++data ClockGetInternalTimeMethodInfo+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetInternalTimeMethodInfo a signature where+    overloadedMethod _ = clockGetInternalTime++-- method Clock::get_master+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Clock"+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_get_master" gst_clock_get_master :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    IO (Ptr Clock)+++clockGetMaster ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> m Clock                              -- result+clockGetMaster _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_get_master _obj'+    checkUnexpectedReturnNULL "gst_clock_get_master" result+    result' <- (wrapObject Clock) result+    touchManagedPtr _obj+    return result'++data ClockGetMasterMethodInfo+instance (signature ~ (m Clock), MonadIO m, ClockK a) => MethodInfo ClockGetMasterMethodInfo a signature where+    overloadedMethod _ = clockGetMaster++-- method Clock::get_resolution+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_get_resolution" gst_clock_get_resolution :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    IO Word64+++clockGetResolution ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+clockGetResolution _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_get_resolution _obj'+    touchManagedPtr _obj+    return result++data ClockGetResolutionMethodInfo+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetResolutionMethodInfo a signature where+    overloadedMethod _ = clockGetResolution++-- method Clock::get_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_get_time" gst_clock_get_time :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    IO Word64+++clockGetTime ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+clockGetTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_get_time _obj'+    touchManagedPtr _obj+    return result++data ClockGetTimeMethodInfo+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetTimeMethodInfo a signature where+    overloadedMethod _ = clockGetTime++-- method Clock::get_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_get_timeout" gst_clock_get_timeout :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    IO Word64+++clockGetTimeout ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+clockGetTimeout _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_get_timeout _obj'+    touchManagedPtr _obj+    return result++data ClockGetTimeoutMethodInfo+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetTimeoutMethodInfo a signature where+    overloadedMethod _ = clockGetTimeout++-- method Clock::is_synced+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_is_synced" gst_clock_is_synced :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    IO CInt+++clockIsSynced ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+clockIsSynced _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_is_synced _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ClockIsSyncedMethodInfo+instance (signature ~ (m Bool), MonadIO m, ClockK a) => MethodInfo ClockIsSyncedMethodInfo a signature where+    overloadedMethod _ = clockIsSynced++-- method Clock::new_periodic_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_new_periodic_id" gst_clock_new_periodic_id :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- start_time : TBasicType TUInt64+    Word64 ->                               -- interval : TBasicType TUInt64+    IO ()+++clockNewPeriodicId ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- startTime+    -> Word64                               -- interval+    -> m ()                                 -- result+clockNewPeriodicId _obj startTime interval = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_clock_new_periodic_id _obj' startTime interval+    touchManagedPtr _obj+    return ()++data ClockNewPeriodicIdMethodInfo+instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockNewPeriodicIdMethodInfo a signature where+    overloadedMethod _ = clockNewPeriodicId++-- method Clock::new_single_shot_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_new_single_shot_id" gst_clock_new_single_shot_id :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- time : TBasicType TUInt64+    IO ()+++clockNewSingleShotId ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- time+    -> m ()                                 -- result+clockNewSingleShotId _obj time = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_clock_new_single_shot_id _obj' time+    touchManagedPtr _obj+    return ()++data ClockNewSingleShotIdMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockNewSingleShotIdMethodInfo a signature where+    overloadedMethod _ = clockNewSingleShotId++-- method Clock::periodic_id_reinit+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_periodic_id_reinit" gst_clock_periodic_id_reinit :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Ptr () ->                               -- id : TBasicType TVoid+    Word64 ->                               -- start_time : TBasicType TUInt64+    Word64 ->                               -- interval : TBasicType TUInt64+    IO CInt+++clockPeriodicIdReinit ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Ptr ()                               -- id+    -> Word64                               -- startTime+    -> Word64                               -- interval+    -> m Bool                               -- result+clockPeriodicIdReinit _obj id startTime interval = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_periodic_id_reinit _obj' id startTime interval+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ClockPeriodicIdReinitMethodInfo+instance (signature ~ (Ptr () -> Word64 -> Word64 -> m Bool), MonadIO m, ClockK a) => MethodInfo ClockPeriodicIdReinitMethodInfo a signature where+    overloadedMethod _ = clockPeriodicIdReinit++-- method Clock::set_calibration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate_num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate_denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_set_calibration" gst_clock_set_calibration :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- internal : TBasicType TUInt64+    Word64 ->                               -- external : TBasicType TUInt64+    Word64 ->                               -- rate_num : TBasicType TUInt64+    Word64 ->                               -- rate_denom : TBasicType TUInt64+    IO ()+++clockSetCalibration ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- internal+    -> Word64                               -- external+    -> Word64                               -- rateNum+    -> Word64                               -- rateDenom+    -> m ()                                 -- result+clockSetCalibration _obj internal external rateNum rateDenom = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_clock_set_calibration _obj' internal external rateNum rateDenom+    touchManagedPtr _obj+    return ()++data ClockSetCalibrationMethodInfo+instance (signature ~ (Word64 -> Word64 -> Word64 -> Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockSetCalibrationMethodInfo a signature where+    overloadedMethod _ = clockSetCalibration++-- method Clock::set_master+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "master", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_set_master" gst_clock_set_master :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Ptr Clock ->                            -- master : TInterface "Gst" "Clock"+    IO CInt+++clockSetMaster ::+    (MonadIO m, ClockK a, ClockK b) =>+    a                                       -- _obj+    -> Maybe (b)                            -- master+    -> m Bool                               -- result+clockSetMaster _obj master = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeMaster <- case master of+        Nothing -> return nullPtr+        Just jMaster -> do+            let jMaster' = unsafeManagedPtrCastPtr jMaster+            return jMaster'+    result <- gst_clock_set_master _obj' maybeMaster+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust master touchManagedPtr+    return result'++data ClockSetMasterMethodInfo+instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, ClockK a, ClockK b) => MethodInfo ClockSetMasterMethodInfo a signature where+    overloadedMethod _ = clockSetMaster++-- method Clock::set_resolution+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "resolution", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_set_resolution" gst_clock_set_resolution :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- resolution : TBasicType TUInt64+    IO Word64+++clockSetResolution ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- resolution+    -> m Word64                             -- result+clockSetResolution _obj resolution = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_set_resolution _obj' resolution+    touchManagedPtr _obj+    return result++data ClockSetResolutionMethodInfo+instance (signature ~ (Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockSetResolutionMethodInfo a signature where+    overloadedMethod _ = clockSetResolution++-- method Clock::set_synced+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "synced", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_set_synced" gst_clock_set_synced :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    CInt ->                                 -- synced : TBasicType TBoolean+    IO ()+++clockSetSynced ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Bool                                 -- synced+    -> m ()                                 -- result+clockSetSynced _obj synced = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let synced' = (fromIntegral . fromEnum) synced+    gst_clock_set_synced _obj' synced'+    touchManagedPtr _obj+    return ()++data ClockSetSyncedMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, ClockK a) => MethodInfo ClockSetSyncedMethodInfo a signature where+    overloadedMethod _ = clockSetSynced++-- method Clock::set_timeout+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_set_timeout" gst_clock_set_timeout :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- timeout : TBasicType TUInt64+    IO ()+++clockSetTimeout ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- timeout+    -> m ()                                 -- result+clockSetTimeout _obj timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_clock_set_timeout _obj' timeout+    touchManagedPtr _obj+    return ()++data ClockSetTimeoutMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockSetTimeoutMethodInfo a signature where+    overloadedMethod _ = clockSetTimeout++-- method Clock::single_shot_id_reinit+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_single_shot_id_reinit" gst_clock_single_shot_id_reinit :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Ptr () ->                               -- id : TBasicType TVoid+    Word64 ->                               -- time : TBasicType TUInt64+    IO CInt+++clockSingleShotIdReinit ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Ptr ()                               -- id+    -> Word64                               -- time+    -> m Bool                               -- result+clockSingleShotIdReinit _obj id time = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_single_shot_id_reinit _obj' id time+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ClockSingleShotIdReinitMethodInfo+instance (signature ~ (Ptr () -> Word64 -> m Bool), MonadIO m, ClockK a) => MethodInfo ClockSingleShotIdReinitMethodInfo a signature where+    overloadedMethod _ = clockSingleShotIdReinit++-- method Clock::unadjust_unlocked+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_unadjust_unlocked" gst_clock_unadjust_unlocked :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- external : TBasicType TUInt64+    IO Word64+++clockUnadjustUnlocked ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- external+    -> m Word64                             -- result+clockUnadjustUnlocked _obj external = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_unadjust_unlocked _obj' external+    touchManagedPtr _obj+    return result++data ClockUnadjustUnlockedMethodInfo+instance (signature ~ (Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockUnadjustUnlockedMethodInfo a signature where+    overloadedMethod _ = clockUnadjustUnlocked++-- method Clock::wait_for_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_wait_for_sync" gst_clock_wait_for_sync :: +    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"+    Word64 ->                               -- timeout : TBasicType TUInt64+    IO CInt+++clockWaitForSync ::+    (MonadIO m, ClockK a) =>+    a                                       -- _obj+    -> Word64                               -- timeout+    -> m Bool                               -- result+clockWaitForSync _obj timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_clock_wait_for_sync _obj' timeout+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ClockWaitForSyncMethodInfo+instance (signature ~ (Word64 -> m Bool), MonadIO m, ClockK a) => MethodInfo ClockWaitForSyncMethodInfo a signature where+    overloadedMethod _ = clockWaitForSync++-- method Clock::id_compare_func+-- method type : MemberFunction+-- Args : [Arg {argCName = "id1", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id2", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_id_compare_func" gst_clock_id_compare_func :: +    Ptr () ->                               -- id1 : TBasicType TVoid+    Ptr () ->                               -- id2 : TBasicType TVoid+    IO Int32+++clockIdCompareFunc ::+    (MonadIO m) =>+    Ptr ()                                  -- id1+    -> Ptr ()                               -- id2+    -> m Int32                              -- result+clockIdCompareFunc id1 id2 = liftIO $ do+    result <- gst_clock_id_compare_func id1 id2+    return result++-- method Clock::id_get_time+-- method type : MemberFunction+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_id_get_time" gst_clock_id_get_time :: +    Ptr () ->                               -- id : TBasicType TVoid+    IO Word64+++clockIdGetTime ::+    (MonadIO m) =>+    Ptr ()                                  -- id+    -> m Word64                             -- result+clockIdGetTime id = liftIO $ do+    result <- gst_clock_id_get_time id+    return result++-- method Clock::id_ref+-- method type : MemberFunction+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_id_ref" gst_clock_id_ref :: +    Ptr () ->                               -- id : TBasicType TVoid+    IO ()+++clockIdRef ::+    (MonadIO m) =>+    Ptr ()                                  -- id+    -> m ()                                 -- result+clockIdRef id = liftIO $ do+    gst_clock_id_ref id+    return ()++-- method Clock::id_unref+-- method type : MemberFunction+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_id_unref" gst_clock_id_unref :: +    Ptr () ->                               -- id : TBasicType TVoid+    IO ()+++clockIdUnref ::+    (MonadIO m) =>+    Ptr ()                                  -- id+    -> m ()                                 -- result+clockIdUnref id = liftIO $ do+    gst_clock_id_unref id+    return ()++-- method Clock::id_unschedule+-- method type : MemberFunction+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_id_unschedule" gst_clock_id_unschedule :: +    Ptr () ->                               -- id : TBasicType TVoid+    IO ()+++clockIdUnschedule ::+    (MonadIO m) =>+    Ptr ()                                  -- id+    -> m ()                                 -- result+clockIdUnschedule id = liftIO $ do+    gst_clock_id_unschedule id+    return ()++-- method Clock::id_wait+-- method type : MemberFunction+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "ClockReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_id_wait" gst_clock_id_wait :: +    Ptr () ->                               -- id : TBasicType TVoid+    Ptr Int64 ->                            -- jitter : TBasicType TInt64+    IO CUInt+++clockIdWait ::+    (MonadIO m) =>+    Ptr ()                                  -- id+    -> m (ClockReturn,Int64)                -- result+clockIdWait id = liftIO $ do+    jitter <- allocMem :: IO (Ptr Int64)+    result <- gst_clock_id_wait id jitter+    let result' = (toEnum . fromIntegral) result+    jitter' <- peek jitter+    freeMem jitter+    return (result', jitter')++-- method Clock::id_wait_async+-- method type : MemberFunction+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "ClockCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_data", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "ClockReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_clock_id_wait_async" gst_clock_id_wait_async :: +    Ptr () ->                               -- id : TBasicType TVoid+    FunPtr ClockCallbackC ->                -- func : TInterface "Gst" "ClockCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy_data : TInterface "GLib" "DestroyNotify"+    IO CUInt+++clockIdWaitAsync ::+    (MonadIO m) =>+    Ptr ()                                  -- id+    -> ClockCallback                        -- func+    -> m ClockReturn                        -- result+clockIdWaitAsync id func = liftIO $ do+    func' <- mkClockCallback (clockCallbackWrapper Nothing func)+    let userData = castFunPtrToPtr func'+    let destroyData = safeFreeFunPtrPtr+    result <- gst_clock_id_wait_async id func' userData destroyData+    let result' = (toEnum . fromIntegral) result+    return result'++
+ GI/Gst/Objects/Clock.hs-boot view
@@ -0,0 +1,39 @@+module GI.Gst.Objects.Clock 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++newtype Clock = Clock (ForeignPtr Clock)+instance GObject Clock where+class GObject o => ClockK o+instance (GObject o, IsDescendantOf Clock o) => ClockK o+data ClockTimeoutPropertyInfo+data ClockWindowSizePropertyInfo+data ClockWindowThresholdPropertyInfo+data ClockSyncedSignalInfo+data ClockAddObservationMethodInfo+data ClockAddObservationUnappliedMethodInfo+data ClockAdjustUnlockedMethodInfo+data ClockAdjustWithCalibrationMethodInfo+data ClockGetCalibrationMethodInfo+data ClockGetInternalTimeMethodInfo+data ClockGetMasterMethodInfo+data ClockGetResolutionMethodInfo+data ClockGetTimeMethodInfo+data ClockGetTimeoutMethodInfo+data ClockIsSyncedMethodInfo+data ClockNewPeriodicIdMethodInfo+data ClockNewSingleShotIdMethodInfo+data ClockPeriodicIdReinitMethodInfo+data ClockSetCalibrationMethodInfo+data ClockSetMasterMethodInfo+data ClockSetResolutionMethodInfo+data ClockSetSyncedMethodInfo+data ClockSetTimeoutMethodInfo+data ClockSingleShotIdReinitMethodInfo+data ClockUnadjustUnlockedMethodInfo+data ClockWaitForSyncMethodInfo
+ GI/Gst/Objects/ControlBinding.hs view
@@ -0,0 +1,365 @@+++{- |+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.Objects.ControlBinding+    ( ++-- * Exported types+    ControlBinding(..)                      ,+    ControlBindingK                         ,+    toControlBinding                        ,+    noControlBinding                        ,+++ -- * Methods+-- ** controlBindingGetGValueArray+    ControlBindingGetGValueArrayMethodInfo  ,+    controlBindingGetGValueArray            ,+++-- ** controlBindingGetValue+    ControlBindingGetValueMethodInfo        ,+    controlBindingGetValue                  ,+++-- ** controlBindingIsDisabled+    ControlBindingIsDisabledMethodInfo      ,+    controlBindingIsDisabled                ,+++-- ** controlBindingSetDisabled+    ControlBindingSetDisabledMethodInfo     ,+    controlBindingSetDisabled               ,+++-- ** controlBindingSyncValues+    ControlBindingSyncValuesMethodInfo      ,+    controlBindingSyncValues                ,+++++ -- * Properties+-- ** Name+    ControlBindingNamePropertyInfo          ,+    constructControlBindingName             ,+    getControlBindingName                   ,+++-- ** Object+    ControlBindingObjectPropertyInfo        ,+    constructControlBindingObject           ,+    getControlBindingObject                 ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype ControlBinding = ControlBinding (ForeignPtr ControlBinding)+foreign import ccall "gst_control_binding_get_type"+    c_gst_control_binding_get_type :: IO GType++type instance ParentTypes ControlBinding = ControlBindingParentTypes+type ControlBindingParentTypes = '[Object, GObject.Object]++instance GObject ControlBinding where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_control_binding_get_type+    ++class GObject o => ControlBindingK o+instance (GObject o, IsDescendantOf ControlBinding o) => ControlBindingK o++toControlBinding :: ControlBindingK o => o -> IO ControlBinding+toControlBinding = unsafeCastTo ControlBinding++noControlBinding :: Maybe ControlBinding+noControlBinding = Nothing++type family ResolveControlBindingMethod (t :: Symbol) (o :: *) :: * where+    ResolveControlBindingMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveControlBindingMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveControlBindingMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveControlBindingMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveControlBindingMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveControlBindingMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveControlBindingMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveControlBindingMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveControlBindingMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveControlBindingMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveControlBindingMethod "isDisabled" o = ControlBindingIsDisabledMethodInfo+    ResolveControlBindingMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveControlBindingMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveControlBindingMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveControlBindingMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveControlBindingMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveControlBindingMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveControlBindingMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveControlBindingMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveControlBindingMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveControlBindingMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveControlBindingMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveControlBindingMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveControlBindingMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveControlBindingMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveControlBindingMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveControlBindingMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveControlBindingMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveControlBindingMethod "getName" o = ObjectGetNameMethodInfo+    ResolveControlBindingMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveControlBindingMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveControlBindingMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveControlBindingMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveControlBindingMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveControlBindingMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveControlBindingMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveControlBindingMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveControlBindingMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveControlBindingMethod "setDisabled" o = ControlBindingSetDisabledMethodInfo+    ResolveControlBindingMethod "setName" o = ObjectSetNameMethodInfo+    ResolveControlBindingMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveControlBindingMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveControlBindingMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveControlBindingMethod t ControlBinding, MethodInfo info ControlBinding p) => IsLabelProxy t (ControlBinding -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveControlBindingMethod t ControlBinding, MethodInfo info ControlBinding p) => IsLabel t (ControlBinding -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++--- XXX Duplicated object with different types:+  --- Name {namespace = "Gst", name = "ControlBinding"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}+  --- Name {namespace = "Gst", name = "Object"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propTransfer = TransferNothing, propDeprecated = Nothing}+-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getControlBindingName :: (MonadIO m, ControlBindingK o) => o -> m T.Text+getControlBindingName obj = liftIO $ getObjectPropertyString obj "name"++constructControlBindingName :: T.Text -> IO ([Char], GValue)+constructControlBindingName val = constructObjectPropertyString "name" val++data ControlBindingNamePropertyInfo+instance AttrInfo ControlBindingNamePropertyInfo where+    type AttrAllowedOps ControlBindingNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ControlBindingNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ControlBindingNamePropertyInfo = ControlBindingK+    type AttrGetType ControlBindingNamePropertyInfo = T.Text+    type AttrLabel ControlBindingNamePropertyInfo = "name"+    attrGet _ = getControlBindingName+    attrSet _ = undefined+    attrConstruct _ = constructControlBindingName++-- VVV Prop "object"+   -- Type: TInterface "Gst" "Object"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getControlBindingObject :: (MonadIO m, ControlBindingK o) => o -> m Object+getControlBindingObject obj = liftIO $ getObjectPropertyObject obj "object" Object++constructControlBindingObject :: (ObjectK a) => a -> IO ([Char], GValue)+constructControlBindingObject val = constructObjectPropertyObject "object" val++data ControlBindingObjectPropertyInfo+instance AttrInfo ControlBindingObjectPropertyInfo where+    type AttrAllowedOps ControlBindingObjectPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ControlBindingObjectPropertyInfo = ObjectK+    type AttrBaseTypeConstraint ControlBindingObjectPropertyInfo = ControlBindingK+    type AttrGetType ControlBindingObjectPropertyInfo = Object+    type AttrLabel ControlBindingObjectPropertyInfo = "object"+    attrGet _ = getControlBindingObject+    attrSet _ = undefined+    attrConstruct _ = constructControlBindingObject++type instance AttributeList ControlBinding = ControlBindingAttributeList+type ControlBindingAttributeList = ('[ '("object", ControlBindingObjectPropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ControlBinding = ControlBindingSignalList+type ControlBindingSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ControlBinding::get_g_value_array+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TCArray False (-1) 3 (TInterface "GObject" "Value"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_control_binding_get_g_value_array" gst_control_binding_get_g_value_array :: +    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"+    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- interval : TBasicType TUInt64+    Word32 ->                               -- n_values : TBasicType TUInt32+    Ptr GValue ->                           -- values : TCArray False (-1) 3 (TInterface "GObject" "Value")+    IO CInt+++controlBindingGetGValueArray ::+    (MonadIO m, ControlBindingK a) =>+    a                                       -- _obj+    -> Word64                               -- timestamp+    -> Word64                               -- interval+    -> [GValue]                             -- values+    -> m Bool                               -- result+controlBindingGetGValueArray _obj timestamp interval values = liftIO $ do+    let nValues = fromIntegral $ length values+    let _obj' = unsafeManagedPtrCastPtr _obj+    let values' = map unsafeManagedPtrGetPtr values+    values'' <- packBlockArray 24 values'+    result <- gst_control_binding_get_g_value_array _obj' timestamp interval nValues values''+    let result' = (/= 0) result+    touchManagedPtr _obj+    mapM_ touchManagedPtr values+    freeMem values''+    return result'++data ControlBindingGetGValueArrayMethodInfo+instance (signature ~ (Word64 -> Word64 -> [GValue] -> m Bool), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingGetGValueArrayMethodInfo a signature where+    overloadedMethod _ = controlBindingGetGValueArray++-- method ControlBinding::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_control_binding_get_value" gst_control_binding_get_value :: +    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"+    Word64 ->                               -- timestamp : TBasicType TUInt64+    IO (Ptr GValue)+++controlBindingGetValue ::+    (MonadIO m, ControlBindingK a) =>+    a                                       -- _obj+    -> Word64                               -- timestamp+    -> m GValue                             -- result+controlBindingGetValue _obj timestamp = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_control_binding_get_value _obj' timestamp+    checkUnexpectedReturnNULL "gst_control_binding_get_value" result+    result' <- (wrapBoxed GValue) result+    touchManagedPtr _obj+    return result'++data ControlBindingGetValueMethodInfo+instance (signature ~ (Word64 -> m GValue), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingGetValueMethodInfo a signature where+    overloadedMethod _ = controlBindingGetValue++-- method ControlBinding::is_disabled+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_control_binding_is_disabled" gst_control_binding_is_disabled :: +    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"+    IO CInt+++controlBindingIsDisabled ::+    (MonadIO m, ControlBindingK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+controlBindingIsDisabled _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_control_binding_is_disabled _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ControlBindingIsDisabledMethodInfo+instance (signature ~ (m Bool), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingIsDisabledMethodInfo a signature where+    overloadedMethod _ = controlBindingIsDisabled++-- method ControlBinding::set_disabled+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_control_binding_set_disabled" gst_control_binding_set_disabled :: +    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"+    CInt ->                                 -- disabled : TBasicType TBoolean+    IO ()+++controlBindingSetDisabled ::+    (MonadIO m, ControlBindingK a) =>+    a                                       -- _obj+    -> Bool                                 -- disabled+    -> m ()                                 -- result+controlBindingSetDisabled _obj disabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let disabled' = (fromIntegral . fromEnum) disabled+    gst_control_binding_set_disabled _obj' disabled'+    touchManagedPtr _obj+    return ()++data ControlBindingSetDisabledMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingSetDisabledMethodInfo a signature where+    overloadedMethod _ = controlBindingSetDisabled++-- method ControlBinding::sync_values+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "last_sync", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_control_binding_sync_values" gst_control_binding_sync_values :: +    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"+    Ptr Object ->                           -- object : TInterface "Gst" "Object"+    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- last_sync : TBasicType TUInt64+    IO CInt+++controlBindingSyncValues ::+    (MonadIO m, ControlBindingK a, ObjectK b) =>+    a                                       -- _obj+    -> b                                    -- object+    -> Word64                               -- timestamp+    -> Word64                               -- lastSync+    -> m Bool                               -- result+controlBindingSyncValues _obj object timestamp lastSync = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let object' = unsafeManagedPtrCastPtr object+    result <- gst_control_binding_sync_values _obj' object' timestamp lastSync+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr object+    return result'++data ControlBindingSyncValuesMethodInfo+instance (signature ~ (b -> Word64 -> Word64 -> m Bool), MonadIO m, ControlBindingK a, ObjectK b) => MethodInfo ControlBindingSyncValuesMethodInfo a signature where+    overloadedMethod _ = controlBindingSyncValues++
+ GI/Gst/Objects/ControlBinding.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gst.Objects.ControlBinding 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++newtype ControlBinding = ControlBinding (ForeignPtr ControlBinding)+instance GObject ControlBinding where+class GObject o => ControlBindingK o+instance (GObject o, IsDescendantOf ControlBinding o) => ControlBindingK o+data ControlBindingNamePropertyInfo+data ControlBindingObjectPropertyInfo+data ControlBindingGetGValueArrayMethodInfo+data ControlBindingGetValueMethodInfo+data ControlBindingIsDisabledMethodInfo+data ControlBindingSetDisabledMethodInfo+data ControlBindingSyncValuesMethodInfo
+ GI/Gst/Objects/ControlSource.hs view
@@ -0,0 +1,199 @@+++{- |+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.Objects.ControlSource+    ( ++-- * Exported types+    ControlSource(..)                       ,+    ControlSourceK                          ,+    toControlSource                         ,+    noControlSource                         ,+++ -- * Methods+-- ** controlSourceControlSourceGetValue+    ControlSourceControlSourceGetValueMethodInfo,+    controlSourceControlSourceGetValue      ,+++-- ** controlSourceControlSourceGetValueArray+    ControlSourceControlSourceGetValueArrayMethodInfo,+    controlSourceControlSourceGetValueArray ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype ControlSource = ControlSource (ForeignPtr ControlSource)+foreign import ccall "gst_control_source_get_type"+    c_gst_control_source_get_type :: IO GType++type instance ParentTypes ControlSource = ControlSourceParentTypes+type ControlSourceParentTypes = '[Object, GObject.Object]++instance GObject ControlSource where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_control_source_get_type+    ++class GObject o => ControlSourceK o+instance (GObject o, IsDescendantOf ControlSource o) => ControlSourceK o++toControlSource :: ControlSourceK o => o -> IO ControlSource+toControlSource = unsafeCastTo ControlSource++noControlSource :: Maybe ControlSource+noControlSource = Nothing++type family ResolveControlSourceMethod (t :: Symbol) (o :: *) :: * where+    ResolveControlSourceMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveControlSourceMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveControlSourceMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveControlSourceMethod "controlSourceGetValue" o = ControlSourceControlSourceGetValueMethodInfo+    ResolveControlSourceMethod "controlSourceGetValueArray" o = ControlSourceControlSourceGetValueArrayMethodInfo+    ResolveControlSourceMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveControlSourceMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveControlSourceMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveControlSourceMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveControlSourceMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveControlSourceMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveControlSourceMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveControlSourceMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveControlSourceMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveControlSourceMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveControlSourceMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveControlSourceMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveControlSourceMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveControlSourceMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveControlSourceMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveControlSourceMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveControlSourceMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveControlSourceMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveControlSourceMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveControlSourceMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveControlSourceMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveControlSourceMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveControlSourceMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveControlSourceMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveControlSourceMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveControlSourceMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveControlSourceMethod "getName" o = ObjectGetNameMethodInfo+    ResolveControlSourceMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveControlSourceMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveControlSourceMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveControlSourceMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveControlSourceMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveControlSourceMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveControlSourceMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveControlSourceMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveControlSourceMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveControlSourceMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveControlSourceMethod "setName" o = ObjectSetNameMethodInfo+    ResolveControlSourceMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveControlSourceMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveControlSourceMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveControlSourceMethod t ControlSource, MethodInfo info ControlSource p) => IsLabelProxy t (ControlSource -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveControlSourceMethod t ControlSource, MethodInfo info ControlSource p) => IsLabel t (ControlSource -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList ControlSource = ControlSourceAttributeList+type ControlSourceAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ControlSource = ControlSourceSignalList+type ControlSourceSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ControlSource::control_source_get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_control_source_get_value" gst_control_source_get_value :: +    Ptr ControlSource ->                    -- _obj : TInterface "Gst" "ControlSource"+    Word64 ->                               -- timestamp : TBasicType TUInt64+    CDouble ->                              -- value : TBasicType TDouble+    IO CInt+++controlSourceControlSourceGetValue ::+    (MonadIO m, ControlSourceK a) =>+    a                                       -- _obj+    -> Word64                               -- timestamp+    -> Double                               -- value+    -> m Bool                               -- result+controlSourceControlSourceGetValue _obj timestamp value = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let value' = realToFrac value+    result <- gst_control_source_get_value _obj' timestamp value'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ControlSourceControlSourceGetValueMethodInfo+instance (signature ~ (Word64 -> Double -> m Bool), MonadIO m, ControlSourceK a) => MethodInfo ControlSourceControlSourceGetValueMethodInfo a signature where+    overloadedMethod _ = controlSourceControlSourceGetValue++-- method ControlSource::control_source_get_value_array+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TCArray False (-1) 3 (TBasicType TDouble), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_control_source_get_value_array" gst_control_source_get_value_array :: +    Ptr ControlSource ->                    -- _obj : TInterface "Gst" "ControlSource"+    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- interval : TBasicType TUInt64+    Word32 ->                               -- n_values : TBasicType TUInt32+    Ptr CDouble ->                          -- values : TCArray False (-1) 3 (TBasicType TDouble)+    IO CInt+++controlSourceControlSourceGetValueArray ::+    (MonadIO m, ControlSourceK a) =>+    a                                       -- _obj+    -> Word64                               -- timestamp+    -> Word64                               -- interval+    -> [Double]                             -- values+    -> m Bool                               -- result+controlSourceControlSourceGetValueArray _obj timestamp interval values = liftIO $ do+    let nValues = fromIntegral $ length values+    let _obj' = unsafeManagedPtrCastPtr _obj+    values' <- (packMapStorableArray realToFrac) values+    result <- gst_control_source_get_value_array _obj' timestamp interval nValues values'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem values'+    return result'++data ControlSourceControlSourceGetValueArrayMethodInfo+instance (signature ~ (Word64 -> Word64 -> [Double] -> m Bool), MonadIO m, ControlSourceK a) => MethodInfo ControlSourceControlSourceGetValueArrayMethodInfo a signature where+    overloadedMethod _ = controlSourceControlSourceGetValueArray++
+ GI/Gst/Objects/ControlSource.hs-boot view
@@ -0,0 +1,15 @@+module GI.Gst.Objects.ControlSource 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++newtype ControlSource = ControlSource (ForeignPtr ControlSource)+instance GObject ControlSource where+class GObject o => ControlSourceK o+instance (GObject o, IsDescendantOf ControlSource o) => ControlSourceK o+data ControlSourceControlSourceGetValueMethodInfo+data ControlSourceControlSourceGetValueArrayMethodInfo
+ GI/Gst/Objects/Device.hs view
@@ -0,0 +1,585 @@+++{- |+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.Objects.Device+    ( ++-- * Exported types+    Device(..)                              ,+    DeviceK                                 ,+    toDevice                                ,+    noDevice                                ,+++ -- * Methods+-- ** deviceCreateElement+    DeviceCreateElementMethodInfo           ,+    deviceCreateElement                     ,+++-- ** deviceGetCaps+    DeviceGetCapsMethodInfo                 ,+    deviceGetCaps                           ,+++-- ** deviceGetDeviceClass+    DeviceGetDeviceClassMethodInfo          ,+    deviceGetDeviceClass                    ,+++-- ** deviceGetDisplayName+    DeviceGetDisplayNameMethodInfo          ,+    deviceGetDisplayName                    ,+++-- ** deviceGetProperties+    DeviceGetPropertiesMethodInfo           ,+    deviceGetProperties                     ,+++-- ** deviceHasClasses+    DeviceHasClassesMethodInfo              ,+    deviceHasClasses                        ,+++-- ** deviceHasClassesv+    DeviceHasClassesvMethodInfo             ,+    deviceHasClassesv                       ,+++-- ** deviceReconfigureElement+    DeviceReconfigureElementMethodInfo      ,+    deviceReconfigureElement                ,+++++ -- * Properties+-- ** Caps+    DeviceCapsPropertyInfo                  ,+    constructDeviceCaps                     ,+    getDeviceCaps                           ,+++-- ** DeviceClass+    DeviceDeviceClassPropertyInfo           ,+    constructDeviceDeviceClass              ,+    getDeviceDeviceClass                    ,+++-- ** DisplayName+    DeviceDisplayNamePropertyInfo           ,+    constructDeviceDisplayName              ,+    getDeviceDisplayName                    ,+++-- ** Properties+    DevicePropertiesPropertyInfo            ,+    constructDeviceProperties               ,+    getDeviceProperties                     ,+++++ -- * Signals+-- ** Removed+    DeviceRemovedCallback                   ,+    DeviceRemovedCallbackC                  ,+    DeviceRemovedSignalInfo                 ,+    afterDeviceRemoved                      ,+    deviceRemovedCallbackWrapper            ,+    deviceRemovedClosure                    ,+    mkDeviceRemovedCallback                 ,+    noDeviceRemovedCallback                 ,+    onDeviceRemoved                         ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Device = Device (ForeignPtr Device)+foreign import ccall "gst_device_get_type"+    c_gst_device_get_type :: IO GType++type instance ParentTypes Device = DeviceParentTypes+type DeviceParentTypes = '[Object, GObject.Object]++instance GObject Device where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_device_get_type+    ++class GObject o => DeviceK o+instance (GObject o, IsDescendantOf Device o) => DeviceK o++toDevice :: DeviceK o => o -> IO Device+toDevice = unsafeCastTo Device++noDevice :: Maybe Device+noDevice = Nothing++type family ResolveDeviceMethod (t :: Symbol) (o :: *) :: * where+    ResolveDeviceMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveDeviceMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveDeviceMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveDeviceMethod "createElement" o = DeviceCreateElementMethodInfo+    ResolveDeviceMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveDeviceMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveDeviceMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveDeviceMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveDeviceMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveDeviceMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveDeviceMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveDeviceMethod "hasClasses" o = DeviceHasClassesMethodInfo+    ResolveDeviceMethod "hasClassesv" o = DeviceHasClassesvMethodInfo+    ResolveDeviceMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveDeviceMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveDeviceMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveDeviceMethod "reconfigureElement" o = DeviceReconfigureElementMethodInfo+    ResolveDeviceMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveDeviceMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveDeviceMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveDeviceMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveDeviceMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveDeviceMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveDeviceMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveDeviceMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveDeviceMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveDeviceMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveDeviceMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveDeviceMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveDeviceMethod "getCaps" o = DeviceGetCapsMethodInfo+    ResolveDeviceMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveDeviceMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveDeviceMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveDeviceMethod "getDeviceClass" o = DeviceGetDeviceClassMethodInfo+    ResolveDeviceMethod "getDisplayName" o = DeviceGetDisplayNameMethodInfo+    ResolveDeviceMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveDeviceMethod "getName" o = ObjectGetNameMethodInfo+    ResolveDeviceMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveDeviceMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveDeviceMethod "getProperties" o = DeviceGetPropertiesMethodInfo+    ResolveDeviceMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveDeviceMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveDeviceMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveDeviceMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveDeviceMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveDeviceMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveDeviceMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveDeviceMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveDeviceMethod "setName" o = ObjectSetNameMethodInfo+    ResolveDeviceMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveDeviceMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveDeviceMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveDeviceMethod t Device, MethodInfo info Device p) => IsLabelProxy t (Device -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveDeviceMethod t Device, MethodInfo info Device p) => IsLabel t (Device -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Device::removed+type DeviceRemovedCallback =+    IO ()++noDeviceRemovedCallback :: Maybe DeviceRemovedCallback+noDeviceRemovedCallback = Nothing++type DeviceRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDeviceRemovedCallback :: DeviceRemovedCallbackC -> IO (FunPtr DeviceRemovedCallbackC)++deviceRemovedClosure :: DeviceRemovedCallback -> IO Closure+deviceRemovedClosure cb = newCClosure =<< mkDeviceRemovedCallback wrapped+    where wrapped = deviceRemovedCallbackWrapper cb++deviceRemovedCallbackWrapper ::+    DeviceRemovedCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+deviceRemovedCallbackWrapper _cb _ _ = do+    _cb ++onDeviceRemoved :: (GObject a, MonadIO m) => a -> DeviceRemovedCallback -> m SignalHandlerId+onDeviceRemoved obj cb = liftIO $ connectDeviceRemoved obj cb SignalConnectBefore+afterDeviceRemoved :: (GObject a, MonadIO m) => a -> DeviceRemovedCallback -> m SignalHandlerId+afterDeviceRemoved obj cb = connectDeviceRemoved obj cb SignalConnectAfter++connectDeviceRemoved :: (GObject a, MonadIO m) =>+                        a -> DeviceRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectDeviceRemoved obj cb after = liftIO $ do+    cb' <- mkDeviceRemovedCallback (deviceRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "removed" cb' after++-- VVV Prop "caps"+   -- Type: TInterface "Gst" "Caps"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDeviceCaps :: (MonadIO m, DeviceK o) => o -> m Caps+getDeviceCaps obj = liftIO $ getObjectPropertyBoxed obj "caps" Caps++constructDeviceCaps :: Caps -> IO ([Char], GValue)+constructDeviceCaps val = constructObjectPropertyBoxed "caps" val++data DeviceCapsPropertyInfo+instance AttrInfo DeviceCapsPropertyInfo where+    type AttrAllowedOps DeviceCapsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DeviceCapsPropertyInfo = (~) Caps+    type AttrBaseTypeConstraint DeviceCapsPropertyInfo = DeviceK+    type AttrGetType DeviceCapsPropertyInfo = Caps+    type AttrLabel DeviceCapsPropertyInfo = "caps"+    attrGet _ = getDeviceCaps+    attrSet _ = undefined+    attrConstruct _ = constructDeviceCaps++-- VVV Prop "device-class"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDeviceDeviceClass :: (MonadIO m, DeviceK o) => o -> m T.Text+getDeviceDeviceClass obj = liftIO $ getObjectPropertyString obj "device-class"++constructDeviceDeviceClass :: T.Text -> IO ([Char], GValue)+constructDeviceDeviceClass val = constructObjectPropertyString "device-class" val++data DeviceDeviceClassPropertyInfo+instance AttrInfo DeviceDeviceClassPropertyInfo where+    type AttrAllowedOps DeviceDeviceClassPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DeviceDeviceClassPropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DeviceDeviceClassPropertyInfo = DeviceK+    type AttrGetType DeviceDeviceClassPropertyInfo = T.Text+    type AttrLabel DeviceDeviceClassPropertyInfo = "device-class"+    attrGet _ = getDeviceDeviceClass+    attrSet _ = undefined+    attrConstruct _ = constructDeviceDeviceClass++-- VVV Prop "display-name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDeviceDisplayName :: (MonadIO m, DeviceK o) => o -> m T.Text+getDeviceDisplayName obj = liftIO $ getObjectPropertyString obj "display-name"++constructDeviceDisplayName :: T.Text -> IO ([Char], GValue)+constructDeviceDisplayName val = constructObjectPropertyString "display-name" val++data DeviceDisplayNamePropertyInfo+instance AttrInfo DeviceDisplayNamePropertyInfo where+    type AttrAllowedOps DeviceDisplayNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DeviceDisplayNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint DeviceDisplayNamePropertyInfo = DeviceK+    type AttrGetType DeviceDisplayNamePropertyInfo = T.Text+    type AttrLabel DeviceDisplayNamePropertyInfo = "display-name"+    attrGet _ = getDeviceDisplayName+    attrSet _ = undefined+    attrConstruct _ = constructDeviceDisplayName++-- VVV Prop "properties"+   -- Type: TInterface "Gst" "Structure"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getDeviceProperties :: (MonadIO m, DeviceK o) => o -> m Structure+getDeviceProperties obj = liftIO $ getObjectPropertyBoxed obj "properties" Structure++constructDeviceProperties :: Structure -> IO ([Char], GValue)+constructDeviceProperties val = constructObjectPropertyBoxed "properties" val++data DevicePropertiesPropertyInfo+instance AttrInfo DevicePropertiesPropertyInfo where+    type AttrAllowedOps DevicePropertiesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DevicePropertiesPropertyInfo = (~) Structure+    type AttrBaseTypeConstraint DevicePropertiesPropertyInfo = DeviceK+    type AttrGetType DevicePropertiesPropertyInfo = Structure+    type AttrLabel DevicePropertiesPropertyInfo = "properties"+    attrGet _ = getDeviceProperties+    attrSet _ = undefined+    attrConstruct _ = constructDeviceProperties++type instance AttributeList Device = DeviceAttributeList+type DeviceAttributeList = ('[ '("caps", DeviceCapsPropertyInfo), '("deviceClass", DeviceDeviceClassPropertyInfo), '("displayName", DeviceDisplayNamePropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("properties", DevicePropertiesPropertyInfo)] :: [(Symbol, *)])++data DeviceRemovedSignalInfo+instance SignalInfo DeviceRemovedSignalInfo where+    type HaskellCallbackType DeviceRemovedSignalInfo = DeviceRemovedCallback+    connectSignal _ = connectDeviceRemoved++type instance SignalList Device = DeviceSignalList+type DeviceSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("removed", DeviceRemovedSignalInfo)] :: [(Symbol, *)])++-- method Device::create_element+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_create_element" gst_device_create_element :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Element)+++deviceCreateElement ::+    (MonadIO m, DeviceK a) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- name+    -> m Element                            -- result+deviceCreateElement _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_device_create_element _obj' maybeName+    checkUnexpectedReturnNULL "gst_device_create_element" result+    result' <- (wrapObject Element) result+    touchManagedPtr _obj+    freeMem maybeName+    return result'++data DeviceCreateElementMethodInfo+instance (signature ~ (Maybe (T.Text) -> m Element), MonadIO m, DeviceK a) => MethodInfo DeviceCreateElementMethodInfo a signature where+    overloadedMethod _ = deviceCreateElement++-- method Device::get_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_get_caps" gst_device_get_caps :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    IO (Ptr Caps)+++deviceGetCaps ::+    (MonadIO m, DeviceK a) =>+    a                                       -- _obj+    -> m Caps                               -- result+deviceGetCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_get_caps _obj'+    checkUnexpectedReturnNULL "gst_device_get_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data DeviceGetCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m, DeviceK a) => MethodInfo DeviceGetCapsMethodInfo a signature where+    overloadedMethod _ = deviceGetCaps++-- method Device::get_device_class+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_get_device_class" gst_device_get_device_class :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    IO CString+++deviceGetDeviceClass ::+    (MonadIO m, DeviceK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+deviceGetDeviceClass _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_get_device_class _obj'+    checkUnexpectedReturnNULL "gst_device_get_device_class" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data DeviceGetDeviceClassMethodInfo+instance (signature ~ (m T.Text), MonadIO m, DeviceK a) => MethodInfo DeviceGetDeviceClassMethodInfo a signature where+    overloadedMethod _ = deviceGetDeviceClass++-- method Device::get_display_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_get_display_name" gst_device_get_display_name :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    IO CString+++deviceGetDisplayName ::+    (MonadIO m, DeviceK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+deviceGetDisplayName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_get_display_name _obj'+    checkUnexpectedReturnNULL "gst_device_get_display_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data DeviceGetDisplayNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, DeviceK a) => MethodInfo DeviceGetDisplayNameMethodInfo a signature where+    overloadedMethod _ = deviceGetDisplayName++-- method Device::get_properties+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_get_properties" gst_device_get_properties :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    IO (Ptr Structure)+++deviceGetProperties ::+    (MonadIO m, DeviceK a) =>+    a                                       -- _obj+    -> m Structure                          -- result+deviceGetProperties _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_get_properties _obj'+    checkUnexpectedReturnNULL "gst_device_get_properties" result+    result' <- (wrapBoxed Structure) result+    touchManagedPtr _obj+    return result'++data DeviceGetPropertiesMethodInfo+instance (signature ~ (m Structure), MonadIO m, DeviceK a) => MethodInfo DeviceGetPropertiesMethodInfo a signature where+    overloadedMethod _ = deviceGetProperties++-- method Device::has_classes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_has_classes" gst_device_has_classes :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    CString ->                              -- classes : TBasicType TUTF8+    IO CInt+++deviceHasClasses ::+    (MonadIO m, DeviceK a) =>+    a                                       -- _obj+    -> T.Text                               -- classes+    -> m Bool                               -- result+deviceHasClasses _obj classes = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    classes' <- textToCString classes+    result <- gst_device_has_classes _obj' classes'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem classes'+    return result'++data DeviceHasClassesMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, DeviceK a) => MethodInfo DeviceHasClassesMethodInfo a signature where+    overloadedMethod _ = deviceHasClasses++-- method Device::has_classesv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_has_classesv" gst_device_has_classesv :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    Ptr CString ->                          -- classes : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO CInt+++deviceHasClassesv ::+    (MonadIO m, DeviceK a) =>+    a                                       -- _obj+    -> [T.Text]                             -- classes+    -> m Bool                               -- result+deviceHasClassesv _obj classes = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    classes' <- packZeroTerminatedUTF8CArray classes+    result <- gst_device_has_classesv _obj' classes'+    let result' = (/= 0) result+    touchManagedPtr _obj+    mapZeroTerminatedCArray freeMem classes'+    freeMem classes'+    return result'++data DeviceHasClassesvMethodInfo+instance (signature ~ ([T.Text] -> m Bool), MonadIO m, DeviceK a) => MethodInfo DeviceHasClassesvMethodInfo a signature where+    overloadedMethod _ = deviceHasClassesv++-- method Device::reconfigure_element+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_reconfigure_element" gst_device_reconfigure_element :: +    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"+    Ptr Element ->                          -- element : TInterface "Gst" "Element"+    IO CInt+++deviceReconfigureElement ::+    (MonadIO m, DeviceK a, ElementK b) =>+    a                                       -- _obj+    -> b                                    -- element+    -> m Bool                               -- result+deviceReconfigureElement _obj element = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let element' = unsafeManagedPtrCastPtr element+    result <- gst_device_reconfigure_element _obj' element'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr element+    return result'++data DeviceReconfigureElementMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, DeviceK a, ElementK b) => MethodInfo DeviceReconfigureElementMethodInfo a signature where+    overloadedMethod _ = deviceReconfigureElement++
+ GI/Gst/Objects/Device.hs-boot view
@@ -0,0 +1,26 @@+module GI.Gst.Objects.Device 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++newtype Device = Device (ForeignPtr Device)+instance GObject Device where+class GObject o => DeviceK o+instance (GObject o, IsDescendantOf Device o) => DeviceK o+data DeviceCapsPropertyInfo+data DeviceDeviceClassPropertyInfo+data DeviceDisplayNamePropertyInfo+data DevicePropertiesPropertyInfo+data DeviceRemovedSignalInfo+data DeviceCreateElementMethodInfo+data DeviceGetCapsMethodInfo+data DeviceGetDeviceClassMethodInfo+data DeviceGetDisplayNameMethodInfo+data DeviceGetPropertiesMethodInfo+data DeviceHasClassesMethodInfo+data DeviceHasClassesvMethodInfo+data DeviceReconfigureElementMethodInfo
+ GI/Gst/Objects/DeviceMonitor.hs view
@@ -0,0 +1,506 @@+++{- |+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.Objects.DeviceMonitor+    ( ++-- * Exported types+    DeviceMonitor(..)                       ,+    DeviceMonitorK                          ,+    toDeviceMonitor                         ,+    noDeviceMonitor                         ,+++ -- * Methods+-- ** deviceMonitorAddFilter+    DeviceMonitorAddFilterMethodInfo        ,+    deviceMonitorAddFilter                  ,+++-- ** deviceMonitorGetBus+    DeviceMonitorGetBusMethodInfo           ,+    deviceMonitorGetBus                     ,+++-- ** deviceMonitorGetDevices+    DeviceMonitorGetDevicesMethodInfo       ,+    deviceMonitorGetDevices                 ,+++-- ** deviceMonitorGetProviders+    DeviceMonitorGetProvidersMethodInfo     ,+    deviceMonitorGetProviders               ,+++-- ** deviceMonitorGetShowAllDevices+    DeviceMonitorGetShowAllDevicesMethodInfo,+    deviceMonitorGetShowAllDevices          ,+++-- ** deviceMonitorNew+    deviceMonitorNew                        ,+++-- ** deviceMonitorRemoveFilter+    DeviceMonitorRemoveFilterMethodInfo     ,+    deviceMonitorRemoveFilter               ,+++-- ** deviceMonitorSetShowAllDevices+    DeviceMonitorSetShowAllDevicesMethodInfo,+    deviceMonitorSetShowAllDevices          ,+++-- ** deviceMonitorStart+    DeviceMonitorStartMethodInfo            ,+    deviceMonitorStart                      ,+++-- ** deviceMonitorStop+    DeviceMonitorStopMethodInfo             ,+    deviceMonitorStop                       ,+++++ -- * Properties+-- ** ShowAll+    DeviceMonitorShowAllPropertyInfo        ,+    constructDeviceMonitorShowAll           ,+    getDeviceMonitorShowAll                 ,+    setDeviceMonitorShowAll                 ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype DeviceMonitor = DeviceMonitor (ForeignPtr DeviceMonitor)+foreign import ccall "gst_device_monitor_get_type"+    c_gst_device_monitor_get_type :: IO GType++type instance ParentTypes DeviceMonitor = DeviceMonitorParentTypes+type DeviceMonitorParentTypes = '[Object, GObject.Object]++instance GObject DeviceMonitor where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_device_monitor_get_type+    ++class GObject o => DeviceMonitorK o+instance (GObject o, IsDescendantOf DeviceMonitor o) => DeviceMonitorK o++toDeviceMonitor :: DeviceMonitorK o => o -> IO DeviceMonitor+toDeviceMonitor = unsafeCastTo DeviceMonitor++noDeviceMonitor :: Maybe DeviceMonitor+noDeviceMonitor = Nothing++type family ResolveDeviceMonitorMethod (t :: Symbol) (o :: *) :: * where+    ResolveDeviceMonitorMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveDeviceMonitorMethod "addFilter" o = DeviceMonitorAddFilterMethodInfo+    ResolveDeviceMonitorMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveDeviceMonitorMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveDeviceMonitorMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveDeviceMonitorMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveDeviceMonitorMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveDeviceMonitorMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveDeviceMonitorMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveDeviceMonitorMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveDeviceMonitorMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveDeviceMonitorMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveDeviceMonitorMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveDeviceMonitorMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveDeviceMonitorMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveDeviceMonitorMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveDeviceMonitorMethod "removeFilter" o = DeviceMonitorRemoveFilterMethodInfo+    ResolveDeviceMonitorMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveDeviceMonitorMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveDeviceMonitorMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveDeviceMonitorMethod "start" o = DeviceMonitorStartMethodInfo+    ResolveDeviceMonitorMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveDeviceMonitorMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveDeviceMonitorMethod "stop" o = DeviceMonitorStopMethodInfo+    ResolveDeviceMonitorMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveDeviceMonitorMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveDeviceMonitorMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveDeviceMonitorMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveDeviceMonitorMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveDeviceMonitorMethod "getBus" o = DeviceMonitorGetBusMethodInfo+    ResolveDeviceMonitorMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveDeviceMonitorMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveDeviceMonitorMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveDeviceMonitorMethod "getDevices" o = DeviceMonitorGetDevicesMethodInfo+    ResolveDeviceMonitorMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveDeviceMonitorMethod "getName" o = ObjectGetNameMethodInfo+    ResolveDeviceMonitorMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveDeviceMonitorMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveDeviceMonitorMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveDeviceMonitorMethod "getProviders" o = DeviceMonitorGetProvidersMethodInfo+    ResolveDeviceMonitorMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveDeviceMonitorMethod "getShowAllDevices" o = DeviceMonitorGetShowAllDevicesMethodInfo+    ResolveDeviceMonitorMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveDeviceMonitorMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveDeviceMonitorMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveDeviceMonitorMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveDeviceMonitorMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveDeviceMonitorMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveDeviceMonitorMethod "setName" o = ObjectSetNameMethodInfo+    ResolveDeviceMonitorMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveDeviceMonitorMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveDeviceMonitorMethod "setShowAllDevices" o = DeviceMonitorSetShowAllDevicesMethodInfo+    ResolveDeviceMonitorMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveDeviceMonitorMethod t DeviceMonitor, MethodInfo info DeviceMonitor p) => IsLabelProxy t (DeviceMonitor -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveDeviceMonitorMethod t DeviceMonitor, MethodInfo info DeviceMonitor p) => IsLabel t (DeviceMonitor -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- VVV Prop "show-all"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getDeviceMonitorShowAll :: (MonadIO m, DeviceMonitorK o) => o -> m Bool+getDeviceMonitorShowAll obj = liftIO $ getObjectPropertyBool obj "show-all"++setDeviceMonitorShowAll :: (MonadIO m, DeviceMonitorK o) => o -> Bool -> m ()+setDeviceMonitorShowAll obj val = liftIO $ setObjectPropertyBool obj "show-all" val++constructDeviceMonitorShowAll :: Bool -> IO ([Char], GValue)+constructDeviceMonitorShowAll val = constructObjectPropertyBool "show-all" val++data DeviceMonitorShowAllPropertyInfo+instance AttrInfo DeviceMonitorShowAllPropertyInfo where+    type AttrAllowedOps DeviceMonitorShowAllPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint DeviceMonitorShowAllPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint DeviceMonitorShowAllPropertyInfo = DeviceMonitorK+    type AttrGetType DeviceMonitorShowAllPropertyInfo = Bool+    type AttrLabel DeviceMonitorShowAllPropertyInfo = "show-all"+    attrGet _ = getDeviceMonitorShowAll+    attrSet _ = setDeviceMonitorShowAll+    attrConstruct _ = constructDeviceMonitorShowAll++type instance AttributeList DeviceMonitor = DeviceMonitorAttributeList+type DeviceMonitorAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("showAll", DeviceMonitorShowAllPropertyInfo)] :: [(Symbol, *)])++type instance SignalList DeviceMonitor = DeviceMonitorSignalList+type DeviceMonitorSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DeviceMonitor::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "DeviceMonitor"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_new" gst_device_monitor_new :: +    IO (Ptr DeviceMonitor)+++deviceMonitorNew ::+    (MonadIO m) =>+    m DeviceMonitor                         -- result+deviceMonitorNew  = liftIO $ do+    result <- gst_device_monitor_new+    checkUnexpectedReturnNULL "gst_device_monitor_new" result+    result' <- (wrapObject DeviceMonitor) result+    return result'++-- method DeviceMonitor::add_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_add_filter" gst_device_monitor_add_filter :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    CString ->                              -- classes : TBasicType TUTF8+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO Word32+++deviceMonitorAddFilter ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- classes+    -> Maybe (Caps)                         -- caps+    -> m Word32                             -- result+deviceMonitorAddFilter _obj classes caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeClasses <- case classes of+        Nothing -> return nullPtr+        Just jClasses -> do+            jClasses' <- textToCString jClasses+            return jClasses'+    maybeCaps <- case caps of+        Nothing -> return nullPtr+        Just jCaps -> do+            let jCaps' = unsafeManagedPtrGetPtr jCaps+            return jCaps'+    result <- gst_device_monitor_add_filter _obj' maybeClasses maybeCaps+    touchManagedPtr _obj+    whenJust caps touchManagedPtr+    freeMem maybeClasses+    return result++data DeviceMonitorAddFilterMethodInfo+instance (signature ~ (Maybe (T.Text) -> Maybe (Caps) -> m Word32), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorAddFilterMethodInfo a signature where+    overloadedMethod _ = deviceMonitorAddFilter++-- method DeviceMonitor::get_bus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Bus"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_get_bus" gst_device_monitor_get_bus :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    IO (Ptr Bus)+++deviceMonitorGetBus ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> m Bus                                -- result+deviceMonitorGetBus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_monitor_get_bus _obj'+    checkUnexpectedReturnNULL "gst_device_monitor_get_bus" result+    result' <- (wrapObject Bus) result+    touchManagedPtr _obj+    return result'++data DeviceMonitorGetBusMethodInfo+instance (signature ~ (m Bus), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetBusMethodInfo a signature where+    overloadedMethod _ = deviceMonitorGetBus++-- method DeviceMonitor::get_devices+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "Device")+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_get_devices" gst_device_monitor_get_devices :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    IO (Ptr (GList (Ptr Device)))+++deviceMonitorGetDevices ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> m [Device]                           -- result+deviceMonitorGetDevices _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_monitor_get_devices _obj'+    checkUnexpectedReturnNULL "gst_device_monitor_get_devices" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Device) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++data DeviceMonitorGetDevicesMethodInfo+instance (signature ~ (m [Device]), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetDevicesMethodInfo a signature where+    overloadedMethod _ = deviceMonitorGetDevices++-- method DeviceMonitor::get_providers+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_get_providers" gst_device_monitor_get_providers :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    IO (Ptr CString)+++deviceMonitorGetProviders ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+deviceMonitorGetProviders _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_monitor_get_providers _obj'+    checkUnexpectedReturnNULL "gst_device_monitor_get_providers" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++data DeviceMonitorGetProvidersMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetProvidersMethodInfo a signature where+    overloadedMethod _ = deviceMonitorGetProviders++-- method DeviceMonitor::get_show_all_devices+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_get_show_all_devices" gst_device_monitor_get_show_all_devices :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    IO CInt+++deviceMonitorGetShowAllDevices ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+deviceMonitorGetShowAllDevices _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_monitor_get_show_all_devices _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DeviceMonitorGetShowAllDevicesMethodInfo+instance (signature ~ (m Bool), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetShowAllDevicesMethodInfo a signature where+    overloadedMethod _ = deviceMonitorGetShowAllDevices++-- method DeviceMonitor::remove_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_remove_filter" gst_device_monitor_remove_filter :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    Word32 ->                               -- filter_id : TBasicType TUInt32+    IO CInt+++deviceMonitorRemoveFilter ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> Word32                               -- filterId+    -> m Bool                               -- result+deviceMonitorRemoveFilter _obj filterId = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_monitor_remove_filter _obj' filterId+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DeviceMonitorRemoveFilterMethodInfo+instance (signature ~ (Word32 -> m Bool), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorRemoveFilterMethodInfo a signature where+    overloadedMethod _ = deviceMonitorRemoveFilter++-- method DeviceMonitor::set_show_all_devices+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show_all", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_set_show_all_devices" gst_device_monitor_set_show_all_devices :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    CInt ->                                 -- show_all : TBasicType TBoolean+    IO ()+++deviceMonitorSetShowAllDevices ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> Bool                                 -- showAll+    -> m ()                                 -- result+deviceMonitorSetShowAllDevices _obj showAll = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let showAll' = (fromIntegral . fromEnum) showAll+    gst_device_monitor_set_show_all_devices _obj' showAll'+    touchManagedPtr _obj+    return ()++data DeviceMonitorSetShowAllDevicesMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorSetShowAllDevicesMethodInfo a signature where+    overloadedMethod _ = deviceMonitorSetShowAllDevices++-- method DeviceMonitor::start+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_start" gst_device_monitor_start :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    IO CInt+++deviceMonitorStart ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+deviceMonitorStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_monitor_start _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DeviceMonitorStartMethodInfo+instance (signature ~ (m Bool), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorStartMethodInfo a signature where+    overloadedMethod _ = deviceMonitorStart++-- method DeviceMonitor::stop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_monitor_stop" gst_device_monitor_stop :: +    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"+    IO ()+++deviceMonitorStop ::+    (MonadIO m, DeviceMonitorK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+deviceMonitorStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_device_monitor_stop _obj'+    touchManagedPtr _obj+    return ()++data DeviceMonitorStopMethodInfo+instance (signature ~ (m ()), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorStopMethodInfo a signature where+    overloadedMethod _ = deviceMonitorStop++
+ GI/Gst/Objects/DeviceMonitor.hs-boot view
@@ -0,0 +1,23 @@+module GI.Gst.Objects.DeviceMonitor 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++newtype DeviceMonitor = DeviceMonitor (ForeignPtr DeviceMonitor)+instance GObject DeviceMonitor where+class GObject o => DeviceMonitorK o+instance (GObject o, IsDescendantOf DeviceMonitor o) => DeviceMonitorK o+data DeviceMonitorShowAllPropertyInfo+data DeviceMonitorAddFilterMethodInfo+data DeviceMonitorGetBusMethodInfo+data DeviceMonitorGetDevicesMethodInfo+data DeviceMonitorGetProvidersMethodInfo+data DeviceMonitorGetShowAllDevicesMethodInfo+data DeviceMonitorRemoveFilterMethodInfo+data DeviceMonitorSetShowAllDevicesMethodInfo+data DeviceMonitorStartMethodInfo+data DeviceMonitorStopMethodInfo
+ GI/Gst/Objects/DeviceProvider.hs view
@@ -0,0 +1,671 @@+++{- |+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.Objects.DeviceProvider+    ( ++-- * Exported types+    DeviceProvider(..)                      ,+    DeviceProviderK                         ,+    toDeviceProvider                        ,+    noDeviceProvider                        ,+++ -- * Methods+-- ** deviceProviderCanMonitor+    DeviceProviderCanMonitorMethodInfo      ,+    deviceProviderCanMonitor                ,+++-- ** deviceProviderDeviceAdd+    DeviceProviderDeviceAddMethodInfo       ,+    deviceProviderDeviceAdd                 ,+++-- ** deviceProviderDeviceRemove+    DeviceProviderDeviceRemoveMethodInfo    ,+    deviceProviderDeviceRemove              ,+++-- ** deviceProviderGetBus+    DeviceProviderGetBusMethodInfo          ,+    deviceProviderGetBus                    ,+++-- ** deviceProviderGetDevices+    DeviceProviderGetDevicesMethodInfo      ,+    deviceProviderGetDevices                ,+++-- ** deviceProviderGetFactory+    DeviceProviderGetFactoryMethodInfo      ,+    deviceProviderGetFactory                ,+++-- ** deviceProviderGetHiddenProviders+    DeviceProviderGetHiddenProvidersMethodInfo,+    deviceProviderGetHiddenProviders        ,+++-- ** deviceProviderHideProvider+    DeviceProviderHideProviderMethodInfo    ,+    deviceProviderHideProvider              ,+++-- ** deviceProviderRegister+    deviceProviderRegister                  ,+++-- ** deviceProviderStart+    DeviceProviderStartMethodInfo           ,+    deviceProviderStart                     ,+++-- ** deviceProviderStop+    DeviceProviderStopMethodInfo            ,+    deviceProviderStop                      ,+++-- ** deviceProviderUnhideProvider+    DeviceProviderUnhideProviderMethodInfo  ,+    deviceProviderUnhideProvider            ,+++++ -- * Signals+-- ** ProviderHidden+    DeviceProviderProviderHiddenCallback    ,+    DeviceProviderProviderHiddenCallbackC   ,+    DeviceProviderProviderHiddenSignalInfo  ,+    afterDeviceProviderProviderHidden       ,+    deviceProviderProviderHiddenCallbackWrapper,+    deviceProviderProviderHiddenClosure     ,+    mkDeviceProviderProviderHiddenCallback  ,+    noDeviceProviderProviderHiddenCallback  ,+    onDeviceProviderProviderHidden          ,+++-- ** ProviderUnhidden+    DeviceProviderProviderUnhiddenCallback  ,+    DeviceProviderProviderUnhiddenCallbackC ,+    DeviceProviderProviderUnhiddenSignalInfo,+    afterDeviceProviderProviderUnhidden     ,+    deviceProviderProviderUnhiddenCallbackWrapper,+    deviceProviderProviderUnhiddenClosure   ,+    mkDeviceProviderProviderUnhiddenCallback,+    noDeviceProviderProviderUnhiddenCallback,+    onDeviceProviderProviderUnhidden        ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype DeviceProvider = DeviceProvider (ForeignPtr DeviceProvider)+foreign import ccall "gst_device_provider_get_type"+    c_gst_device_provider_get_type :: IO GType++type instance ParentTypes DeviceProvider = DeviceProviderParentTypes+type DeviceProviderParentTypes = '[Object, GObject.Object]++instance GObject DeviceProvider where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_device_provider_get_type+    ++class GObject o => DeviceProviderK o+instance (GObject o, IsDescendantOf DeviceProvider o) => DeviceProviderK o++toDeviceProvider :: DeviceProviderK o => o -> IO DeviceProvider+toDeviceProvider = unsafeCastTo DeviceProvider++noDeviceProvider :: Maybe DeviceProvider+noDeviceProvider = Nothing++type family ResolveDeviceProviderMethod (t :: Symbol) (o :: *) :: * where+    ResolveDeviceProviderMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveDeviceProviderMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveDeviceProviderMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveDeviceProviderMethod "canMonitor" o = DeviceProviderCanMonitorMethodInfo+    ResolveDeviceProviderMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveDeviceProviderMethod "deviceAdd" o = DeviceProviderDeviceAddMethodInfo+    ResolveDeviceProviderMethod "deviceRemove" o = DeviceProviderDeviceRemoveMethodInfo+    ResolveDeviceProviderMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveDeviceProviderMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveDeviceProviderMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveDeviceProviderMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveDeviceProviderMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveDeviceProviderMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveDeviceProviderMethod "hideProvider" o = DeviceProviderHideProviderMethodInfo+    ResolveDeviceProviderMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveDeviceProviderMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveDeviceProviderMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveDeviceProviderMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveDeviceProviderMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveDeviceProviderMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveDeviceProviderMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveDeviceProviderMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveDeviceProviderMethod "start" o = DeviceProviderStartMethodInfo+    ResolveDeviceProviderMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveDeviceProviderMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveDeviceProviderMethod "stop" o = DeviceProviderStopMethodInfo+    ResolveDeviceProviderMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveDeviceProviderMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveDeviceProviderMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveDeviceProviderMethod "unhideProvider" o = DeviceProviderUnhideProviderMethodInfo+    ResolveDeviceProviderMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveDeviceProviderMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveDeviceProviderMethod "getBus" o = DeviceProviderGetBusMethodInfo+    ResolveDeviceProviderMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveDeviceProviderMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveDeviceProviderMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveDeviceProviderMethod "getDevices" o = DeviceProviderGetDevicesMethodInfo+    ResolveDeviceProviderMethod "getFactory" o = DeviceProviderGetFactoryMethodInfo+    ResolveDeviceProviderMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveDeviceProviderMethod "getHiddenProviders" o = DeviceProviderGetHiddenProvidersMethodInfo+    ResolveDeviceProviderMethod "getName" o = ObjectGetNameMethodInfo+    ResolveDeviceProviderMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveDeviceProviderMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveDeviceProviderMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveDeviceProviderMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveDeviceProviderMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveDeviceProviderMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveDeviceProviderMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveDeviceProviderMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveDeviceProviderMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveDeviceProviderMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveDeviceProviderMethod "setName" o = ObjectSetNameMethodInfo+    ResolveDeviceProviderMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveDeviceProviderMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveDeviceProviderMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, MethodInfo info DeviceProvider p) => IsLabelProxy t (DeviceProvider -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, MethodInfo info DeviceProvider p) => IsLabel t (DeviceProvider -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal DeviceProvider::provider-hidden+type DeviceProviderProviderHiddenCallback =+    T.Text ->+    IO ()++noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback+noDeviceProviderProviderHiddenCallback = Nothing++type DeviceProviderProviderHiddenCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDeviceProviderProviderHiddenCallback :: DeviceProviderProviderHiddenCallbackC -> IO (FunPtr DeviceProviderProviderHiddenCallbackC)++deviceProviderProviderHiddenClosure :: DeviceProviderProviderHiddenCallback -> IO Closure+deviceProviderProviderHiddenClosure cb = newCClosure =<< mkDeviceProviderProviderHiddenCallback wrapped+    where wrapped = deviceProviderProviderHiddenCallbackWrapper cb++deviceProviderProviderHiddenCallbackWrapper ::+    DeviceProviderProviderHiddenCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+deviceProviderProviderHiddenCallbackWrapper _cb _ object _ = do+    object' <- cstringToText object+    _cb  object'++onDeviceProviderProviderHidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId+onDeviceProviderProviderHidden obj cb = liftIO $ connectDeviceProviderProviderHidden obj cb SignalConnectBefore+afterDeviceProviderProviderHidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId+afterDeviceProviderProviderHidden obj cb = connectDeviceProviderProviderHidden obj cb SignalConnectAfter++connectDeviceProviderProviderHidden :: (GObject a, MonadIO m) =>+                                       a -> DeviceProviderProviderHiddenCallback -> SignalConnectMode -> m SignalHandlerId+connectDeviceProviderProviderHidden obj cb after = liftIO $ do+    cb' <- mkDeviceProviderProviderHiddenCallback (deviceProviderProviderHiddenCallbackWrapper cb)+    connectSignalFunPtr obj "provider-hidden" cb' after++-- signal DeviceProvider::provider-unhidden+type DeviceProviderProviderUnhiddenCallback =+    T.Text ->+    IO ()++noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderUnhiddenCallback+noDeviceProviderProviderUnhiddenCallback = Nothing++type DeviceProviderProviderUnhiddenCallbackC =+    Ptr () ->                               -- object+    CString ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkDeviceProviderProviderUnhiddenCallback :: DeviceProviderProviderUnhiddenCallbackC -> IO (FunPtr DeviceProviderProviderUnhiddenCallbackC)++deviceProviderProviderUnhiddenClosure :: DeviceProviderProviderUnhiddenCallback -> IO Closure+deviceProviderProviderUnhiddenClosure cb = newCClosure =<< mkDeviceProviderProviderUnhiddenCallback wrapped+    where wrapped = deviceProviderProviderUnhiddenCallbackWrapper cb++deviceProviderProviderUnhiddenCallbackWrapper ::+    DeviceProviderProviderUnhiddenCallback ->+    Ptr () ->+    CString ->+    Ptr () ->+    IO ()+deviceProviderProviderUnhiddenCallbackWrapper _cb _ object _ = do+    object' <- cstringToText object+    _cb  object'++onDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId+onDeviceProviderProviderUnhidden obj cb = liftIO $ connectDeviceProviderProviderUnhidden obj cb SignalConnectBefore+afterDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId+afterDeviceProviderProviderUnhidden obj cb = connectDeviceProviderProviderUnhidden obj cb SignalConnectAfter++connectDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) =>+                                         a -> DeviceProviderProviderUnhiddenCallback -> SignalConnectMode -> m SignalHandlerId+connectDeviceProviderProviderUnhidden obj cb after = liftIO $ do+    cb' <- mkDeviceProviderProviderUnhiddenCallback (deviceProviderProviderUnhiddenCallbackWrapper cb)+    connectSignalFunPtr obj "provider-unhidden" cb' after++type instance AttributeList DeviceProvider = DeviceProviderAttributeList+type DeviceProviderAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++data DeviceProviderProviderHiddenSignalInfo+instance SignalInfo DeviceProviderProviderHiddenSignalInfo where+    type HaskellCallbackType DeviceProviderProviderHiddenSignalInfo = DeviceProviderProviderHiddenCallback+    connectSignal _ = connectDeviceProviderProviderHidden++data DeviceProviderProviderUnhiddenSignalInfo+instance SignalInfo DeviceProviderProviderUnhiddenSignalInfo where+    type HaskellCallbackType DeviceProviderProviderUnhiddenSignalInfo = DeviceProviderProviderUnhiddenCallback+    connectSignal _ = connectDeviceProviderProviderUnhidden++type instance SignalList DeviceProvider = DeviceProviderSignalList+type DeviceProviderSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("providerHidden", DeviceProviderProviderHiddenSignalInfo), '("providerUnhidden", DeviceProviderProviderUnhiddenSignalInfo)] :: [(Symbol, *)])++-- method DeviceProvider::can_monitor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_can_monitor" gst_device_provider_can_monitor :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    IO CInt+++deviceProviderCanMonitor ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+deviceProviderCanMonitor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_can_monitor _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DeviceProviderCanMonitorMethodInfo+instance (signature ~ (m Bool), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderCanMonitorMethodInfo a signature where+    overloadedMethod _ = deviceProviderCanMonitor++-- method DeviceProvider::device_add+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_device_add" gst_device_provider_device_add :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    Ptr Device ->                           -- device : TInterface "Gst" "Device"+    IO ()+++deviceProviderDeviceAdd ::+    (MonadIO m, DeviceProviderK a, DeviceK b) =>+    a                                       -- _obj+    -> b                                    -- device+    -> m ()                                 -- result+deviceProviderDeviceAdd _obj device = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    device' <- refObject device+    gst_device_provider_device_add _obj' device'+    touchManagedPtr _obj+    touchManagedPtr device+    return ()++data DeviceProviderDeviceAddMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, DeviceProviderK a, DeviceK b) => MethodInfo DeviceProviderDeviceAddMethodInfo a signature where+    overloadedMethod _ = deviceProviderDeviceAdd++-- method DeviceProvider::device_remove+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_device_remove" gst_device_provider_device_remove :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    Ptr Device ->                           -- device : TInterface "Gst" "Device"+    IO ()+++deviceProviderDeviceRemove ::+    (MonadIO m, DeviceProviderK a, DeviceK b) =>+    a                                       -- _obj+    -> b                                    -- device+    -> m ()                                 -- result+deviceProviderDeviceRemove _obj device = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let device' = unsafeManagedPtrCastPtr device+    gst_device_provider_device_remove _obj' device'+    touchManagedPtr _obj+    touchManagedPtr device+    return ()++data DeviceProviderDeviceRemoveMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, DeviceProviderK a, DeviceK b) => MethodInfo DeviceProviderDeviceRemoveMethodInfo a signature where+    overloadedMethod _ = deviceProviderDeviceRemove++-- method DeviceProvider::get_bus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Bus"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_get_bus" gst_device_provider_get_bus :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    IO (Ptr Bus)+++deviceProviderGetBus ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> m Bus                                -- result+deviceProviderGetBus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_get_bus _obj'+    checkUnexpectedReturnNULL "gst_device_provider_get_bus" result+    result' <- (wrapObject Bus) result+    touchManagedPtr _obj+    return result'++data DeviceProviderGetBusMethodInfo+instance (signature ~ (m Bus), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetBusMethodInfo a signature where+    overloadedMethod _ = deviceProviderGetBus++-- method DeviceProvider::get_devices+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "Device")+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_get_devices" gst_device_provider_get_devices :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    IO (Ptr (GList (Ptr Device)))+++deviceProviderGetDevices ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> m [Device]                           -- result+deviceProviderGetDevices _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_get_devices _obj'+    checkUnexpectedReturnNULL "gst_device_provider_get_devices" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Device) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++data DeviceProviderGetDevicesMethodInfo+instance (signature ~ (m [Device]), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetDevicesMethodInfo a signature where+    overloadedMethod _ = deviceProviderGetDevices++-- method DeviceProvider::get_factory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DeviceProviderFactory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_get_factory" gst_device_provider_get_factory :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    IO (Ptr DeviceProviderFactory)+++deviceProviderGetFactory ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> m DeviceProviderFactory              -- result+deviceProviderGetFactory _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_get_factory _obj'+    checkUnexpectedReturnNULL "gst_device_provider_get_factory" result+    result' <- (newObject DeviceProviderFactory) result+    touchManagedPtr _obj+    return result'++data DeviceProviderGetFactoryMethodInfo+instance (signature ~ (m DeviceProviderFactory), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetFactoryMethodInfo a signature where+    overloadedMethod _ = deviceProviderGetFactory++-- method DeviceProvider::get_hidden_providers+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_get_hidden_providers" gst_device_provider_get_hidden_providers :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    IO (Ptr CString)+++deviceProviderGetHiddenProviders ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+deviceProviderGetHiddenProviders _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_get_hidden_providers _obj'+    checkUnexpectedReturnNULL "gst_device_provider_get_hidden_providers" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++data DeviceProviderGetHiddenProvidersMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetHiddenProvidersMethodInfo a signature where+    overloadedMethod _ = deviceProviderGetHiddenProviders++-- method DeviceProvider::hide_provider+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_hide_provider" gst_device_provider_hide_provider :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++deviceProviderHideProvider ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m ()                                 -- result+deviceProviderHideProvider _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    gst_device_provider_hide_provider _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++data DeviceProviderHideProviderMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderHideProviderMethodInfo a signature where+    overloadedMethod _ = deviceProviderHideProvider++-- method DeviceProvider::start+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_start" gst_device_provider_start :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    IO CInt+++deviceProviderStart ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+deviceProviderStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_start _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DeviceProviderStartMethodInfo+instance (signature ~ (m Bool), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderStartMethodInfo a signature where+    overloadedMethod _ = deviceProviderStart++-- method DeviceProvider::stop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_stop" gst_device_provider_stop :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    IO ()+++deviceProviderStop ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+deviceProviderStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_device_provider_stop _obj'+    touchManagedPtr _obj+    return ()++data DeviceProviderStopMethodInfo+instance (signature ~ (m ()), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderStopMethodInfo a signature where+    overloadedMethod _ = deviceProviderStop++-- method DeviceProvider::unhide_provider+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_unhide_provider" gst_device_provider_unhide_provider :: +    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++deviceProviderUnhideProvider ::+    (MonadIO m, DeviceProviderK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m ()                                 -- result+deviceProviderUnhideProvider _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    gst_device_provider_unhide_provider _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++data DeviceProviderUnhideProviderMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderUnhideProviderMethodInfo a signature where+    overloadedMethod _ = deviceProviderUnhideProvider++-- method DeviceProvider::register+-- method type : MemberFunction+-- Args : [Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_register" gst_device_provider_register :: +    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"+    CString ->                              -- name : TBasicType TUTF8+    Word32 ->                               -- rank : TBasicType TUInt32+    CGType ->                               -- type : TBasicType TGType+    IO CInt+++deviceProviderRegister ::+    (MonadIO m, PluginK a) =>+    Maybe (a)                               -- plugin+    -> T.Text                               -- name+    -> Word32                               -- rank+    -> GType                                -- type_+    -> m Bool                               -- result+deviceProviderRegister plugin name rank type_ = liftIO $ do+    maybePlugin <- case plugin of+        Nothing -> return nullPtr+        Just jPlugin -> do+            let jPlugin' = unsafeManagedPtrCastPtr jPlugin+            return jPlugin'+    name' <- textToCString name+    let type_' = gtypeToCGType type_+    result <- gst_device_provider_register maybePlugin name' rank type_'+    let result' = (/= 0) result+    whenJust plugin touchManagedPtr+    freeMem name'+    return result'++
+ GI/Gst/Objects/DeviceProvider.hs-boot view
@@ -0,0 +1,26 @@+module GI.Gst.Objects.DeviceProvider 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++newtype DeviceProvider = DeviceProvider (ForeignPtr DeviceProvider)+instance GObject DeviceProvider where+class GObject o => DeviceProviderK o+instance (GObject o, IsDescendantOf DeviceProvider o) => DeviceProviderK o+data DeviceProviderProviderHiddenSignalInfo+data DeviceProviderProviderUnhiddenSignalInfo+data DeviceProviderCanMonitorMethodInfo+data DeviceProviderDeviceAddMethodInfo+data DeviceProviderDeviceRemoveMethodInfo+data DeviceProviderGetBusMethodInfo+data DeviceProviderGetDevicesMethodInfo+data DeviceProviderGetFactoryMethodInfo+data DeviceProviderGetHiddenProvidersMethodInfo+data DeviceProviderHideProviderMethodInfo+data DeviceProviderStartMethodInfo+data DeviceProviderStopMethodInfo+data DeviceProviderUnhideProviderMethodInfo
+ GI/Gst/Objects/DeviceProviderFactory.hs view
@@ -0,0 +1,440 @@+++{- |+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.Objects.DeviceProviderFactory+    ( ++-- * Exported types+    DeviceProviderFactory(..)               ,+    DeviceProviderFactoryK                  ,+    toDeviceProviderFactory                 ,+    noDeviceProviderFactory                 ,+++ -- * Methods+-- ** deviceProviderFactoryFind+    deviceProviderFactoryFind               ,+++-- ** deviceProviderFactoryGet+    DeviceProviderFactoryGetMethodInfo      ,+    deviceProviderFactoryGet                ,+++-- ** deviceProviderFactoryGetByName+    deviceProviderFactoryGetByName          ,+++-- ** deviceProviderFactoryGetDeviceProviderType+    DeviceProviderFactoryGetDeviceProviderTypeMethodInfo,+    deviceProviderFactoryGetDeviceProviderType,+++-- ** deviceProviderFactoryGetMetadata+    DeviceProviderFactoryGetMetadataMethodInfo,+    deviceProviderFactoryGetMetadata        ,+++-- ** deviceProviderFactoryGetMetadataKeys+    DeviceProviderFactoryGetMetadataKeysMethodInfo,+    deviceProviderFactoryGetMetadataKeys    ,+++-- ** deviceProviderFactoryHasClasses+    DeviceProviderFactoryHasClassesMethodInfo,+    deviceProviderFactoryHasClasses         ,+++-- ** deviceProviderFactoryHasClassesv+    DeviceProviderFactoryHasClassesvMethodInfo,+    deviceProviderFactoryHasClassesv        ,+++-- ** deviceProviderFactoryListGetDeviceProviders+    deviceProviderFactoryListGetDeviceProviders,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype DeviceProviderFactory = DeviceProviderFactory (ForeignPtr DeviceProviderFactory)+foreign import ccall "gst_device_provider_factory_get_type"+    c_gst_device_provider_factory_get_type :: IO GType++type instance ParentTypes DeviceProviderFactory = DeviceProviderFactoryParentTypes+type DeviceProviderFactoryParentTypes = '[PluginFeature, Object, GObject.Object]++instance GObject DeviceProviderFactory where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_device_provider_factory_get_type+    ++class GObject o => DeviceProviderFactoryK o+instance (GObject o, IsDescendantOf DeviceProviderFactory o) => DeviceProviderFactoryK o++toDeviceProviderFactory :: DeviceProviderFactoryK o => o -> IO DeviceProviderFactory+toDeviceProviderFactory = unsafeCastTo DeviceProviderFactory++noDeviceProviderFactory :: Maybe DeviceProviderFactory+noDeviceProviderFactory = Nothing++type family ResolveDeviceProviderFactoryMethod (t :: Symbol) (o :: *) :: * where+    ResolveDeviceProviderFactoryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveDeviceProviderFactoryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveDeviceProviderFactoryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveDeviceProviderFactoryMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo+    ResolveDeviceProviderFactoryMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveDeviceProviderFactoryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveDeviceProviderFactoryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveDeviceProviderFactoryMethod "get" o = DeviceProviderFactoryGetMethodInfo+    ResolveDeviceProviderFactoryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveDeviceProviderFactoryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveDeviceProviderFactoryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveDeviceProviderFactoryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveDeviceProviderFactoryMethod "hasClasses" o = DeviceProviderFactoryHasClassesMethodInfo+    ResolveDeviceProviderFactoryMethod "hasClassesv" o = DeviceProviderFactoryHasClassesvMethodInfo+    ResolveDeviceProviderFactoryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveDeviceProviderFactoryMethod "load" o = PluginFeatureLoadMethodInfo+    ResolveDeviceProviderFactoryMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveDeviceProviderFactoryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveDeviceProviderFactoryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveDeviceProviderFactoryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveDeviceProviderFactoryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveDeviceProviderFactoryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveDeviceProviderFactoryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveDeviceProviderFactoryMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveDeviceProviderFactoryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveDeviceProviderFactoryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveDeviceProviderFactoryMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveDeviceProviderFactoryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveDeviceProviderFactoryMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveDeviceProviderFactoryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveDeviceProviderFactoryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveDeviceProviderFactoryMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveDeviceProviderFactoryMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveDeviceProviderFactoryMethod "getDeviceProviderType" o = DeviceProviderFactoryGetDeviceProviderTypeMethodInfo+    ResolveDeviceProviderFactoryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveDeviceProviderFactoryMethod "getMetadata" o = DeviceProviderFactoryGetMetadataMethodInfo+    ResolveDeviceProviderFactoryMethod "getMetadataKeys" o = DeviceProviderFactoryGetMetadataKeysMethodInfo+    ResolveDeviceProviderFactoryMethod "getName" o = ObjectGetNameMethodInfo+    ResolveDeviceProviderFactoryMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveDeviceProviderFactoryMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveDeviceProviderFactoryMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo+    ResolveDeviceProviderFactoryMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo+    ResolveDeviceProviderFactoryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveDeviceProviderFactoryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveDeviceProviderFactoryMethod "getRank" o = PluginFeatureGetRankMethodInfo+    ResolveDeviceProviderFactoryMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveDeviceProviderFactoryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveDeviceProviderFactoryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveDeviceProviderFactoryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveDeviceProviderFactoryMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveDeviceProviderFactoryMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveDeviceProviderFactoryMethod "setName" o = ObjectSetNameMethodInfo+    ResolveDeviceProviderFactoryMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveDeviceProviderFactoryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveDeviceProviderFactoryMethod "setRank" o = PluginFeatureSetRankMethodInfo+    ResolveDeviceProviderFactoryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveDeviceProviderFactoryMethod t DeviceProviderFactory, MethodInfo info DeviceProviderFactory p) => IsLabelProxy t (DeviceProviderFactory -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveDeviceProviderFactoryMethod t DeviceProviderFactory, MethodInfo info DeviceProviderFactory p) => IsLabel t (DeviceProviderFactory -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList DeviceProviderFactory = DeviceProviderFactoryAttributeList+type DeviceProviderFactoryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList DeviceProviderFactory = DeviceProviderFactorySignalList+type DeviceProviderFactorySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method DeviceProviderFactory::get+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DeviceProvider"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_get" gst_device_provider_factory_get :: +    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"+    IO (Ptr DeviceProvider)+++deviceProviderFactoryGet ::+    (MonadIO m, DeviceProviderFactoryK a) =>+    a                                       -- _obj+    -> m DeviceProvider                     -- result+deviceProviderFactoryGet _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_factory_get _obj'+    checkUnexpectedReturnNULL "gst_device_provider_factory_get" result+    result' <- (wrapObject DeviceProvider) result+    touchManagedPtr _obj+    return result'++data DeviceProviderFactoryGetMethodInfo+instance (signature ~ (m DeviceProvider), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetMethodInfo a signature where+    overloadedMethod _ = deviceProviderFactoryGet++-- method DeviceProviderFactory::get_device_provider_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_get_device_provider_type" gst_device_provider_factory_get_device_provider_type :: +    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"+    IO CGType+++deviceProviderFactoryGetDeviceProviderType ::+    (MonadIO m, DeviceProviderFactoryK a) =>+    a                                       -- _obj+    -> m GType                              -- result+deviceProviderFactoryGetDeviceProviderType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_factory_get_device_provider_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++data DeviceProviderFactoryGetDeviceProviderTypeMethodInfo+instance (signature ~ (m GType), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetDeviceProviderTypeMethodInfo a signature where+    overloadedMethod _ = deviceProviderFactoryGetDeviceProviderType++-- method DeviceProviderFactory::get_metadata+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_get_metadata" gst_device_provider_factory_get_metadata :: +    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"+    CString ->                              -- key : TBasicType TUTF8+    IO CString+++deviceProviderFactoryGetMetadata ::+    (MonadIO m, DeviceProviderFactoryK a) =>+    a                                       -- _obj+    -> T.Text                               -- key+    -> m T.Text                             -- result+deviceProviderFactoryGetMetadata _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gst_device_provider_factory_get_metadata _obj' key'+    checkUnexpectedReturnNULL "gst_device_provider_factory_get_metadata" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem key'+    return result'++data DeviceProviderFactoryGetMetadataMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetMetadataMethodInfo a signature where+    overloadedMethod _ = deviceProviderFactoryGetMetadata++-- method DeviceProviderFactory::get_metadata_keys+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_get_metadata_keys" gst_device_provider_factory_get_metadata_keys :: +    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"+    IO (Ptr CString)+++deviceProviderFactoryGetMetadataKeys ::+    (MonadIO m, DeviceProviderFactoryK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+deviceProviderFactoryGetMetadataKeys _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_device_provider_factory_get_metadata_keys _obj'+    checkUnexpectedReturnNULL "gst_device_provider_factory_get_metadata_keys" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++data DeviceProviderFactoryGetMetadataKeysMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetMetadataKeysMethodInfo a signature where+    overloadedMethod _ = deviceProviderFactoryGetMetadataKeys++-- method DeviceProviderFactory::has_classes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_has_classes" gst_device_provider_factory_has_classes :: +    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"+    CString ->                              -- classes : TBasicType TUTF8+    IO CInt+++deviceProviderFactoryHasClasses ::+    (MonadIO m, DeviceProviderFactoryK a) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- classes+    -> m Bool                               -- result+deviceProviderFactoryHasClasses _obj classes = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeClasses <- case classes of+        Nothing -> return nullPtr+        Just jClasses -> do+            jClasses' <- textToCString jClasses+            return jClasses'+    result <- gst_device_provider_factory_has_classes _obj' maybeClasses+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem maybeClasses+    return result'++data DeviceProviderFactoryHasClassesMethodInfo+instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryHasClassesMethodInfo a signature where+    overloadedMethod _ = deviceProviderFactoryHasClasses++-- method DeviceProviderFactory::has_classesv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_has_classesv" gst_device_provider_factory_has_classesv :: +    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"+    Ptr CString ->                          -- classes : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO CInt+++deviceProviderFactoryHasClassesv ::+    (MonadIO m, DeviceProviderFactoryK a) =>+    a                                       -- _obj+    -> Maybe ([T.Text])                     -- classes+    -> m Bool                               -- result+deviceProviderFactoryHasClassesv _obj classes = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeClasses <- case classes of+        Nothing -> return nullPtr+        Just jClasses -> do+            jClasses' <- packZeroTerminatedUTF8CArray jClasses+            return jClasses'+    result <- gst_device_provider_factory_has_classesv _obj' maybeClasses+    let result' = (/= 0) result+    touchManagedPtr _obj+    mapZeroTerminatedCArray freeMem maybeClasses+    freeMem maybeClasses+    return result'++data DeviceProviderFactoryHasClassesvMethodInfo+instance (signature ~ (Maybe ([T.Text]) -> m Bool), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryHasClassesvMethodInfo a signature where+    overloadedMethod _ = deviceProviderFactoryHasClassesv++-- method DeviceProviderFactory::find+-- method type : MemberFunction+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DeviceProviderFactory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_find" gst_device_provider_factory_find :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr DeviceProviderFactory)+++deviceProviderFactoryFind ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> m DeviceProviderFactory              -- result+deviceProviderFactoryFind name = liftIO $ do+    name' <- textToCString name+    result <- gst_device_provider_factory_find name'+    checkUnexpectedReturnNULL "gst_device_provider_factory_find" result+    result' <- (wrapObject DeviceProviderFactory) result+    freeMem name'+    return result'++-- method DeviceProviderFactory::get_by_name+-- method type : MemberFunction+-- Args : [Arg {argCName = "factoryname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DeviceProvider"+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_get_by_name" gst_device_provider_factory_get_by_name :: +    CString ->                              -- factoryname : TBasicType TUTF8+    IO (Ptr DeviceProvider)+++deviceProviderFactoryGetByName ::+    (MonadIO m) =>+    T.Text                                  -- factoryname+    -> m DeviceProvider                     -- result+deviceProviderFactoryGetByName factoryname = liftIO $ do+    factoryname' <- textToCString factoryname+    result <- gst_device_provider_factory_get_by_name factoryname'+    checkUnexpectedReturnNULL "gst_device_provider_factory_get_by_name" result+    result' <- (wrapObject DeviceProvider) result+    freeMem factoryname'+    return result'++-- method DeviceProviderFactory::list_get_device_providers+-- method type : MemberFunction+-- Args : [Arg {argCName = "minrank", argType = TInterface "Gst" "Rank", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "DeviceProviderFactory")+-- throws : False+-- Skip return : False++foreign import ccall "gst_device_provider_factory_list_get_device_providers" gst_device_provider_factory_list_get_device_providers :: +    CUInt ->                                -- minrank : TInterface "Gst" "Rank"+    IO (Ptr (GList (Ptr DeviceProviderFactory)))+++deviceProviderFactoryListGetDeviceProviders ::+    (MonadIO m) =>+    Rank                                    -- minrank+    -> m [DeviceProviderFactory]            -- result+deviceProviderFactoryListGetDeviceProviders minrank = liftIO $ do+    let minrank' = (fromIntegral . fromEnum) minrank+    result <- gst_device_provider_factory_list_get_device_providers minrank'+    checkUnexpectedReturnNULL "gst_device_provider_factory_list_get_device_providers" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject DeviceProviderFactory) result'+    g_list_free result+    return result''++
+ GI/Gst/Objects/DeviceProviderFactory.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gst.Objects.DeviceProviderFactory 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++newtype DeviceProviderFactory = DeviceProviderFactory (ForeignPtr DeviceProviderFactory)+instance GObject DeviceProviderFactory where+class GObject o => DeviceProviderFactoryK o+instance (GObject o, IsDescendantOf DeviceProviderFactory o) => DeviceProviderFactoryK o+data DeviceProviderFactoryGetMethodInfo+data DeviceProviderFactoryGetDeviceProviderTypeMethodInfo+data DeviceProviderFactoryGetMetadataMethodInfo+data DeviceProviderFactoryGetMetadataKeysMethodInfo+data DeviceProviderFactoryHasClassesMethodInfo+data DeviceProviderFactoryHasClassesvMethodInfo
+ GI/Gst/Objects/Element.hs view
@@ -0,0 +1,2399 @@+++{- |+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.Objects.Element+    ( ++-- * Exported types+    Element(..)                             ,+    ElementK                                ,+    toElement                               ,+    noElement                               ,+++ -- * Methods+-- ** elementAbortState+    ElementAbortStateMethodInfo             ,+    elementAbortState                       ,+++-- ** elementAddPad+    ElementAddPadMethodInfo                 ,+    elementAddPad                           ,+++-- ** elementChangeState+    ElementChangeStateMethodInfo            ,+    elementChangeState                      ,+++-- ** elementContinueState+    ElementContinueStateMethodInfo          ,+    elementContinueState                    ,+++-- ** elementCreateAllPads+    ElementCreateAllPadsMethodInfo          ,+    elementCreateAllPads                    ,+++-- ** elementGetBaseTime+    ElementGetBaseTimeMethodInfo            ,+    elementGetBaseTime                      ,+++-- ** elementGetBus+    ElementGetBusMethodInfo                 ,+    elementGetBus                           ,+++-- ** elementGetClock+    ElementGetClockMethodInfo               ,+    elementGetClock                         ,+++-- ** elementGetCompatiblePad+    ElementGetCompatiblePadMethodInfo       ,+    elementGetCompatiblePad                 ,+++-- ** elementGetCompatiblePadTemplate+    ElementGetCompatiblePadTemplateMethodInfo,+    elementGetCompatiblePadTemplate         ,+++-- ** elementGetFactory+    ElementGetFactoryMethodInfo             ,+    elementGetFactory                       ,+++-- ** elementGetRequestPad+    ElementGetRequestPadMethodInfo          ,+    elementGetRequestPad                    ,+++-- ** elementGetStartTime+    ElementGetStartTimeMethodInfo           ,+    elementGetStartTime                     ,+++-- ** elementGetState+    ElementGetStateMethodInfo               ,+    elementGetState                         ,+++-- ** elementGetStaticPad+    ElementGetStaticPadMethodInfo           ,+    elementGetStaticPad                     ,+++-- ** elementIsLockedState+    ElementIsLockedStateMethodInfo          ,+    elementIsLockedState                    ,+++-- ** elementIteratePads+    ElementIteratePadsMethodInfo            ,+    elementIteratePads                      ,+++-- ** elementIterateSinkPads+    ElementIterateSinkPadsMethodInfo        ,+    elementIterateSinkPads                  ,+++-- ** elementIterateSrcPads+    ElementIterateSrcPadsMethodInfo         ,+    elementIterateSrcPads                   ,+++-- ** elementLink+    ElementLinkMethodInfo                   ,+    elementLink                             ,+++-- ** elementLinkFiltered+    ElementLinkFilteredMethodInfo           ,+    elementLinkFiltered                     ,+++-- ** elementLinkPads+    ElementLinkPadsMethodInfo               ,+    elementLinkPads                         ,+++-- ** elementLinkPadsFiltered+    ElementLinkPadsFilteredMethodInfo       ,+    elementLinkPadsFiltered                 ,+++-- ** elementLinkPadsFull+    ElementLinkPadsFullMethodInfo           ,+    elementLinkPadsFull                     ,+++-- ** elementLostState+    ElementLostStateMethodInfo              ,+    elementLostState                        ,+++-- ** elementMakeFromUri+    elementMakeFromUri                      ,+++-- ** elementMessageFull+    ElementMessageFullMethodInfo            ,+    elementMessageFull                      ,+++-- ** elementNoMorePads+    ElementNoMorePadsMethodInfo             ,+    elementNoMorePads                       ,+++-- ** elementPostMessage+    ElementPostMessageMethodInfo            ,+    elementPostMessage                      ,+++-- ** elementProvideClock+    ElementProvideClockMethodInfo           ,+    elementProvideClock                     ,+++-- ** elementQuery+    ElementQueryMethodInfo                  ,+    elementQuery                            ,+++-- ** elementQueryConvert+    ElementQueryConvertMethodInfo           ,+    elementQueryConvert                     ,+++-- ** elementQueryDuration+    ElementQueryDurationMethodInfo          ,+    elementQueryDuration                    ,+++-- ** elementQueryPosition+    ElementQueryPositionMethodInfo          ,+    elementQueryPosition                    ,+++-- ** elementRegister+    elementRegister                         ,+++-- ** elementReleaseRequestPad+    ElementReleaseRequestPadMethodInfo      ,+    elementReleaseRequestPad                ,+++-- ** elementRemovePad+    ElementRemovePadMethodInfo              ,+    elementRemovePad                        ,+++-- ** elementRequestPad+    ElementRequestPadMethodInfo             ,+    elementRequestPad                       ,+++-- ** elementSeek+    ElementSeekMethodInfo                   ,+    elementSeek                             ,+++-- ** elementSeekSimple+    ElementSeekSimpleMethodInfo             ,+    elementSeekSimple                       ,+++-- ** elementSendEvent+    ElementSendEventMethodInfo              ,+    elementSendEvent                        ,+++-- ** elementSetBaseTime+    ElementSetBaseTimeMethodInfo            ,+    elementSetBaseTime                      ,+++-- ** elementSetBus+    ElementSetBusMethodInfo                 ,+    elementSetBus                           ,+++-- ** elementSetClock+    ElementSetClockMethodInfo               ,+    elementSetClock                         ,+++-- ** elementSetContext+    ElementSetContextMethodInfo             ,+    elementSetContext                       ,+++-- ** elementSetLockedState+    ElementSetLockedStateMethodInfo         ,+    elementSetLockedState                   ,+++-- ** elementSetStartTime+    ElementSetStartTimeMethodInfo           ,+    elementSetStartTime                     ,+++-- ** elementSetState+    ElementSetStateMethodInfo               ,+    elementSetState                         ,+++-- ** elementStateChangeReturnGetName+    elementStateChangeReturnGetName         ,+++-- ** elementStateGetName+    elementStateGetName                     ,+++-- ** elementSyncStateWithParent+    ElementSyncStateWithParentMethodInfo    ,+    elementSyncStateWithParent              ,+++-- ** elementUnlink+    ElementUnlinkMethodInfo                 ,+    elementUnlink                           ,+++-- ** elementUnlinkPads+    ElementUnlinkPadsMethodInfo             ,+    elementUnlinkPads                       ,+++++ -- * Signals+-- ** NoMorePads+    ElementNoMorePadsCallback               ,+    ElementNoMorePadsCallbackC              ,+    ElementNoMorePadsSignalInfo             ,+    afterElementNoMorePads                  ,+    elementNoMorePadsCallbackWrapper        ,+    elementNoMorePadsClosure                ,+    mkElementNoMorePadsCallback             ,+    noElementNoMorePadsCallback             ,+    onElementNoMorePads                     ,+++-- ** PadAdded+    ElementPadAddedCallback                 ,+    ElementPadAddedCallbackC                ,+    ElementPadAddedSignalInfo               ,+    afterElementPadAdded                    ,+    elementPadAddedCallbackWrapper          ,+    elementPadAddedClosure                  ,+    mkElementPadAddedCallback               ,+    noElementPadAddedCallback               ,+    onElementPadAdded                       ,+++-- ** PadRemoved+    ElementPadRemovedCallback               ,+    ElementPadRemovedCallbackC              ,+    ElementPadRemovedSignalInfo             ,+    afterElementPadRemoved                  ,+    elementPadRemovedCallbackWrapper        ,+    elementPadRemovedClosure                ,+    mkElementPadRemovedCallback             ,+    noElementPadRemovedCallback             ,+    onElementPadRemoved                     ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Element = Element (ForeignPtr Element)+foreign import ccall "gst_element_get_type"+    c_gst_element_get_type :: IO GType++type instance ParentTypes Element = ElementParentTypes+type ElementParentTypes = '[Object, GObject.Object]++instance GObject Element where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_element_get_type+    ++class GObject o => ElementK o+instance (GObject o, IsDescendantOf Element o) => ElementK o++toElement :: ElementK o => o -> IO Element+toElement = unsafeCastTo Element++noElement :: Maybe Element+noElement = Nothing++type family ResolveElementMethod (t :: Symbol) (o :: *) :: * where+    ResolveElementMethod "abortState" o = ElementAbortStateMethodInfo+    ResolveElementMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveElementMethod "addPad" o = ElementAddPadMethodInfo+    ResolveElementMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveElementMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveElementMethod "changeState" o = ElementChangeStateMethodInfo+    ResolveElementMethod "continueState" o = ElementContinueStateMethodInfo+    ResolveElementMethod "createAllPads" o = ElementCreateAllPadsMethodInfo+    ResolveElementMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveElementMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveElementMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveElementMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveElementMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveElementMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveElementMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveElementMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveElementMethod "isLockedState" o = ElementIsLockedStateMethodInfo+    ResolveElementMethod "iteratePads" o = ElementIteratePadsMethodInfo+    ResolveElementMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo+    ResolveElementMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo+    ResolveElementMethod "link" o = ElementLinkMethodInfo+    ResolveElementMethod "linkFiltered" o = ElementLinkFilteredMethodInfo+    ResolveElementMethod "linkPads" o = ElementLinkPadsMethodInfo+    ResolveElementMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo+    ResolveElementMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo+    ResolveElementMethod "lostState" o = ElementLostStateMethodInfo+    ResolveElementMethod "messageFull" o = ElementMessageFullMethodInfo+    ResolveElementMethod "noMorePads" o = ElementNoMorePadsMethodInfo+    ResolveElementMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveElementMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveElementMethod "postMessage" o = ElementPostMessageMethodInfo+    ResolveElementMethod "provideClock" o = ElementProvideClockMethodInfo+    ResolveElementMethod "query" o = ElementQueryMethodInfo+    ResolveElementMethod "queryConvert" o = ElementQueryConvertMethodInfo+    ResolveElementMethod "queryDuration" o = ElementQueryDurationMethodInfo+    ResolveElementMethod "queryPosition" o = ElementQueryPositionMethodInfo+    ResolveElementMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveElementMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo+    ResolveElementMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveElementMethod "removePad" o = ElementRemovePadMethodInfo+    ResolveElementMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveElementMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveElementMethod "requestPad" o = ElementRequestPadMethodInfo+    ResolveElementMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveElementMethod "seek" o = ElementSeekMethodInfo+    ResolveElementMethod "seekSimple" o = ElementSeekSimpleMethodInfo+    ResolveElementMethod "sendEvent" o = ElementSendEventMethodInfo+    ResolveElementMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveElementMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveElementMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveElementMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo+    ResolveElementMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveElementMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveElementMethod "unlink" o = ElementUnlinkMethodInfo+    ResolveElementMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo+    ResolveElementMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveElementMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveElementMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo+    ResolveElementMethod "getBus" o = ElementGetBusMethodInfo+    ResolveElementMethod "getClock" o = ElementGetClockMethodInfo+    ResolveElementMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo+    ResolveElementMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo+    ResolveElementMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveElementMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveElementMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveElementMethod "getFactory" o = ElementGetFactoryMethodInfo+    ResolveElementMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveElementMethod "getName" o = ObjectGetNameMethodInfo+    ResolveElementMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveElementMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveElementMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveElementMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveElementMethod "getRequestPad" o = ElementGetRequestPadMethodInfo+    ResolveElementMethod "getStartTime" o = ElementGetStartTimeMethodInfo+    ResolveElementMethod "getState" o = ElementGetStateMethodInfo+    ResolveElementMethod "getStaticPad" o = ElementGetStaticPadMethodInfo+    ResolveElementMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveElementMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveElementMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo+    ResolveElementMethod "setBus" o = ElementSetBusMethodInfo+    ResolveElementMethod "setClock" o = ElementSetClockMethodInfo+    ResolveElementMethod "setContext" o = ElementSetContextMethodInfo+    ResolveElementMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveElementMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveElementMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveElementMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveElementMethod "setLockedState" o = ElementSetLockedStateMethodInfo+    ResolveElementMethod "setName" o = ObjectSetNameMethodInfo+    ResolveElementMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveElementMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveElementMethod "setStartTime" o = ElementSetStartTimeMethodInfo+    ResolveElementMethod "setState" o = ElementSetStateMethodInfo+    ResolveElementMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveElementMethod t Element, MethodInfo info Element p) => IsLabelProxy t (Element -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveElementMethod t Element, MethodInfo info Element p) => IsLabel t (Element -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Element::no-more-pads+type ElementNoMorePadsCallback =+    IO ()++noElementNoMorePadsCallback :: Maybe ElementNoMorePadsCallback+noElementNoMorePadsCallback = Nothing++type ElementNoMorePadsCallbackC =+    Ptr () ->                               -- object+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkElementNoMorePadsCallback :: ElementNoMorePadsCallbackC -> IO (FunPtr ElementNoMorePadsCallbackC)++elementNoMorePadsClosure :: ElementNoMorePadsCallback -> IO Closure+elementNoMorePadsClosure cb = newCClosure =<< mkElementNoMorePadsCallback wrapped+    where wrapped = elementNoMorePadsCallbackWrapper cb++elementNoMorePadsCallbackWrapper ::+    ElementNoMorePadsCallback ->+    Ptr () ->+    Ptr () ->+    IO ()+elementNoMorePadsCallbackWrapper _cb _ _ = do+    _cb ++onElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId+onElementNoMorePads obj cb = liftIO $ connectElementNoMorePads obj cb SignalConnectBefore+afterElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId+afterElementNoMorePads obj cb = connectElementNoMorePads obj cb SignalConnectAfter++connectElementNoMorePads :: (GObject a, MonadIO m) =>+                            a -> ElementNoMorePadsCallback -> SignalConnectMode -> m SignalHandlerId+connectElementNoMorePads obj cb after = liftIO $ do+    cb' <- mkElementNoMorePadsCallback (elementNoMorePadsCallbackWrapper cb)+    connectSignalFunPtr obj "no-more-pads" cb' after++-- signal Element::pad-added+type ElementPadAddedCallback =+    Pad ->+    IO ()++noElementPadAddedCallback :: Maybe ElementPadAddedCallback+noElementPadAddedCallback = Nothing++type ElementPadAddedCallbackC =+    Ptr () ->                               -- object+    Ptr Pad ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkElementPadAddedCallback :: ElementPadAddedCallbackC -> IO (FunPtr ElementPadAddedCallbackC)++elementPadAddedClosure :: ElementPadAddedCallback -> IO Closure+elementPadAddedClosure cb = newCClosure =<< mkElementPadAddedCallback wrapped+    where wrapped = elementPadAddedCallbackWrapper cb++elementPadAddedCallbackWrapper ::+    ElementPadAddedCallback ->+    Ptr () ->+    Ptr Pad ->+    Ptr () ->+    IO ()+elementPadAddedCallbackWrapper _cb _ newPad _ = do+    newPad' <- (newObject Pad) newPad+    _cb  newPad'++onElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId+onElementPadAdded obj cb = liftIO $ connectElementPadAdded obj cb SignalConnectBefore+afterElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId+afterElementPadAdded obj cb = connectElementPadAdded obj cb SignalConnectAfter++connectElementPadAdded :: (GObject a, MonadIO m) =>+                          a -> ElementPadAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectElementPadAdded obj cb after = liftIO $ do+    cb' <- mkElementPadAddedCallback (elementPadAddedCallbackWrapper cb)+    connectSignalFunPtr obj "pad-added" cb' after++-- signal Element::pad-removed+type ElementPadRemovedCallback =+    Pad ->+    IO ()++noElementPadRemovedCallback :: Maybe ElementPadRemovedCallback+noElementPadRemovedCallback = Nothing++type ElementPadRemovedCallbackC =+    Ptr () ->                               -- object+    Ptr Pad ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkElementPadRemovedCallback :: ElementPadRemovedCallbackC -> IO (FunPtr ElementPadRemovedCallbackC)++elementPadRemovedClosure :: ElementPadRemovedCallback -> IO Closure+elementPadRemovedClosure cb = newCClosure =<< mkElementPadRemovedCallback wrapped+    where wrapped = elementPadRemovedCallbackWrapper cb++elementPadRemovedCallbackWrapper ::+    ElementPadRemovedCallback ->+    Ptr () ->+    Ptr Pad ->+    Ptr () ->+    IO ()+elementPadRemovedCallbackWrapper _cb _ oldPad _ = do+    oldPad' <- (newObject Pad) oldPad+    _cb  oldPad'++onElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId+onElementPadRemoved obj cb = liftIO $ connectElementPadRemoved obj cb SignalConnectBefore+afterElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId+afterElementPadRemoved obj cb = connectElementPadRemoved obj cb SignalConnectAfter++connectElementPadRemoved :: (GObject a, MonadIO m) =>+                            a -> ElementPadRemovedCallback -> SignalConnectMode -> m SignalHandlerId+connectElementPadRemoved obj cb after = liftIO $ do+    cb' <- mkElementPadRemovedCallback (elementPadRemovedCallbackWrapper cb)+    connectSignalFunPtr obj "pad-removed" cb' after++type instance AttributeList Element = ElementAttributeList+type ElementAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++data ElementNoMorePadsSignalInfo+instance SignalInfo ElementNoMorePadsSignalInfo where+    type HaskellCallbackType ElementNoMorePadsSignalInfo = ElementNoMorePadsCallback+    connectSignal _ = connectElementNoMorePads++data ElementPadAddedSignalInfo+instance SignalInfo ElementPadAddedSignalInfo where+    type HaskellCallbackType ElementPadAddedSignalInfo = ElementPadAddedCallback+    connectSignal _ = connectElementPadAdded++data ElementPadRemovedSignalInfo+instance SignalInfo ElementPadRemovedSignalInfo where+    type HaskellCallbackType ElementPadRemovedSignalInfo = ElementPadRemovedCallback+    connectSignal _ = connectElementPadRemoved++type instance SignalList Element = ElementSignalList+type ElementSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++-- method Element::abort_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_abort_state" gst_element_abort_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO ()+++elementAbortState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+elementAbortState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_element_abort_state _obj'+    touchManagedPtr _obj+    return ()++data ElementAbortStateMethodInfo+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementAbortStateMethodInfo a signature where+    overloadedMethod _ = elementAbortState++-- method Element::add_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_add_pad" gst_element_add_pad :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    IO CInt+++elementAddPad ::+    (MonadIO m, ElementK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- pad+    -> m Bool                               -- result+elementAddPad _obj pad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    pad' <- refObject pad+    result <- gst_element_add_pad _obj' pad'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr pad+    return result'++data ElementAddPadMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, PadK b) => MethodInfo ElementAddPadMethodInfo a signature where+    overloadedMethod _ = elementAddPad++-- method Element::change_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "transition", argType = TInterface "Gst" "StateChange", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "StateChangeReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_change_state" gst_element_change_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CUInt ->                                -- transition : TInterface "Gst" "StateChange"+    IO CUInt+++elementChangeState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> StateChange                          -- transition+    -> m StateChangeReturn                  -- result+elementChangeState _obj transition = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let transition' = (fromIntegral . fromEnum) transition+    result <- gst_element_change_state _obj' transition'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data ElementChangeStateMethodInfo+instance (signature ~ (StateChange -> m StateChangeReturn), MonadIO m, ElementK a) => MethodInfo ElementChangeStateMethodInfo a signature where+    overloadedMethod _ = elementChangeState++-- method Element::continue_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ret", argType = TInterface "Gst" "StateChangeReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "StateChangeReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_continue_state" gst_element_continue_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CUInt ->                                -- ret : TInterface "Gst" "StateChangeReturn"+    IO CUInt+++elementContinueState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> StateChangeReturn                    -- ret+    -> m StateChangeReturn                  -- result+elementContinueState _obj ret = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let ret' = (fromIntegral . fromEnum) ret+    result <- gst_element_continue_state _obj' ret'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data ElementContinueStateMethodInfo+instance (signature ~ (StateChangeReturn -> m StateChangeReturn), MonadIO m, ElementK a) => MethodInfo ElementContinueStateMethodInfo a signature where+    overloadedMethod _ = elementContinueState++-- method Element::create_all_pads+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_create_all_pads" gst_element_create_all_pads :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO ()+++elementCreateAllPads ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+elementCreateAllPads _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_element_create_all_pads _obj'+    touchManagedPtr _obj+    return ()++data ElementCreateAllPadsMethodInfo+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementCreateAllPadsMethodInfo a signature where+    overloadedMethod _ = elementCreateAllPads++-- method Element::get_base_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_base_time" gst_element_get_base_time :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO Word64+++elementGetBaseTime ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+elementGetBaseTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_get_base_time _obj'+    touchManagedPtr _obj+    return result++data ElementGetBaseTimeMethodInfo+instance (signature ~ (m Word64), MonadIO m, ElementK a) => MethodInfo ElementGetBaseTimeMethodInfo a signature where+    overloadedMethod _ = elementGetBaseTime++-- method Element::get_bus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Bus"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_bus" gst_element_get_bus :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO (Ptr Bus)+++elementGetBus ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Bus                                -- result+elementGetBus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_get_bus _obj'+    checkUnexpectedReturnNULL "gst_element_get_bus" result+    result' <- (wrapObject Bus) result+    touchManagedPtr _obj+    return result'++data ElementGetBusMethodInfo+instance (signature ~ (m Bus), MonadIO m, ElementK a) => MethodInfo ElementGetBusMethodInfo a signature where+    overloadedMethod _ = elementGetBus++-- method Element::get_clock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Clock"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_clock" gst_element_get_clock :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO (Ptr Clock)+++elementGetClock ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Clock                              -- result+elementGetClock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_get_clock _obj'+    checkUnexpectedReturnNULL "gst_element_get_clock" result+    result' <- (wrapObject Clock) result+    touchManagedPtr _obj+    return result'++data ElementGetClockMethodInfo+instance (signature ~ (m Clock), MonadIO m, ElementK a) => MethodInfo ElementGetClockMethodInfo a signature where+    overloadedMethod _ = elementGetClock++-- method Element::get_compatible_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_compatible_pad" gst_element_get_compatible_pad :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO (Ptr Pad)+++elementGetCompatiblePad ::+    (MonadIO m, ElementK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- pad+    -> Maybe (Caps)                         -- caps+    -> m Pad                                -- result+elementGetCompatiblePad _obj pad caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pad' = unsafeManagedPtrCastPtr pad+    maybeCaps <- case caps of+        Nothing -> return nullPtr+        Just jCaps -> do+            let jCaps' = unsafeManagedPtrGetPtr jCaps+            return jCaps'+    result <- gst_element_get_compatible_pad _obj' pad' maybeCaps+    checkUnexpectedReturnNULL "gst_element_get_compatible_pad" result+    result' <- (wrapObject Pad) result+    touchManagedPtr _obj+    touchManagedPtr pad+    whenJust caps touchManagedPtr+    return result'++data ElementGetCompatiblePadMethodInfo+instance (signature ~ (b -> Maybe (Caps) -> m Pad), MonadIO m, ElementK a, PadK b) => MethodInfo ElementGetCompatiblePadMethodInfo a signature where+    overloadedMethod _ = elementGetCompatiblePad++-- method Element::get_compatible_pad_template+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "compattempl", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadTemplate"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_compatible_pad_template" gst_element_get_compatible_pad_template :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr PadTemplate ->                      -- compattempl : TInterface "Gst" "PadTemplate"+    IO (Ptr PadTemplate)+++elementGetCompatiblePadTemplate ::+    (MonadIO m, ElementK a, PadTemplateK b) =>+    a                                       -- _obj+    -> b                                    -- compattempl+    -> m PadTemplate                        -- result+elementGetCompatiblePadTemplate _obj compattempl = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let compattempl' = unsafeManagedPtrCastPtr compattempl+    result <- gst_element_get_compatible_pad_template _obj' compattempl'+    checkUnexpectedReturnNULL "gst_element_get_compatible_pad_template" result+    result' <- (newObject PadTemplate) result+    touchManagedPtr _obj+    touchManagedPtr compattempl+    return result'++data ElementGetCompatiblePadTemplateMethodInfo+instance (signature ~ (b -> m PadTemplate), MonadIO m, ElementK a, PadTemplateK b) => MethodInfo ElementGetCompatiblePadTemplateMethodInfo a signature where+    overloadedMethod _ = elementGetCompatiblePadTemplate++-- method Element::get_factory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "ElementFactory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_factory" gst_element_get_factory :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO (Ptr ElementFactory)+++elementGetFactory ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m ElementFactory                     -- result+elementGetFactory _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_get_factory _obj'+    checkUnexpectedReturnNULL "gst_element_get_factory" result+    result' <- (newObject ElementFactory) result+    touchManagedPtr _obj+    return result'++data ElementGetFactoryMethodInfo+instance (signature ~ (m ElementFactory), MonadIO m, ElementK a) => MethodInfo ElementGetFactoryMethodInfo a signature where+    overloadedMethod _ = elementGetFactory++-- method Element::get_request_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_request_pad" gst_element_get_request_pad :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Pad)+++elementGetRequestPad ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Pad                                -- result+elementGetRequestPad _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_element_get_request_pad _obj' name'+    checkUnexpectedReturnNULL "gst_element_get_request_pad" result+    result' <- (wrapObject Pad) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data ElementGetRequestPadMethodInfo+instance (signature ~ (T.Text -> m Pad), MonadIO m, ElementK a) => MethodInfo ElementGetRequestPadMethodInfo a signature where+    overloadedMethod _ = elementGetRequestPad++-- method Element::get_start_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_start_time" gst_element_get_start_time :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO Word64+++elementGetStartTime ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+elementGetStartTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_get_start_time _obj'+    touchManagedPtr _obj+    return result++data ElementGetStartTimeMethodInfo+instance (signature ~ (m Word64), MonadIO m, ElementK a) => MethodInfo ElementGetStartTimeMethodInfo a signature where+    overloadedMethod _ = elementGetStartTime++-- method Element::get_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pending", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "StateChangeReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_state" gst_element_get_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr CUInt ->                            -- state : TInterface "Gst" "State"+    Ptr CUInt ->                            -- pending : TInterface "Gst" "State"+    Word64 ->                               -- timeout : TBasicType TUInt64+    IO CUInt+++elementGetState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Word64                               -- timeout+    -> m (StateChangeReturn,State,State)    -- result+elementGetState _obj timeout = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    state <- allocMem :: IO (Ptr CUInt)+    pending <- allocMem :: IO (Ptr CUInt)+    result <- gst_element_get_state _obj' state pending timeout+    let result' = (toEnum . fromIntegral) result+    state' <- peek state+    let state'' = (toEnum . fromIntegral) state'+    pending' <- peek pending+    let pending'' = (toEnum . fromIntegral) pending'+    touchManagedPtr _obj+    freeMem state+    freeMem pending+    return (result', state'', pending'')++data ElementGetStateMethodInfo+instance (signature ~ (Word64 -> m (StateChangeReturn,State,State)), MonadIO m, ElementK a) => MethodInfo ElementGetStateMethodInfo a signature where+    overloadedMethod _ = elementGetState++-- method Element::get_static_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_get_static_pad" gst_element_get_static_pad :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Pad)+++elementGetStaticPad ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Pad                                -- result+elementGetStaticPad _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_element_get_static_pad _obj' name'+    checkUnexpectedReturnNULL "gst_element_get_static_pad" result+    result' <- (wrapObject Pad) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data ElementGetStaticPadMethodInfo+instance (signature ~ (T.Text -> m Pad), MonadIO m, ElementK a) => MethodInfo ElementGetStaticPadMethodInfo a signature where+    overloadedMethod _ = elementGetStaticPad++-- method Element::is_locked_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_is_locked_state" gst_element_is_locked_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO CInt+++elementIsLockedState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+elementIsLockedState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_is_locked_state _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ElementIsLockedStateMethodInfo+instance (signature ~ (m Bool), MonadIO m, ElementK a) => MethodInfo ElementIsLockedStateMethodInfo a signature where+    overloadedMethod _ = elementIsLockedState++-- method Element::iterate_pads+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_iterate_pads" gst_element_iterate_pads :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO (Ptr Iterator)+++elementIteratePads ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+elementIteratePads _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_iterate_pads _obj'+    checkUnexpectedReturnNULL "gst_element_iterate_pads" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data ElementIteratePadsMethodInfo+instance (signature ~ (m Iterator), MonadIO m, ElementK a) => MethodInfo ElementIteratePadsMethodInfo a signature where+    overloadedMethod _ = elementIteratePads++-- method Element::iterate_sink_pads+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_iterate_sink_pads" gst_element_iterate_sink_pads :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO (Ptr Iterator)+++elementIterateSinkPads ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+elementIterateSinkPads _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_iterate_sink_pads _obj'+    checkUnexpectedReturnNULL "gst_element_iterate_sink_pads" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data ElementIterateSinkPadsMethodInfo+instance (signature ~ (m Iterator), MonadIO m, ElementK a) => MethodInfo ElementIterateSinkPadsMethodInfo a signature where+    overloadedMethod _ = elementIterateSinkPads++-- method Element::iterate_src_pads+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_iterate_src_pads" gst_element_iterate_src_pads :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO (Ptr Iterator)+++elementIterateSrcPads ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+elementIterateSrcPads _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_iterate_src_pads _obj'+    checkUnexpectedReturnNULL "gst_element_iterate_src_pads" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data ElementIterateSrcPadsMethodInfo+instance (signature ~ (m Iterator), MonadIO m, ElementK a) => MethodInfo ElementIterateSrcPadsMethodInfo a signature where+    overloadedMethod _ = elementIterateSrcPads++-- method Element::link+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_link" gst_element_link :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"+    IO CInt+++elementLink ::+    (MonadIO m, ElementK a, ElementK b) =>+    a                                       -- _obj+    -> b                                    -- dest+    -> m Bool                               -- result+elementLink _obj dest = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let dest' = unsafeManagedPtrCastPtr dest+    result <- gst_element_link _obj' dest'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr dest+    return result'++data ElementLinkMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkMethodInfo a signature where+    overloadedMethod _ = elementLink++-- method Element::link_filtered+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_link_filtered" gst_element_link_filtered :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"+    IO CInt+++elementLinkFiltered ::+    (MonadIO m, ElementK a, ElementK b) =>+    a                                       -- _obj+    -> b                                    -- dest+    -> Maybe (Caps)                         -- filter+    -> m Bool                               -- result+elementLinkFiltered _obj dest filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let dest' = unsafeManagedPtrCastPtr dest+    maybeFilter <- case filter of+        Nothing -> return nullPtr+        Just jFilter -> do+            let jFilter' = unsafeManagedPtrGetPtr jFilter+            return jFilter'+    result <- gst_element_link_filtered _obj' dest' maybeFilter+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr dest+    whenJust filter touchManagedPtr+    return result'++data ElementLinkFilteredMethodInfo+instance (signature ~ (b -> Maybe (Caps) -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkFilteredMethodInfo a signature where+    overloadedMethod _ = elementLinkFiltered++-- method Element::link_pads+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_link_pads" gst_element_link_pads :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CString ->                              -- srcpadname : TBasicType TUTF8+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"+    CString ->                              -- destpadname : TBasicType TUTF8+    IO CInt+++elementLinkPads ::+    (MonadIO m, ElementK a, ElementK b) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- srcpadname+    -> b                                    -- dest+    -> Maybe (T.Text)                       -- destpadname+    -> m Bool                               -- result+elementLinkPads _obj srcpadname dest destpadname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSrcpadname <- case srcpadname of+        Nothing -> return nullPtr+        Just jSrcpadname -> do+            jSrcpadname' <- textToCString jSrcpadname+            return jSrcpadname'+    let dest' = unsafeManagedPtrCastPtr dest+    maybeDestpadname <- case destpadname of+        Nothing -> return nullPtr+        Just jDestpadname -> do+            jDestpadname' <- textToCString jDestpadname+            return jDestpadname'+    result <- gst_element_link_pads _obj' maybeSrcpadname dest' maybeDestpadname+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr dest+    freeMem maybeSrcpadname+    freeMem maybeDestpadname+    return result'++data ElementLinkPadsMethodInfo+instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkPadsMethodInfo a signature where+    overloadedMethod _ = elementLinkPads++-- method Element::link_pads_filtered+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_link_pads_filtered" gst_element_link_pads_filtered :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CString ->                              -- srcpadname : TBasicType TUTF8+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"+    CString ->                              -- destpadname : TBasicType TUTF8+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"+    IO CInt+++elementLinkPadsFiltered ::+    (MonadIO m, ElementK a, ElementK b) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- srcpadname+    -> b                                    -- dest+    -> Maybe (T.Text)                       -- destpadname+    -> Maybe (Caps)                         -- filter+    -> m Bool                               -- result+elementLinkPadsFiltered _obj srcpadname dest destpadname filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSrcpadname <- case srcpadname of+        Nothing -> return nullPtr+        Just jSrcpadname -> do+            jSrcpadname' <- textToCString jSrcpadname+            return jSrcpadname'+    let dest' = unsafeManagedPtrCastPtr dest+    maybeDestpadname <- case destpadname of+        Nothing -> return nullPtr+        Just jDestpadname -> do+            jDestpadname' <- textToCString jDestpadname+            return jDestpadname'+    maybeFilter <- case filter of+        Nothing -> return nullPtr+        Just jFilter -> do+            let jFilter' = unsafeManagedPtrGetPtr jFilter+            return jFilter'+    result <- gst_element_link_pads_filtered _obj' maybeSrcpadname dest' maybeDestpadname maybeFilter+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr dest+    whenJust filter touchManagedPtr+    freeMem maybeSrcpadname+    freeMem maybeDestpadname+    return result'++data ElementLinkPadsFilteredMethodInfo+instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> Maybe (Caps) -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkPadsFilteredMethodInfo a signature where+    overloadedMethod _ = elementLinkPadsFiltered++-- method Element::link_pads_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PadLinkCheck", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_link_pads_full" gst_element_link_pads_full :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CString ->                              -- srcpadname : TBasicType TUTF8+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"+    CString ->                              -- destpadname : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gst" "PadLinkCheck"+    IO CInt+++elementLinkPadsFull ::+    (MonadIO m, ElementK a, ElementK b) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- srcpadname+    -> b                                    -- dest+    -> Maybe (T.Text)                       -- destpadname+    -> [PadLinkCheck]                       -- flags+    -> m Bool                               -- result+elementLinkPadsFull _obj srcpadname dest destpadname flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeSrcpadname <- case srcpadname of+        Nothing -> return nullPtr+        Just jSrcpadname -> do+            jSrcpadname' <- textToCString jSrcpadname+            return jSrcpadname'+    let dest' = unsafeManagedPtrCastPtr dest+    maybeDestpadname <- case destpadname of+        Nothing -> return nullPtr+        Just jDestpadname -> do+            jDestpadname' <- textToCString jDestpadname+            return jDestpadname'+    let flags' = gflagsToWord flags+    result <- gst_element_link_pads_full _obj' maybeSrcpadname dest' maybeDestpadname flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr dest+    freeMem maybeSrcpadname+    freeMem maybeDestpadname+    return result'++data ElementLinkPadsFullMethodInfo+instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> [PadLinkCheck] -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkPadsFullMethodInfo a signature where+    overloadedMethod _ = elementLinkPadsFull++-- method Element::lost_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_lost_state" gst_element_lost_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO ()+++elementLostState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+elementLostState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_element_lost_state _obj'+    touchManagedPtr _obj+    return ()++data ElementLostStateMethodInfo+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementLostStateMethodInfo a signature where+    overloadedMethod _ = elementLostState++-- method Element::message_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "function", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_message_full" gst_element_message_full :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CUInt ->                                -- type : TInterface "Gst" "MessageType"+    Word32 ->                               -- domain : TBasicType TUInt32+    Int32 ->                                -- code : TBasicType TInt32+    CString ->                              -- text : TBasicType TUTF8+    CString ->                              -- debug : TBasicType TUTF8+    CString ->                              -- file : TBasicType TUTF8+    CString ->                              -- function : TBasicType TUTF8+    Int32 ->                                -- line : TBasicType TInt32+    IO ()+++elementMessageFull ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> [MessageType]                        -- type_+    -> Word32                               -- domain+    -> Int32                                -- code+    -> Maybe (T.Text)                       -- text+    -> Maybe (T.Text)                       -- debug+    -> T.Text                               -- file+    -> T.Text                               -- function+    -> Int32                                -- line+    -> m ()                                 -- result+elementMessageFull _obj type_ domain code text debug file function line = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = gflagsToWord type_+    maybeText <- case text of+        Nothing -> return nullPtr+        Just jText -> do+            jText' <- textToCString jText+            return jText'+    maybeDebug <- case debug of+        Nothing -> return nullPtr+        Just jDebug -> do+            jDebug' <- textToCString jDebug+            return jDebug'+    file' <- textToCString file+    function' <- textToCString function+    gst_element_message_full _obj' type_' domain code maybeText maybeDebug file' function' line+    touchManagedPtr _obj+    freeMem file'+    freeMem function'+    return ()++data ElementMessageFullMethodInfo+instance (signature ~ ([MessageType] -> Word32 -> Int32 -> Maybe (T.Text) -> Maybe (T.Text) -> T.Text -> T.Text -> Int32 -> m ()), MonadIO m, ElementK a) => MethodInfo ElementMessageFullMethodInfo a signature where+    overloadedMethod _ = elementMessageFull++-- method Element::no_more_pads+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_no_more_pads" gst_element_no_more_pads :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO ()+++elementNoMorePads ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+elementNoMorePads _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_element_no_more_pads _obj'+    touchManagedPtr _obj+    return ()++data ElementNoMorePadsMethodInfo+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementNoMorePadsMethodInfo a signature where+    overloadedMethod _ = elementNoMorePads++-- method Element::post_message+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_post_message" gst_element_post_message :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Message ->                          -- message : TInterface "Gst" "Message"+    IO CInt+++elementPostMessage ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Message                              -- message+    -> m Bool                               -- result+elementPostMessage _obj message = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    message' <- copyBoxed message+    result <- gst_element_post_message _obj' message'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr message+    return result'++data ElementPostMessageMethodInfo+instance (signature ~ (Message -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementPostMessageMethodInfo a signature where+    overloadedMethod _ = elementPostMessage++-- method Element::provide_clock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Clock"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_provide_clock" gst_element_provide_clock :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO (Ptr Clock)+++elementProvideClock ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Clock                              -- result+elementProvideClock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_provide_clock _obj'+    checkUnexpectedReturnNULL "gst_element_provide_clock" result+    result' <- (wrapObject Clock) result+    touchManagedPtr _obj+    return result'++data ElementProvideClockMethodInfo+instance (signature ~ (m Clock), MonadIO m, ElementK a) => MethodInfo ElementProvideClockMethodInfo a signature where+    overloadedMethod _ = elementProvideClock++-- method Element::query+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_query" gst_element_query :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Query ->                            -- query : TInterface "Gst" "Query"+    IO CInt+++elementQuery ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Query                                -- query+    -> m Bool                               -- result+elementQuery _obj query = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_element_query _obj' query'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr query+    return result'++data ElementQueryMethodInfo+instance (signature ~ (Query -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementQueryMethodInfo a signature where+    overloadedMethod _ = elementQuery++-- method Element::query_convert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_query_convert" gst_element_query_convert :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr CUInt ->                            -- src_format : TInterface "Gst" "Format"+    Int64 ->                                -- src_val : TBasicType TInt64+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- dest_val : TBasicType TInt64+    IO CInt+++elementQueryConvert ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Format                               -- srcFormat+    -> Int64                                -- srcVal+    -> Format                               -- destFormat+    -> m (Bool,Format,Int64)                -- result+elementQueryConvert _obj srcFormat srcVal destFormat = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let srcFormat' = (fromIntegral . fromEnum) srcFormat+    srcFormat'' <- allocMem :: IO (Ptr CUInt)+    poke srcFormat'' srcFormat'+    let destFormat' = (fromIntegral . fromEnum) destFormat+    destVal <- allocMem :: IO (Ptr Int64)+    result <- gst_element_query_convert _obj' srcFormat'' srcVal destFormat' destVal+    let result' = (/= 0) result+    srcFormat''' <- peek srcFormat''+    let srcFormat'''' = (toEnum . fromIntegral) srcFormat'''+    destVal' <- peek destVal+    touchManagedPtr _obj+    freeMem srcFormat''+    freeMem destVal+    return (result', srcFormat'''', destVal')++data ElementQueryConvertMethodInfo+instance (signature ~ (Format -> Int64 -> Format -> m (Bool,Format,Int64)), MonadIO m, ElementK a) => MethodInfo ElementQueryConvertMethodInfo a signature where+    overloadedMethod _ = elementQueryConvert++-- method Element::query_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_query_duration" gst_element_query_duration :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- duration : TBasicType TInt64+    IO CInt+++elementQueryDuration ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Format                               -- format+    -> m (Bool,Int64)                       -- result+elementQueryDuration _obj format = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let format' = (fromIntegral . fromEnum) format+    duration <- allocMem :: IO (Ptr Int64)+    result <- gst_element_query_duration _obj' format' duration+    let result' = (/= 0) result+    duration' <- peek duration+    touchManagedPtr _obj+    freeMem duration+    return (result', duration')++data ElementQueryDurationMethodInfo+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, ElementK a) => MethodInfo ElementQueryDurationMethodInfo a signature where+    overloadedMethod _ = elementQueryDuration++-- method Element::query_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_query_position" gst_element_query_position :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- cur : TBasicType TInt64+    IO CInt+++elementQueryPosition ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Format                               -- format+    -> m (Bool,Int64)                       -- result+elementQueryPosition _obj format = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let format' = (fromIntegral . fromEnum) format+    cur <- allocMem :: IO (Ptr Int64)+    result <- gst_element_query_position _obj' format' cur+    let result' = (/= 0) result+    cur' <- peek cur+    touchManagedPtr _obj+    freeMem cur+    return (result', cur')++data ElementQueryPositionMethodInfo+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, ElementK a) => MethodInfo ElementQueryPositionMethodInfo a signature where+    overloadedMethod _ = elementQueryPosition++-- method Element::release_request_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_release_request_pad" gst_element_release_request_pad :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    IO ()+++elementReleaseRequestPad ::+    (MonadIO m, ElementK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- pad+    -> m ()                                 -- result+elementReleaseRequestPad _obj pad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pad' = unsafeManagedPtrCastPtr pad+    gst_element_release_request_pad _obj' pad'+    touchManagedPtr _obj+    touchManagedPtr pad+    return ()++data ElementReleaseRequestPadMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, ElementK a, PadK b) => MethodInfo ElementReleaseRequestPadMethodInfo a signature where+    overloadedMethod _ = elementReleaseRequestPad++-- method Element::remove_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_remove_pad" gst_element_remove_pad :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    IO CInt+++elementRemovePad ::+    (MonadIO m, ElementK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- pad+    -> m Bool                               -- result+elementRemovePad _obj pad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    pad' <- refObject pad+    result <- gst_element_remove_pad _obj' pad'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr pad+    return result'++data ElementRemovePadMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, PadK b) => MethodInfo ElementRemovePadMethodInfo a signature where+    overloadedMethod _ = elementRemovePad++-- method Element::request_pad+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_request_pad" gst_element_request_pad :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"+    CString ->                              -- name : TBasicType TUTF8+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO (Ptr Pad)+++elementRequestPad ::+    (MonadIO m, ElementK a, PadTemplateK b) =>+    a                                       -- _obj+    -> b                                    -- templ+    -> Maybe (T.Text)                       -- name+    -> Maybe (Caps)                         -- caps+    -> m Pad                                -- result+elementRequestPad _obj templ name caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let templ' = unsafeManagedPtrCastPtr templ+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    maybeCaps <- case caps of+        Nothing -> return nullPtr+        Just jCaps -> do+            let jCaps' = unsafeManagedPtrGetPtr jCaps+            return jCaps'+    result <- gst_element_request_pad _obj' templ' maybeName maybeCaps+    checkUnexpectedReturnNULL "gst_element_request_pad" result+    result' <- (wrapObject Pad) result+    touchManagedPtr _obj+    touchManagedPtr templ+    whenJust caps touchManagedPtr+    freeMem maybeName+    return result'++data ElementRequestPadMethodInfo+instance (signature ~ (b -> Maybe (T.Text) -> Maybe (Caps) -> m Pad), MonadIO m, ElementK a, PadTemplateK b) => MethodInfo ElementRequestPadMethodInfo a signature where+    overloadedMethod _ = elementRequestPad++-- method Element::seek+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_seek" gst_element_seek :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CDouble ->                              -- rate : TBasicType TDouble+    CUInt ->                                -- format : TInterface "Gst" "Format"+    CUInt ->                                -- flags : TInterface "Gst" "SeekFlags"+    CUInt ->                                -- start_type : TInterface "Gst" "SeekType"+    Int64 ->                                -- start : TBasicType TInt64+    CUInt ->                                -- stop_type : TInterface "Gst" "SeekType"+    Int64 ->                                -- stop : TBasicType TInt64+    IO CInt+++elementSeek ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Double                               -- rate+    -> Format                               -- format+    -> [SeekFlags]                          -- flags+    -> SeekType                             -- startType+    -> Int64                                -- start+    -> SeekType                             -- stopType+    -> Int64                                -- stop+    -> m Bool                               -- result+elementSeek _obj rate format flags startType start stopType stop = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let rate' = realToFrac rate+    let format' = (fromIntegral . fromEnum) format+    let flags' = gflagsToWord flags+    let startType' = (fromIntegral . fromEnum) startType+    let stopType' = (fromIntegral . fromEnum) stopType+    result <- gst_element_seek _obj' rate' format' flags' startType' start stopType' stop+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ElementSeekMethodInfo+instance (signature ~ (Double -> Format -> [SeekFlags] -> SeekType -> Int64 -> SeekType -> Int64 -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSeekMethodInfo a signature where+    overloadedMethod _ = elementSeek++-- method Element::seek_simple+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seek_flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seek_pos", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_seek_simple" gst_element_seek_simple :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    CUInt ->                                -- seek_flags : TInterface "Gst" "SeekFlags"+    Int64 ->                                -- seek_pos : TBasicType TInt64+    IO CInt+++elementSeekSimple ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Format                               -- format+    -> [SeekFlags]                          -- seekFlags+    -> Int64                                -- seekPos+    -> m Bool                               -- result+elementSeekSimple _obj format seekFlags seekPos = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let format' = (fromIntegral . fromEnum) format+    let seekFlags' = gflagsToWord seekFlags+    result <- gst_element_seek_simple _obj' format' seekFlags' seekPos+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ElementSeekSimpleMethodInfo+instance (signature ~ (Format -> [SeekFlags] -> Int64 -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSeekSimpleMethodInfo a signature where+    overloadedMethod _ = elementSeekSimple++-- method Element::send_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_send_event" gst_element_send_event :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Event ->                            -- event : TInterface "Gst" "Event"+    IO CInt+++elementSendEvent ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Event                                -- event+    -> m Bool                               -- result+elementSendEvent _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    event' <- copyBoxed event+    result <- gst_element_send_event _obj' event'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr event+    return result'++data ElementSendEventMethodInfo+instance (signature ~ (Event -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSendEventMethodInfo a signature where+    overloadedMethod _ = elementSendEvent++-- method Element::set_base_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_set_base_time" gst_element_set_base_time :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Word64 ->                               -- time : TBasicType TUInt64+    IO ()+++elementSetBaseTime ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Word64                               -- time+    -> m ()                                 -- result+elementSetBaseTime _obj time = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_element_set_base_time _obj' time+    touchManagedPtr _obj+    return ()++data ElementSetBaseTimeMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, ElementK a) => MethodInfo ElementSetBaseTimeMethodInfo a signature where+    overloadedMethod _ = elementSetBaseTime++-- method Element::set_bus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bus", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_set_bus" gst_element_set_bus :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Bus ->                              -- bus : TInterface "Gst" "Bus"+    IO ()+++elementSetBus ::+    (MonadIO m, ElementK a, BusK b) =>+    a                                       -- _obj+    -> b                                    -- bus+    -> m ()                                 -- result+elementSetBus _obj bus = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let bus' = unsafeManagedPtrCastPtr bus+    gst_element_set_bus _obj' bus'+    touchManagedPtr _obj+    touchManagedPtr bus+    return ()++data ElementSetBusMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, ElementK a, BusK b) => MethodInfo ElementSetBusMethodInfo a signature where+    overloadedMethod _ = elementSetBus++-- method Element::set_clock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_set_clock" gst_element_set_clock :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"+    IO CInt+++elementSetClock ::+    (MonadIO m, ElementK a, ClockK b) =>+    a                                       -- _obj+    -> b                                    -- clock+    -> m Bool                               -- result+elementSetClock _obj clock = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let clock' = unsafeManagedPtrCastPtr clock+    result <- gst_element_set_clock _obj' clock'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr clock+    return result'++data ElementSetClockMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, ClockK b) => MethodInfo ElementSetClockMethodInfo a signature where+    overloadedMethod _ = elementSetClock++-- method Element::set_context+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_set_context" gst_element_set_context :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Context ->                          -- context : TInterface "Gst" "Context"+    IO ()+++elementSetContext ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Context                              -- context+    -> m ()                                 -- result+elementSetContext _obj context = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let context' = unsafeManagedPtrGetPtr context+    gst_element_set_context _obj' context'+    touchManagedPtr _obj+    touchManagedPtr context+    return ()++data ElementSetContextMethodInfo+instance (signature ~ (Context -> m ()), MonadIO m, ElementK a) => MethodInfo ElementSetContextMethodInfo a signature where+    overloadedMethod _ = elementSetContext++-- method Element::set_locked_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "locked_state", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_set_locked_state" gst_element_set_locked_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CInt ->                                 -- locked_state : TBasicType TBoolean+    IO CInt+++elementSetLockedState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Bool                                 -- lockedState+    -> m Bool                               -- result+elementSetLockedState _obj lockedState = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let lockedState' = (fromIntegral . fromEnum) lockedState+    result <- gst_element_set_locked_state _obj' lockedState'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ElementSetLockedStateMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSetLockedStateMethodInfo a signature where+    overloadedMethod _ = elementSetLockedState++-- method Element::set_start_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_set_start_time" gst_element_set_start_time :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Word64 ->                               -- time : TBasicType TUInt64+    IO ()+++elementSetStartTime ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> Word64                               -- time+    -> m ()                                 -- result+elementSetStartTime _obj time = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_element_set_start_time _obj' time+    touchManagedPtr _obj+    return ()++data ElementSetStartTimeMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, ElementK a) => MethodInfo ElementSetStartTimeMethodInfo a signature where+    overloadedMethod _ = elementSetStartTime++-- method Element::set_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "StateChangeReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_set_state" gst_element_set_state :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CUInt ->                                -- state : TInterface "Gst" "State"+    IO CUInt+++elementSetState ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> State                                -- state+    -> m StateChangeReturn                  -- result+elementSetState _obj state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let state' = (fromIntegral . fromEnum) state+    result <- gst_element_set_state _obj' state'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data ElementSetStateMethodInfo+instance (signature ~ (State -> m StateChangeReturn), MonadIO m, ElementK a) => MethodInfo ElementSetStateMethodInfo a signature where+    overloadedMethod _ = elementSetState++-- method Element::sync_state_with_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_sync_state_with_parent" gst_element_sync_state_with_parent :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    IO CInt+++elementSyncStateWithParent ::+    (MonadIO m, ElementK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+elementSyncStateWithParent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_sync_state_with_parent _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ElementSyncStateWithParentMethodInfo+instance (signature ~ (m Bool), MonadIO m, ElementK a) => MethodInfo ElementSyncStateWithParentMethodInfo a signature where+    overloadedMethod _ = elementSyncStateWithParent++-- method Element::unlink+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_unlink" gst_element_unlink :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"+    IO ()+++elementUnlink ::+    (MonadIO m, ElementK a, ElementK b) =>+    a                                       -- _obj+    -> b                                    -- dest+    -> m ()                                 -- result+elementUnlink _obj dest = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let dest' = unsafeManagedPtrCastPtr dest+    gst_element_unlink _obj' dest'+    touchManagedPtr _obj+    touchManagedPtr dest+    return ()++data ElementUnlinkMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementUnlinkMethodInfo a signature where+    overloadedMethod _ = elementUnlink++-- method Element::unlink_pads+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_unlink_pads" gst_element_unlink_pads :: +    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"+    CString ->                              -- srcpadname : TBasicType TUTF8+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"+    CString ->                              -- destpadname : TBasicType TUTF8+    IO ()+++elementUnlinkPads ::+    (MonadIO m, ElementK a, ElementK b) =>+    a                                       -- _obj+    -> T.Text                               -- srcpadname+    -> b                                    -- dest+    -> T.Text                               -- destpadname+    -> m ()                                 -- result+elementUnlinkPads _obj srcpadname dest destpadname = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    srcpadname' <- textToCString srcpadname+    let dest' = unsafeManagedPtrCastPtr dest+    destpadname' <- textToCString destpadname+    gst_element_unlink_pads _obj' srcpadname' dest' destpadname'+    touchManagedPtr _obj+    touchManagedPtr dest+    freeMem srcpadname'+    freeMem destpadname'+    return ()++data ElementUnlinkPadsMethodInfo+instance (signature ~ (T.Text -> b -> T.Text -> m ()), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementUnlinkPadsMethodInfo a signature where+    overloadedMethod _ = elementUnlinkPads++-- method Element::make_from_uri+-- method type : MemberFunction+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "URIType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elementname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : True+-- Skip return : False++foreign import ccall "gst_element_make_from_uri" gst_element_make_from_uri :: +    CUInt ->                                -- type : TInterface "Gst" "URIType"+    CString ->                              -- uri : TBasicType TUTF8+    CString ->                              -- elementname : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Element)+++elementMakeFromUri ::+    (MonadIO m) =>+    URIType                                 -- type_+    -> T.Text                               -- uri+    -> Maybe (T.Text)                       -- elementname+    -> m Element                            -- result+elementMakeFromUri type_ uri elementname = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    uri' <- textToCString uri+    maybeElementname <- case elementname of+        Nothing -> return nullPtr+        Just jElementname -> do+            jElementname' <- textToCString jElementname+            return jElementname'+    onException (do+        result <- propagateGError $ gst_element_make_from_uri type_' uri' maybeElementname+        checkUnexpectedReturnNULL "gst_element_make_from_uri" result+        result' <- (newObject Element) result+        freeMem uri'+        freeMem maybeElementname+        return result'+     ) (do+        freeMem uri'+        freeMem maybeElementname+     )++-- method Element::register+-- method type : MemberFunction+-- Args : [Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_register" gst_element_register :: +    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"+    CString ->                              -- name : TBasicType TUTF8+    Word32 ->                               -- rank : TBasicType TUInt32+    CGType ->                               -- type : TBasicType TGType+    IO CInt+++elementRegister ::+    (MonadIO m, PluginK a) =>+    Maybe (a)                               -- plugin+    -> T.Text                               -- name+    -> Word32                               -- rank+    -> GType                                -- type_+    -> m Bool                               -- result+elementRegister plugin name rank type_ = liftIO $ do+    maybePlugin <- case plugin of+        Nothing -> return nullPtr+        Just jPlugin -> do+            let jPlugin' = unsafeManagedPtrCastPtr jPlugin+            return jPlugin'+    name' <- textToCString name+    let type_' = gtypeToCGType type_+    result <- gst_element_register maybePlugin name' rank type_'+    let result' = (/= 0) result+    whenJust plugin touchManagedPtr+    freeMem name'+    return result'++-- method Element::state_change_return_get_name+-- method type : MemberFunction+-- Args : [Arg {argCName = "state_ret", argType = TInterface "Gst" "StateChangeReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_state_change_return_get_name" gst_element_state_change_return_get_name :: +    CUInt ->                                -- state_ret : TInterface "Gst" "StateChangeReturn"+    IO CString+++elementStateChangeReturnGetName ::+    (MonadIO m) =>+    StateChangeReturn                       -- stateRet+    -> m T.Text                             -- result+elementStateChangeReturnGetName stateRet = liftIO $ do+    let stateRet' = (fromIntegral . fromEnum) stateRet+    result <- gst_element_state_change_return_get_name stateRet'+    checkUnexpectedReturnNULL "gst_element_state_change_return_get_name" result+    result' <- cstringToText result+    return result'++-- method Element::state_get_name+-- method type : MemberFunction+-- Args : [Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_state_get_name" gst_element_state_get_name :: +    CUInt ->                                -- state : TInterface "Gst" "State"+    IO CString+++elementStateGetName ::+    (MonadIO m) =>+    State                                   -- state+    -> m T.Text                             -- result+elementStateGetName state = liftIO $ do+    let state' = (fromIntegral . fromEnum) state+    result <- gst_element_state_get_name state'+    checkUnexpectedReturnNULL "gst_element_state_get_name" result+    result' <- cstringToText result+    return result'++
+ GI/Gst/Objects/Element.hs-boot view
@@ -0,0 +1,65 @@+module GI.Gst.Objects.Element 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++newtype Element = Element (ForeignPtr Element)+instance GObject Element where+class GObject o => ElementK o+instance (GObject o, IsDescendantOf Element o) => ElementK o+data ElementNoMorePadsSignalInfo+data ElementPadAddedSignalInfo+data ElementPadRemovedSignalInfo+data ElementAbortStateMethodInfo+data ElementAddPadMethodInfo+data ElementChangeStateMethodInfo+data ElementContinueStateMethodInfo+data ElementCreateAllPadsMethodInfo+data ElementGetBaseTimeMethodInfo+data ElementGetBusMethodInfo+data ElementGetClockMethodInfo+data ElementGetCompatiblePadMethodInfo+data ElementGetCompatiblePadTemplateMethodInfo+data ElementGetFactoryMethodInfo+data ElementGetRequestPadMethodInfo+data ElementGetStartTimeMethodInfo+data ElementGetStateMethodInfo+data ElementGetStaticPadMethodInfo+data ElementIsLockedStateMethodInfo+data ElementIteratePadsMethodInfo+data ElementIterateSinkPadsMethodInfo+data ElementIterateSrcPadsMethodInfo+data ElementLinkMethodInfo+data ElementLinkFilteredMethodInfo+data ElementLinkPadsMethodInfo+data ElementLinkPadsFilteredMethodInfo+data ElementLinkPadsFullMethodInfo+data ElementLostStateMethodInfo+data ElementMessageFullMethodInfo+data ElementNoMorePadsMethodInfo+data ElementPostMessageMethodInfo+data ElementProvideClockMethodInfo+data ElementQueryMethodInfo+data ElementQueryConvertMethodInfo+data ElementQueryDurationMethodInfo+data ElementQueryPositionMethodInfo+data ElementReleaseRequestPadMethodInfo+data ElementRemovePadMethodInfo+data ElementRequestPadMethodInfo+data ElementSeekMethodInfo+data ElementSeekSimpleMethodInfo+data ElementSendEventMethodInfo+data ElementSetBaseTimeMethodInfo+data ElementSetBusMethodInfo+data ElementSetClockMethodInfo+data ElementSetContextMethodInfo+data ElementSetLockedStateMethodInfo+data ElementSetStartTimeMethodInfo+data ElementSetStateMethodInfo+data ElementSyncStateWithParentMethodInfo+data ElementUnlinkMethodInfo+data ElementUnlinkPadsMethodInfo
+ GI/Gst/Objects/ElementFactory.hs view
@@ -0,0 +1,780 @@+++{- |+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.Objects.ElementFactory+    ( ++-- * Exported types+    ElementFactory(..)                      ,+    ElementFactoryK                         ,+    toElementFactory                        ,+    noElementFactory                        ,+++ -- * Methods+-- ** elementFactoryCanSinkAllCaps+    ElementFactoryCanSinkAllCapsMethodInfo  ,+    elementFactoryCanSinkAllCaps            ,+++-- ** elementFactoryCanSinkAnyCaps+    ElementFactoryCanSinkAnyCapsMethodInfo  ,+    elementFactoryCanSinkAnyCaps            ,+++-- ** elementFactoryCanSrcAllCaps+    ElementFactoryCanSrcAllCapsMethodInfo   ,+    elementFactoryCanSrcAllCaps             ,+++-- ** elementFactoryCanSrcAnyCaps+    ElementFactoryCanSrcAnyCapsMethodInfo   ,+    elementFactoryCanSrcAnyCaps             ,+++-- ** elementFactoryCreate+    ElementFactoryCreateMethodInfo          ,+    elementFactoryCreate                    ,+++-- ** elementFactoryFind+    elementFactoryFind                      ,+++-- ** elementFactoryGetElementType+    ElementFactoryGetElementTypeMethodInfo  ,+    elementFactoryGetElementType            ,+++-- ** elementFactoryGetMetadata+    ElementFactoryGetMetadataMethodInfo     ,+    elementFactoryGetMetadata               ,+++-- ** elementFactoryGetMetadataKeys+    ElementFactoryGetMetadataKeysMethodInfo ,+    elementFactoryGetMetadataKeys           ,+++-- ** elementFactoryGetNumPadTemplates+    ElementFactoryGetNumPadTemplatesMethodInfo,+    elementFactoryGetNumPadTemplates        ,+++-- ** elementFactoryGetStaticPadTemplates+    ElementFactoryGetStaticPadTemplatesMethodInfo,+    elementFactoryGetStaticPadTemplates     ,+++-- ** elementFactoryGetUriProtocols+    ElementFactoryGetUriProtocolsMethodInfo ,+    elementFactoryGetUriProtocols           ,+++-- ** elementFactoryGetUriType+    ElementFactoryGetUriTypeMethodInfo      ,+    elementFactoryGetUriType                ,+++-- ** elementFactoryHasInterface+    ElementFactoryHasInterfaceMethodInfo    ,+    elementFactoryHasInterface              ,+++-- ** elementFactoryListFilter+    elementFactoryListFilter                ,+++-- ** elementFactoryListGetElements+    elementFactoryListGetElements           ,+++-- ** elementFactoryListIsType+    ElementFactoryListIsTypeMethodInfo      ,+    elementFactoryListIsType                ,+++-- ** elementFactoryMake+    elementFactoryMake                      ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype ElementFactory = ElementFactory (ForeignPtr ElementFactory)+foreign import ccall "gst_element_factory_get_type"+    c_gst_element_factory_get_type :: IO GType++type instance ParentTypes ElementFactory = ElementFactoryParentTypes+type ElementFactoryParentTypes = '[PluginFeature, Object, GObject.Object]++instance GObject ElementFactory where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_element_factory_get_type+    ++class GObject o => ElementFactoryK o+instance (GObject o, IsDescendantOf ElementFactory o) => ElementFactoryK o++toElementFactory :: ElementFactoryK o => o -> IO ElementFactory+toElementFactory = unsafeCastTo ElementFactory++noElementFactory :: Maybe ElementFactory+noElementFactory = Nothing++type family ResolveElementFactoryMethod (t :: Symbol) (o :: *) :: * where+    ResolveElementFactoryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveElementFactoryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveElementFactoryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveElementFactoryMethod "canSinkAllCaps" o = ElementFactoryCanSinkAllCapsMethodInfo+    ResolveElementFactoryMethod "canSinkAnyCaps" o = ElementFactoryCanSinkAnyCapsMethodInfo+    ResolveElementFactoryMethod "canSrcAllCaps" o = ElementFactoryCanSrcAllCapsMethodInfo+    ResolveElementFactoryMethod "canSrcAnyCaps" o = ElementFactoryCanSrcAnyCapsMethodInfo+    ResolveElementFactoryMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo+    ResolveElementFactoryMethod "create" o = ElementFactoryCreateMethodInfo+    ResolveElementFactoryMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveElementFactoryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveElementFactoryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveElementFactoryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveElementFactoryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveElementFactoryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveElementFactoryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveElementFactoryMethod "hasInterface" o = ElementFactoryHasInterfaceMethodInfo+    ResolveElementFactoryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveElementFactoryMethod "listIsType" o = ElementFactoryListIsTypeMethodInfo+    ResolveElementFactoryMethod "load" o = PluginFeatureLoadMethodInfo+    ResolveElementFactoryMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveElementFactoryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveElementFactoryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveElementFactoryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveElementFactoryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveElementFactoryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveElementFactoryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveElementFactoryMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveElementFactoryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveElementFactoryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveElementFactoryMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveElementFactoryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveElementFactoryMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveElementFactoryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveElementFactoryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveElementFactoryMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveElementFactoryMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveElementFactoryMethod "getElementType" o = ElementFactoryGetElementTypeMethodInfo+    ResolveElementFactoryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveElementFactoryMethod "getMetadata" o = ElementFactoryGetMetadataMethodInfo+    ResolveElementFactoryMethod "getMetadataKeys" o = ElementFactoryGetMetadataKeysMethodInfo+    ResolveElementFactoryMethod "getName" o = ObjectGetNameMethodInfo+    ResolveElementFactoryMethod "getNumPadTemplates" o = ElementFactoryGetNumPadTemplatesMethodInfo+    ResolveElementFactoryMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveElementFactoryMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveElementFactoryMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo+    ResolveElementFactoryMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo+    ResolveElementFactoryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveElementFactoryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveElementFactoryMethod "getRank" o = PluginFeatureGetRankMethodInfo+    ResolveElementFactoryMethod "getStaticPadTemplates" o = ElementFactoryGetStaticPadTemplatesMethodInfo+    ResolveElementFactoryMethod "getUriProtocols" o = ElementFactoryGetUriProtocolsMethodInfo+    ResolveElementFactoryMethod "getUriType" o = ElementFactoryGetUriTypeMethodInfo+    ResolveElementFactoryMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveElementFactoryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveElementFactoryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveElementFactoryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveElementFactoryMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveElementFactoryMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveElementFactoryMethod "setName" o = ObjectSetNameMethodInfo+    ResolveElementFactoryMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveElementFactoryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveElementFactoryMethod "setRank" o = PluginFeatureSetRankMethodInfo+    ResolveElementFactoryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveElementFactoryMethod t ElementFactory, MethodInfo info ElementFactory p) => IsLabelProxy t (ElementFactory -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveElementFactoryMethod t ElementFactory, MethodInfo info ElementFactory p) => IsLabel t (ElementFactory -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList ElementFactory = ElementFactoryAttributeList+type ElementFactoryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList ElementFactory = ElementFactorySignalList+type ElementFactorySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method ElementFactory::can_sink_all_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_can_sink_all_caps" gst_element_factory_can_sink_all_caps :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO CInt+++elementFactoryCanSinkAllCaps ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> Caps                                 -- caps+    -> m Bool                               -- result+elementFactoryCanSinkAllCaps _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_element_factory_can_sink_all_caps _obj' caps'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps+    return result'++data ElementFactoryCanSinkAllCapsMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSinkAllCapsMethodInfo a signature where+    overloadedMethod _ = elementFactoryCanSinkAllCaps++-- method ElementFactory::can_sink_any_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_can_sink_any_caps" gst_element_factory_can_sink_any_caps :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO CInt+++elementFactoryCanSinkAnyCaps ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> Caps                                 -- caps+    -> m Bool                               -- result+elementFactoryCanSinkAnyCaps _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_element_factory_can_sink_any_caps _obj' caps'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps+    return result'++data ElementFactoryCanSinkAnyCapsMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSinkAnyCapsMethodInfo a signature where+    overloadedMethod _ = elementFactoryCanSinkAnyCaps++-- method ElementFactory::can_src_all_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_can_src_all_caps" gst_element_factory_can_src_all_caps :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO CInt+++elementFactoryCanSrcAllCaps ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> Caps                                 -- caps+    -> m Bool                               -- result+elementFactoryCanSrcAllCaps _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_element_factory_can_src_all_caps _obj' caps'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps+    return result'++data ElementFactoryCanSrcAllCapsMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSrcAllCapsMethodInfo a signature where+    overloadedMethod _ = elementFactoryCanSrcAllCaps++-- method ElementFactory::can_src_any_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_can_src_any_caps" gst_element_factory_can_src_any_caps :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO CInt+++elementFactoryCanSrcAnyCaps ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> Caps                                 -- caps+    -> m Bool                               -- result+elementFactoryCanSrcAnyCaps _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_element_factory_can_src_any_caps _obj' caps'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps+    return result'++data ElementFactoryCanSrcAnyCapsMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSrcAnyCapsMethodInfo a signature where+    overloadedMethod _ = elementFactoryCanSrcAnyCaps++-- method ElementFactory::create+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_create" gst_element_factory_create :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Element)+++elementFactoryCreate ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- name+    -> m Element                            -- result+elementFactoryCreate _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_element_factory_create _obj' maybeName+    checkUnexpectedReturnNULL "gst_element_factory_create" result+    result' <- (newObject Element) result+    touchManagedPtr _obj+    freeMem maybeName+    return result'++data ElementFactoryCreateMethodInfo+instance (signature ~ (Maybe (T.Text) -> m Element), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCreateMethodInfo a signature where+    overloadedMethod _ = elementFactoryCreate++-- method ElementFactory::get_element_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_get_element_type" gst_element_factory_get_element_type :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    IO CGType+++elementFactoryGetElementType ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> m GType                              -- result+elementFactoryGetElementType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_factory_get_element_type _obj'+    let result' = GType result+    touchManagedPtr _obj+    return result'++data ElementFactoryGetElementTypeMethodInfo+instance (signature ~ (m GType), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetElementTypeMethodInfo a signature where+    overloadedMethod _ = elementFactoryGetElementType++-- method ElementFactory::get_metadata+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_get_metadata" gst_element_factory_get_metadata :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    CString ->                              -- key : TBasicType TUTF8+    IO CString+++elementFactoryGetMetadata ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> T.Text                               -- key+    -> m T.Text                             -- result+elementFactoryGetMetadata _obj key = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    key' <- textToCString key+    result <- gst_element_factory_get_metadata _obj' key'+    checkUnexpectedReturnNULL "gst_element_factory_get_metadata" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem key'+    return result'++data ElementFactoryGetMetadataMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetMetadataMethodInfo a signature where+    overloadedMethod _ = elementFactoryGetMetadata++-- method ElementFactory::get_metadata_keys+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_get_metadata_keys" gst_element_factory_get_metadata_keys :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    IO (Ptr CString)+++elementFactoryGetMetadataKeys ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+elementFactoryGetMetadataKeys _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_factory_get_metadata_keys _obj'+    checkUnexpectedReturnNULL "gst_element_factory_get_metadata_keys" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++data ElementFactoryGetMetadataKeysMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetMetadataKeysMethodInfo a signature where+    overloadedMethod _ = elementFactoryGetMetadataKeys++-- method ElementFactory::get_num_pad_templates+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_get_num_pad_templates" gst_element_factory_get_num_pad_templates :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    IO Word32+++elementFactoryGetNumPadTemplates ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> m Word32                             -- result+elementFactoryGetNumPadTemplates _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_factory_get_num_pad_templates _obj'+    touchManagedPtr _obj+    return result++data ElementFactoryGetNumPadTemplatesMethodInfo+instance (signature ~ (m Word32), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetNumPadTemplatesMethodInfo a signature where+    overloadedMethod _ = elementFactoryGetNumPadTemplates++-- method ElementFactory::get_static_pad_templates+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "StaticPadTemplate")+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_get_static_pad_templates" gst_element_factory_get_static_pad_templates :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    IO (Ptr (GList (Ptr StaticPadTemplate)))+++elementFactoryGetStaticPadTemplates ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> m [StaticPadTemplate]                -- result+elementFactoryGetStaticPadTemplates _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_factory_get_static_pad_templates _obj'+    checkUnexpectedReturnNULL "gst_element_factory_get_static_pad_templates" result+    result' <- unpackGList result+    result'' <- mapM (newPtr 64 StaticPadTemplate) result'+    touchManagedPtr _obj+    return result''++data ElementFactoryGetStaticPadTemplatesMethodInfo+instance (signature ~ (m [StaticPadTemplate]), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetStaticPadTemplatesMethodInfo a signature where+    overloadedMethod _ = elementFactoryGetStaticPadTemplates++-- method ElementFactory::get_uri_protocols+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_get_uri_protocols" gst_element_factory_get_uri_protocols :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    IO (Ptr CString)+++elementFactoryGetUriProtocols ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+elementFactoryGetUriProtocols _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_factory_get_uri_protocols _obj'+    checkUnexpectedReturnNULL "gst_element_factory_get_uri_protocols" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++data ElementFactoryGetUriProtocolsMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetUriProtocolsMethodInfo a signature where+    overloadedMethod _ = elementFactoryGetUriProtocols++-- method ElementFactory::get_uri_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "URIType"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_get_uri_type" gst_element_factory_get_uri_type :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    IO CUInt+++elementFactoryGetUriType ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> m URIType                            -- result+elementFactoryGetUriType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_factory_get_uri_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data ElementFactoryGetUriTypeMethodInfo+instance (signature ~ (m URIType), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetUriTypeMethodInfo a signature where+    overloadedMethod _ = elementFactoryGetUriType++-- method ElementFactory::has_interface+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interfacename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_has_interface" gst_element_factory_has_interface :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    CString ->                              -- interfacename : TBasicType TUTF8+    IO CInt+++elementFactoryHasInterface ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> T.Text                               -- interfacename+    -> m Bool                               -- result+elementFactoryHasInterface _obj interfacename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    interfacename' <- textToCString interfacename+    result <- gst_element_factory_has_interface _obj' interfacename'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem interfacename'+    return result'++data ElementFactoryHasInterfaceMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryHasInterfaceMethodInfo a signature where+    overloadedMethod _ = elementFactoryHasInterface++-- method ElementFactory::list_is_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_list_is_type" gst_element_factory_list_is_type :: +    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"+    Word64 ->                               -- type : TBasicType TUInt64+    IO CInt+++elementFactoryListIsType ::+    (MonadIO m, ElementFactoryK a) =>+    a                                       -- _obj+    -> Word64                               -- type_+    -> m Bool                               -- result+elementFactoryListIsType _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_element_factory_list_is_type _obj' type_+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ElementFactoryListIsTypeMethodInfo+instance (signature ~ (Word64 -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryListIsTypeMethodInfo a signature where+    overloadedMethod _ = elementFactoryListIsType++-- method ElementFactory::find+-- method type : MemberFunction+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "ElementFactory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_find" gst_element_factory_find :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr ElementFactory)+++elementFactoryFind ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> m ElementFactory                     -- result+elementFactoryFind name = liftIO $ do+    name' <- textToCString name+    result <- gst_element_factory_find name'+    checkUnexpectedReturnNULL "gst_element_factory_find" result+    result' <- (wrapObject ElementFactory) result+    freeMem name'+    return result'++-- method ElementFactory::list_filter+-- method type : MemberFunction+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "ElementFactory"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subsetonly", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "ElementFactory")+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_list_filter" gst_element_factory_list_filter :: +    Ptr (GList (Ptr ElementFactory)) ->     -- list : TGList (TInterface "Gst" "ElementFactory")+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"+    CInt ->                                 -- subsetonly : TBasicType TBoolean+    IO (Ptr (GList (Ptr ElementFactory)))+++elementFactoryListFilter ::+    (MonadIO m, ElementFactoryK a) =>+    [a]                                     -- list+    -> Caps                                 -- caps+    -> PadDirection                         -- direction+    -> Bool                                 -- subsetonly+    -> m [ElementFactory]                   -- result+elementFactoryListFilter list caps direction subsetonly = liftIO $ do+    let list' = map unsafeManagedPtrCastPtr list+    list'' <- packGList list'+    let caps' = unsafeManagedPtrGetPtr caps+    let direction' = (fromIntegral . fromEnum) direction+    let subsetonly' = (fromIntegral . fromEnum) subsetonly+    result <- gst_element_factory_list_filter list'' caps' direction' subsetonly'+    checkUnexpectedReturnNULL "gst_element_factory_list_filter" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject ElementFactory) result'+    g_list_free result+    mapM_ touchManagedPtr list+    touchManagedPtr caps+    g_list_free list''+    return result''++-- method ElementFactory::list_get_elements+-- method type : MemberFunction+-- Args : [Arg {argCName = "type", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minrank", argType = TInterface "Gst" "Rank", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "ElementFactory")+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_list_get_elements" gst_element_factory_list_get_elements :: +    Word64 ->                               -- type : TBasicType TUInt64+    CUInt ->                                -- minrank : TInterface "Gst" "Rank"+    IO (Ptr (GList (Ptr ElementFactory)))+++elementFactoryListGetElements ::+    (MonadIO m) =>+    Word64                                  -- type_+    -> Rank                                 -- minrank+    -> m [ElementFactory]                   -- result+elementFactoryListGetElements type_ minrank = liftIO $ do+    let minrank' = (fromIntegral . fromEnum) minrank+    result <- gst_element_factory_list_get_elements type_ minrank'+    checkUnexpectedReturnNULL "gst_element_factory_list_get_elements" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject ElementFactory) result'+    g_list_free result+    return result''++-- method ElementFactory::make+-- method type : MemberFunction+-- Args : [Arg {argCName = "factoryname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : False+-- Skip return : False++foreign import ccall "gst_element_factory_make" gst_element_factory_make :: +    CString ->                              -- factoryname : TBasicType TUTF8+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Element)+++elementFactoryMake ::+    (MonadIO m) =>+    T.Text                                  -- factoryname+    -> Maybe (T.Text)                       -- name+    -> m Element                            -- result+elementFactoryMake factoryname name = liftIO $ do+    factoryname' <- textToCString factoryname+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_element_factory_make factoryname' maybeName+    checkUnexpectedReturnNULL "gst_element_factory_make" result+    result' <- (newObject Element) result+    freeMem factoryname'+    freeMem maybeName+    return result'++
+ GI/Gst/Objects/ElementFactory.hs-boot view
@@ -0,0 +1,27 @@+module GI.Gst.Objects.ElementFactory 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++newtype ElementFactory = ElementFactory (ForeignPtr ElementFactory)+instance GObject ElementFactory where+class GObject o => ElementFactoryK o+instance (GObject o, IsDescendantOf ElementFactory o) => ElementFactoryK o+data ElementFactoryCanSinkAllCapsMethodInfo+data ElementFactoryCanSinkAnyCapsMethodInfo+data ElementFactoryCanSrcAllCapsMethodInfo+data ElementFactoryCanSrcAnyCapsMethodInfo+data ElementFactoryCreateMethodInfo+data ElementFactoryGetElementTypeMethodInfo+data ElementFactoryGetMetadataMethodInfo+data ElementFactoryGetMetadataKeysMethodInfo+data ElementFactoryGetNumPadTemplatesMethodInfo+data ElementFactoryGetStaticPadTemplatesMethodInfo+data ElementFactoryGetUriProtocolsMethodInfo+data ElementFactoryGetUriTypeMethodInfo+data ElementFactoryHasInterfaceMethodInfo+data ElementFactoryListIsTypeMethodInfo
+ GI/Gst/Objects/GhostPad.hs view
@@ -0,0 +1,536 @@+++{- |+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.Objects.GhostPad+    ( ++-- * Exported types+    GhostPad(..)                            ,+    GhostPadK                               ,+    toGhostPad                              ,+    noGhostPad                              ,+++ -- * Methods+-- ** ghostPadActivateModeDefault+    ghostPadActivateModeDefault             ,+++-- ** ghostPadConstruct+    GhostPadConstructMethodInfo             ,+    ghostPadConstruct                       ,+++-- ** ghostPadGetTarget+    GhostPadGetTargetMethodInfo             ,+    ghostPadGetTarget                       ,+++-- ** ghostPadInternalActivateModeDefault+    ghostPadInternalActivateModeDefault     ,+++-- ** ghostPadNew+    ghostPadNew                             ,+++-- ** ghostPadNewFromTemplate+    ghostPadNewFromTemplate                 ,+++-- ** ghostPadNewNoTarget+    ghostPadNewNoTarget                     ,+++-- ** ghostPadNewNoTargetFromTemplate+    ghostPadNewNoTargetFromTemplate         ,+++-- ** ghostPadSetTarget+    GhostPadSetTargetMethodInfo             ,+    ghostPadSetTarget                       ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype GhostPad = GhostPad (ForeignPtr GhostPad)+foreign import ccall "gst_ghost_pad_get_type"+    c_gst_ghost_pad_get_type :: IO GType++type instance ParentTypes GhostPad = GhostPadParentTypes+type GhostPadParentTypes = '[ProxyPad, Pad, Object, GObject.Object]++instance GObject GhostPad where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_ghost_pad_get_type+    ++class GObject o => GhostPadK o+instance (GObject o, IsDescendantOf GhostPad o) => GhostPadK o++toGhostPad :: GhostPadK o => o -> IO GhostPad+toGhostPad = unsafeCastTo GhostPad++noGhostPad :: Maybe GhostPad+noGhostPad = Nothing++type family ResolveGhostPadMethod (t :: Symbol) (o :: *) :: * where+    ResolveGhostPadMethod "activateMode" o = PadActivateModeMethodInfo+    ResolveGhostPadMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveGhostPadMethod "addProbe" o = PadAddProbeMethodInfo+    ResolveGhostPadMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveGhostPadMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveGhostPadMethod "canLink" o = PadCanLinkMethodInfo+    ResolveGhostPadMethod "chain" o = PadChainMethodInfo+    ResolveGhostPadMethod "chainList" o = PadChainListMethodInfo+    ResolveGhostPadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo+    ResolveGhostPadMethod "construct" o = GhostPadConstructMethodInfo+    ResolveGhostPadMethod "createStreamId" o = PadCreateStreamIdMethodInfo+    ResolveGhostPadMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveGhostPadMethod "eventDefault" o = PadEventDefaultMethodInfo+    ResolveGhostPadMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveGhostPadMethod "forward" o = PadForwardMethodInfo+    ResolveGhostPadMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveGhostPadMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveGhostPadMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveGhostPadMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveGhostPadMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveGhostPadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo+    ResolveGhostPadMethod "isActive" o = PadIsActiveMethodInfo+    ResolveGhostPadMethod "isBlocked" o = PadIsBlockedMethodInfo+    ResolveGhostPadMethod "isBlocking" o = PadIsBlockingMethodInfo+    ResolveGhostPadMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveGhostPadMethod "isLinked" o = PadIsLinkedMethodInfo+    ResolveGhostPadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo+    ResolveGhostPadMethod "link" o = PadLinkMethodInfo+    ResolveGhostPadMethod "linkFull" o = PadLinkFullMethodInfo+    ResolveGhostPadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo+    ResolveGhostPadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo+    ResolveGhostPadMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveGhostPadMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveGhostPadMethod "pauseTask" o = PadPauseTaskMethodInfo+    ResolveGhostPadMethod "peerQuery" o = PadPeerQueryMethodInfo+    ResolveGhostPadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo+    ResolveGhostPadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo+    ResolveGhostPadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo+    ResolveGhostPadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo+    ResolveGhostPadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo+    ResolveGhostPadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo+    ResolveGhostPadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo+    ResolveGhostPadMethod "pullRange" o = PadPullRangeMethodInfo+    ResolveGhostPadMethod "push" o = PadPushMethodInfo+    ResolveGhostPadMethod "pushEvent" o = PadPushEventMethodInfo+    ResolveGhostPadMethod "pushList" o = PadPushListMethodInfo+    ResolveGhostPadMethod "query" o = PadQueryMethodInfo+    ResolveGhostPadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo+    ResolveGhostPadMethod "queryCaps" o = PadQueryCapsMethodInfo+    ResolveGhostPadMethod "queryConvert" o = PadQueryConvertMethodInfo+    ResolveGhostPadMethod "queryDefault" o = PadQueryDefaultMethodInfo+    ResolveGhostPadMethod "queryDuration" o = PadQueryDurationMethodInfo+    ResolveGhostPadMethod "queryPosition" o = PadQueryPositionMethodInfo+    ResolveGhostPadMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveGhostPadMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveGhostPadMethod "removeProbe" o = PadRemoveProbeMethodInfo+    ResolveGhostPadMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveGhostPadMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveGhostPadMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveGhostPadMethod "sendEvent" o = PadSendEventMethodInfo+    ResolveGhostPadMethod "startTask" o = PadStartTaskMethodInfo+    ResolveGhostPadMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveGhostPadMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveGhostPadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo+    ResolveGhostPadMethod "stopTask" o = PadStopTaskMethodInfo+    ResolveGhostPadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo+    ResolveGhostPadMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveGhostPadMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveGhostPadMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveGhostPadMethod "unlink" o = PadUnlinkMethodInfo+    ResolveGhostPadMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveGhostPadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo+    ResolveGhostPadMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveGhostPadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo+    ResolveGhostPadMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveGhostPadMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveGhostPadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo+    ResolveGhostPadMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveGhostPadMethod "getDirection" o = PadGetDirectionMethodInfo+    ResolveGhostPadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo+    ResolveGhostPadMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveGhostPadMethod "getInternal" o = ProxyPadGetInternalMethodInfo+    ResolveGhostPadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo+    ResolveGhostPadMethod "getName" o = ObjectGetNameMethodInfo+    ResolveGhostPadMethod "getOffset" o = PadGetOffsetMethodInfo+    ResolveGhostPadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo+    ResolveGhostPadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo+    ResolveGhostPadMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveGhostPadMethod "getParentElement" o = PadGetParentElementMethodInfo+    ResolveGhostPadMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveGhostPadMethod "getPeer" o = PadGetPeerMethodInfo+    ResolveGhostPadMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveGhostPadMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveGhostPadMethod "getRange" o = PadGetRangeMethodInfo+    ResolveGhostPadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo+    ResolveGhostPadMethod "getStreamId" o = PadGetStreamIdMethodInfo+    ResolveGhostPadMethod "getTarget" o = GhostPadGetTargetMethodInfo+    ResolveGhostPadMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveGhostPadMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveGhostPadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo+    ResolveGhostPadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo+    ResolveGhostPadMethod "setActive" o = PadSetActiveMethodInfo+    ResolveGhostPadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo+    ResolveGhostPadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo+    ResolveGhostPadMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveGhostPadMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveGhostPadMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveGhostPadMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveGhostPadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo+    ResolveGhostPadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo+    ResolveGhostPadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo+    ResolveGhostPadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo+    ResolveGhostPadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo+    ResolveGhostPadMethod "setName" o = ObjectSetNameMethodInfo+    ResolveGhostPadMethod "setOffset" o = PadSetOffsetMethodInfo+    ResolveGhostPadMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveGhostPadMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveGhostPadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo+    ResolveGhostPadMethod "setTarget" o = GhostPadSetTargetMethodInfo+    ResolveGhostPadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo+    ResolveGhostPadMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveGhostPadMethod t GhostPad, MethodInfo info GhostPad p) => IsLabelProxy t (GhostPad -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveGhostPadMethod t GhostPad, MethodInfo info GhostPad p) => IsLabel t (GhostPad -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList GhostPad = GhostPadAttributeList+type GhostPadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])++type instance SignalList GhostPad = GhostPadSignalList+type GhostPadSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])++-- method GhostPad::new+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "GhostPad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_new" gst_ghost_pad_new :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr Pad ->                              -- target : TInterface "Gst" "Pad"+    IO (Ptr GhostPad)+++ghostPadNew ::+    (MonadIO m, PadK a) =>+    Maybe (T.Text)                          -- name+    -> a                                    -- target+    -> m GhostPad                           -- result+ghostPadNew name target = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    let target' = unsafeManagedPtrCastPtr target+    result <- gst_ghost_pad_new maybeName target'+    checkUnexpectedReturnNULL "gst_ghost_pad_new" result+    result' <- (newObject GhostPad) result+    touchManagedPtr target+    freeMem maybeName+    return result'++-- method GhostPad::new_from_template+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "GhostPad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_new_from_template" gst_ghost_pad_new_from_template :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr Pad ->                              -- target : TInterface "Gst" "Pad"+    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"+    IO (Ptr GhostPad)+++ghostPadNewFromTemplate ::+    (MonadIO m, PadK a, PadTemplateK b) =>+    Maybe (T.Text)                          -- name+    -> a                                    -- target+    -> b                                    -- templ+    -> m GhostPad                           -- result+ghostPadNewFromTemplate name target templ = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    let target' = unsafeManagedPtrCastPtr target+    let templ' = unsafeManagedPtrCastPtr templ+    result <- gst_ghost_pad_new_from_template maybeName target' templ'+    checkUnexpectedReturnNULL "gst_ghost_pad_new_from_template" result+    result' <- (wrapObject GhostPad) result+    touchManagedPtr target+    touchManagedPtr templ+    freeMem maybeName+    return result'++-- method GhostPad::new_no_target+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "GhostPad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_new_no_target" gst_ghost_pad_new_no_target :: +    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- dir : TInterface "Gst" "PadDirection"+    IO (Ptr GhostPad)+++ghostPadNewNoTarget ::+    (MonadIO m) =>+    Maybe (T.Text)                          -- name+    -> PadDirection                         -- dir+    -> m GhostPad                           -- result+ghostPadNewNoTarget name dir = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    let dir' = (fromIntegral . fromEnum) dir+    result <- gst_ghost_pad_new_no_target maybeName dir'+    checkUnexpectedReturnNULL "gst_ghost_pad_new_no_target" result+    result' <- (wrapObject GhostPad) result+    freeMem maybeName+    return result'++-- method GhostPad::new_no_target_from_template+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "GhostPad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_new_no_target_from_template" gst_ghost_pad_new_no_target_from_template :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"+    IO (Ptr GhostPad)+++ghostPadNewNoTargetFromTemplate ::+    (MonadIO m, PadTemplateK a) =>+    Maybe (T.Text)                          -- name+    -> a                                    -- templ+    -> m GhostPad                           -- result+ghostPadNewNoTargetFromTemplate name templ = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    let templ' = unsafeManagedPtrCastPtr templ+    result <- gst_ghost_pad_new_no_target_from_template maybeName templ'+    checkUnexpectedReturnNULL "gst_ghost_pad_new_no_target_from_template" result+    result' <- (wrapObject GhostPad) result+    touchManagedPtr templ+    freeMem maybeName+    return result'++-- method GhostPad::construct+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "GhostPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_construct" gst_ghost_pad_construct :: +    Ptr GhostPad ->                         -- _obj : TInterface "Gst" "GhostPad"+    IO CInt+++ghostPadConstruct ::+    (MonadIO m, GhostPadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+ghostPadConstruct _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_ghost_pad_construct _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data GhostPadConstructMethodInfo+instance (signature ~ (m Bool), MonadIO m, GhostPadK a) => MethodInfo GhostPadConstructMethodInfo a signature where+    overloadedMethod _ = ghostPadConstruct++-- method GhostPad::get_target+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "GhostPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_get_target" gst_ghost_pad_get_target :: +    Ptr GhostPad ->                         -- _obj : TInterface "Gst" "GhostPad"+    IO (Ptr Pad)+++ghostPadGetTarget ::+    (MonadIO m, GhostPadK a) =>+    a                                       -- _obj+    -> m Pad                                -- result+ghostPadGetTarget _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_ghost_pad_get_target _obj'+    checkUnexpectedReturnNULL "gst_ghost_pad_get_target" result+    result' <- (wrapObject Pad) result+    touchManagedPtr _obj+    return result'++data GhostPadGetTargetMethodInfo+instance (signature ~ (m Pad), MonadIO m, GhostPadK a) => MethodInfo GhostPadGetTargetMethodInfo a signature where+    overloadedMethod _ = ghostPadGetTarget++-- method GhostPad::set_target+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "GhostPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "newtarget", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_set_target" gst_ghost_pad_set_target :: +    Ptr GhostPad ->                         -- _obj : TInterface "Gst" "GhostPad"+    Ptr Pad ->                              -- newtarget : TInterface "Gst" "Pad"+    IO CInt+++ghostPadSetTarget ::+    (MonadIO m, GhostPadK a, PadK b) =>+    a                                       -- _obj+    -> Maybe (b)                            -- newtarget+    -> m Bool                               -- result+ghostPadSetTarget _obj newtarget = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeNewtarget <- case newtarget of+        Nothing -> return nullPtr+        Just jNewtarget -> do+            let jNewtarget' = unsafeManagedPtrCastPtr jNewtarget+            return jNewtarget'+    result <- gst_ghost_pad_set_target _obj' maybeNewtarget+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust newtarget touchManagedPtr+    return result'++data GhostPadSetTargetMethodInfo+instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, GhostPadK a, PadK b) => MethodInfo GhostPadSetTargetMethodInfo a signature where+    overloadedMethod _ = ghostPadSetTarget++-- method GhostPad::activate_mode_default+-- method type : MemberFunction+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_activate_mode_default" gst_ghost_pad_activate_mode_default :: +    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++ghostPadActivateModeDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- pad+    -> Maybe (b)                            -- parent+    -> PadMode                              -- mode+    -> Bool                                 -- active+    -> m Bool                               -- result+ghostPadActivateModeDefault pad parent mode active = liftIO $ do+    let pad' = unsafeManagedPtrCastPtr pad+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    let mode' = (fromIntegral . fromEnum) mode+    let active' = (fromIntegral . fromEnum) active+    result <- gst_ghost_pad_activate_mode_default pad' maybeParent mode' active'+    let result' = (/= 0) result+    touchManagedPtr pad+    whenJust parent touchManagedPtr+    return result'++-- method GhostPad::internal_activate_mode_default+-- method type : MemberFunction+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_ghost_pad_internal_activate_mode_default" gst_ghost_pad_internal_activate_mode_default :: +    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++ghostPadInternalActivateModeDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- pad+    -> Maybe (b)                            -- parent+    -> PadMode                              -- mode+    -> Bool                                 -- active+    -> m Bool                               -- result+ghostPadInternalActivateModeDefault pad parent mode active = liftIO $ do+    let pad' = unsafeManagedPtrCastPtr pad+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    let mode' = (fromIntegral . fromEnum) mode+    let active' = (fromIntegral . fromEnum) active+    result <- gst_ghost_pad_internal_activate_mode_default pad' maybeParent mode' active'+    let result' = (/= 0) result+    touchManagedPtr pad+    whenJust parent touchManagedPtr+    return result'++
+ GI/Gst/Objects/GhostPad.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gst.Objects.GhostPad 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++newtype GhostPad = GhostPad (ForeignPtr GhostPad)+instance GObject GhostPad where+class GObject o => GhostPadK o+instance (GObject o, IsDescendantOf GhostPad o) => GhostPadK o+data GhostPadConstructMethodInfo+data GhostPadGetTargetMethodInfo+data GhostPadSetTargetMethodInfo
+ GI/Gst/Objects/Object.hs view
@@ -0,0 +1,1290 @@+++{- |+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.Objects.Object+    ( ++-- * Exported types+    Object(..)                              ,+    ObjectK                                 ,+    toObject                                ,+    noObject                                ,+++ -- * Methods+-- ** objectAddControlBinding+    ObjectAddControlBindingMethodInfo       ,+    objectAddControlBinding                 ,+++-- ** objectCheckUniqueness+    objectCheckUniqueness                   ,+++-- ** objectDefaultDeepNotify+    objectDefaultDeepNotify                 ,+++-- ** objectDefaultError+    ObjectDefaultErrorMethodInfo            ,+    objectDefaultError                      ,+++-- ** objectGetControlBinding+    ObjectGetControlBindingMethodInfo       ,+    objectGetControlBinding                 ,+++-- ** objectGetControlRate+    ObjectGetControlRateMethodInfo          ,+    objectGetControlRate                    ,+++-- ** objectGetGValueArray+    ObjectGetGValueArrayMethodInfo          ,+    objectGetGValueArray                    ,+++-- ** objectGetName+    ObjectGetNameMethodInfo                 ,+    objectGetName                           ,+++-- ** objectGetParent+    ObjectGetParentMethodInfo               ,+    objectGetParent                         ,+++-- ** objectGetPathString+    ObjectGetPathStringMethodInfo           ,+    objectGetPathString                     ,+++-- ** objectGetValue+    ObjectGetValueMethodInfo                ,+    objectGetValue                          ,+++-- ** objectGetValueArray+    ObjectGetValueArrayMethodInfo           ,+    objectGetValueArray                     ,+++-- ** objectHasActiveControlBindings+    ObjectHasActiveControlBindingsMethodInfo,+    objectHasActiveControlBindings          ,+++-- ** objectHasAncestor+    ObjectHasAncestorMethodInfo             ,+    objectHasAncestor                       ,+++-- ** objectHasAsAncestor+    ObjectHasAsAncestorMethodInfo           ,+    objectHasAsAncestor                     ,+++-- ** objectHasAsParent+    ObjectHasAsParentMethodInfo             ,+    objectHasAsParent                       ,+++-- ** objectRef+    ObjectRefMethodInfo                     ,+    objectRef                               ,+++-- ** objectRemoveControlBinding+    ObjectRemoveControlBindingMethodInfo    ,+    objectRemoveControlBinding              ,+++-- ** objectReplace+    objectReplace                           ,+++-- ** objectSetControlBindingDisabled+    ObjectSetControlBindingDisabledMethodInfo,+    objectSetControlBindingDisabled         ,+++-- ** objectSetControlBindingsDisabled+    ObjectSetControlBindingsDisabledMethodInfo,+    objectSetControlBindingsDisabled        ,+++-- ** objectSetControlRate+    ObjectSetControlRateMethodInfo          ,+    objectSetControlRate                    ,+++-- ** objectSetName+    ObjectSetNameMethodInfo                 ,+    objectSetName                           ,+++-- ** objectSetParent+    ObjectSetParentMethodInfo               ,+    objectSetParent                         ,+++-- ** objectSuggestNextSync+    ObjectSuggestNextSyncMethodInfo         ,+    objectSuggestNextSync                   ,+++-- ** objectSyncValues+    ObjectSyncValuesMethodInfo              ,+    objectSyncValues                        ,+++-- ** objectUnparent+    ObjectUnparentMethodInfo                ,+    objectUnparent                          ,+++-- ** objectUnref+    ObjectUnrefMethodInfo                   ,+    objectUnref                             ,+++++ -- * Properties+-- ** Name+    ObjectNamePropertyInfo                  ,+    constructObjectName                     ,+    getObjectName                           ,+    setObjectName                           ,+++-- ** Parent+    ObjectParentPropertyInfo                ,+    constructObjectParent                   ,+    getObjectParent                         ,+    setObjectParent                         ,+++++ -- * Signals+-- ** DeepNotify+    ObjectDeepNotifyCallback                ,+    ObjectDeepNotifyCallbackC               ,+    ObjectDeepNotifySignalInfo              ,+    afterObjectDeepNotify                   ,+    mkObjectDeepNotifyCallback              ,+    noObjectDeepNotifyCallback              ,+    objectDeepNotifyCallbackWrapper         ,+    objectDeepNotifyClosure                 ,+    onObjectDeepNotify                      ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Object = Object (ForeignPtr Object)+foreign import ccall "gst_object_get_type"+    c_gst_object_get_type :: IO GType++type instance ParentTypes Object = ObjectParentTypes+type ObjectParentTypes = '[GObject.Object]++instance GObject Object where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_object_get_type+    ++class GObject o => ObjectK o+instance (GObject o, IsDescendantOf Object o) => ObjectK o++toObject :: ObjectK o => o -> IO Object+toObject = unsafeCastTo Object++noObject :: Maybe Object+noObject = Nothing++type family ResolveObjectMethod (t :: Symbol) (o :: *) :: * where+    ResolveObjectMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveObjectMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveObjectMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveObjectMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveObjectMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveObjectMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveObjectMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveObjectMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveObjectMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveObjectMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveObjectMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveObjectMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveObjectMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveObjectMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveObjectMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveObjectMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveObjectMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveObjectMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveObjectMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveObjectMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveObjectMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveObjectMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveObjectMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveObjectMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveObjectMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveObjectMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveObjectMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveObjectMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveObjectMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveObjectMethod "getName" o = ObjectGetNameMethodInfo+    ResolveObjectMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveObjectMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveObjectMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveObjectMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveObjectMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveObjectMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveObjectMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveObjectMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveObjectMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveObjectMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveObjectMethod "setName" o = ObjectSetNameMethodInfo+    ResolveObjectMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveObjectMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveObjectMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveObjectMethod t Object, MethodInfo info Object p) => IsLabelProxy t (Object -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveObjectMethod t Object, MethodInfo info Object p) => IsLabel t (Object -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Object::deep-notify+type ObjectDeepNotifyCallback =+    Object ->+    GParamSpec ->+    IO ()++noObjectDeepNotifyCallback :: Maybe ObjectDeepNotifyCallback+noObjectDeepNotifyCallback = Nothing++type ObjectDeepNotifyCallbackC =+    Ptr () ->                               -- object+    Ptr Object ->+    Ptr GParamSpec ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkObjectDeepNotifyCallback :: ObjectDeepNotifyCallbackC -> IO (FunPtr ObjectDeepNotifyCallbackC)++objectDeepNotifyClosure :: ObjectDeepNotifyCallback -> IO Closure+objectDeepNotifyClosure cb = newCClosure =<< mkObjectDeepNotifyCallback wrapped+    where wrapped = objectDeepNotifyCallbackWrapper cb++objectDeepNotifyCallbackWrapper ::+    ObjectDeepNotifyCallback ->+    Ptr () ->+    Ptr Object ->+    Ptr GParamSpec ->+    Ptr () ->+    IO ()+objectDeepNotifyCallbackWrapper _cb _ propObject prop _ = do+    propObject' <- (newObject Object) propObject+    prop' <- newGParamSpecFromPtr prop+    _cb  propObject' prop'++onObjectDeepNotify :: (GObject a, MonadIO m) => a -> ObjectDeepNotifyCallback -> m SignalHandlerId+onObjectDeepNotify obj cb = liftIO $ connectObjectDeepNotify obj cb SignalConnectBefore+afterObjectDeepNotify :: (GObject a, MonadIO m) => a -> ObjectDeepNotifyCallback -> m SignalHandlerId+afterObjectDeepNotify obj cb = connectObjectDeepNotify obj cb SignalConnectAfter++connectObjectDeepNotify :: (GObject a, MonadIO m) =>+                           a -> ObjectDeepNotifyCallback -> SignalConnectMode -> m SignalHandlerId+connectObjectDeepNotify obj cb after = liftIO $ do+    cb' <- mkObjectDeepNotifyCallback (objectDeepNotifyCallbackWrapper cb)+    connectSignalFunPtr obj "deep-notify" cb' after++-- VVV Prop "name"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]++getObjectName :: (MonadIO m, ObjectK o) => o -> m T.Text+getObjectName obj = liftIO $ getObjectPropertyString obj "name"++setObjectName :: (MonadIO m, ObjectK o) => o -> T.Text -> m ()+setObjectName obj val = liftIO $ setObjectPropertyString obj "name" val++constructObjectName :: T.Text -> IO ([Char], GValue)+constructObjectName val = constructObjectPropertyString "name" val++data ObjectNamePropertyInfo+instance AttrInfo ObjectNamePropertyInfo where+    type AttrAllowedOps ObjectNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ObjectNamePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint ObjectNamePropertyInfo = ObjectK+    type AttrGetType ObjectNamePropertyInfo = T.Text+    type AttrLabel ObjectNamePropertyInfo = "name"+    attrGet _ = getObjectName+    attrSet _ = setObjectName+    attrConstruct _ = constructObjectName++-- VVV Prop "parent"+   -- Type: TInterface "Gst" "Object"+   -- Flags: [PropertyReadable,PropertyWritable]++getObjectParent :: (MonadIO m, ObjectK o) => o -> m Object+getObjectParent obj = liftIO $ getObjectPropertyObject obj "parent" Object++setObjectParent :: (MonadIO m, ObjectK o, ObjectK a) => o -> a -> m ()+setObjectParent obj val = liftIO $ setObjectPropertyObject obj "parent" val++constructObjectParent :: (ObjectK a) => a -> IO ([Char], GValue)+constructObjectParent val = constructObjectPropertyObject "parent" val++data ObjectParentPropertyInfo+instance AttrInfo ObjectParentPropertyInfo where+    type AttrAllowedOps ObjectParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint ObjectParentPropertyInfo = ObjectK+    type AttrBaseTypeConstraint ObjectParentPropertyInfo = ObjectK+    type AttrGetType ObjectParentPropertyInfo = Object+    type AttrLabel ObjectParentPropertyInfo = "parent"+    attrGet _ = getObjectParent+    attrSet _ = setObjectParent+    attrConstruct _ = constructObjectParent++type instance AttributeList Object = ObjectAttributeList+type ObjectAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++data ObjectDeepNotifySignalInfo+instance SignalInfo ObjectDeepNotifySignalInfo where+    type HaskellCallbackType ObjectDeepNotifySignalInfo = ObjectDeepNotifyCallback+    connectSignal _ = connectObjectDeepNotify++type instance SignalList Object = ObjectSignalList+type ObjectSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Object::add_control_binding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_add_control_binding" gst_object_add_control_binding :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Ptr ControlBinding ->                   -- binding : TInterface "Gst" "ControlBinding"+    IO CInt+++objectAddControlBinding ::+    (MonadIO m, ObjectK a, ControlBindingK b) =>+    a                                       -- _obj+    -> b                                    -- binding+    -> m Bool                               -- result+objectAddControlBinding _obj binding = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    binding' <- refObject binding+    result <- gst_object_add_control_binding _obj' binding'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr binding+    return result'++data ObjectAddControlBindingMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ControlBindingK b) => MethodInfo ObjectAddControlBindingMethodInfo a signature where+    overloadedMethod _ = objectAddControlBinding++-- method Object::default_error+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_default_error" gst_object_default_error :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Ptr GError ->                           -- error : TError+    CString ->                              -- debug : TBasicType TUTF8+    IO ()+++objectDefaultError ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> GError                               -- error_+    -> Maybe (T.Text)                       -- debug+    -> m ()                                 -- result+objectDefaultError _obj error_ debug = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let error_' = unsafeManagedPtrGetPtr error_+    maybeDebug <- case debug of+        Nothing -> return nullPtr+        Just jDebug -> do+            jDebug' <- textToCString jDebug+            return jDebug'+    gst_object_default_error _obj' error_' maybeDebug+    touchManagedPtr _obj+    touchManagedPtr error_+    freeMem maybeDebug+    return ()++data ObjectDefaultErrorMethodInfo+instance (signature ~ (GError -> Maybe (T.Text) -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectDefaultErrorMethodInfo a signature where+    overloadedMethod _ = objectDefaultError++-- method Object::get_control_binding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "ControlBinding"+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_control_binding" gst_object_get_control_binding :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    CString ->                              -- property_name : TBasicType TUTF8+    IO (Ptr ControlBinding)+++objectGetControlBinding ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> T.Text                               -- propertyName+    -> m ControlBinding                     -- result+objectGetControlBinding _obj propertyName = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    propertyName' <- textToCString propertyName+    result <- gst_object_get_control_binding _obj' propertyName'+    checkUnexpectedReturnNULL "gst_object_get_control_binding" result+    result' <- (wrapObject ControlBinding) result+    touchManagedPtr _obj+    freeMem propertyName'+    return result'++data ObjectGetControlBindingMethodInfo+instance (signature ~ (T.Text -> m ControlBinding), MonadIO m, ObjectK a) => MethodInfo ObjectGetControlBindingMethodInfo a signature where+    overloadedMethod _ = objectGetControlBinding++-- method Object::get_control_rate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_control_rate" gst_object_get_control_rate :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO Word64+++objectGetControlRate ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+objectGetControlRate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_get_control_rate _obj'+    touchManagedPtr _obj+    return result++data ObjectGetControlRateMethodInfo+instance (signature ~ (m Word64), MonadIO m, ObjectK a) => MethodInfo ObjectGetControlRateMethodInfo a signature where+    overloadedMethod _ = objectGetControlRate++-- method Object::get_g_value_array+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_g_value_array" gst_object_get_g_value_array :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    CString ->                              -- property_name : TBasicType TUTF8+    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- interval : TBasicType TUInt64+    Word32 ->                               -- n_values : TBasicType TUInt32+    Ptr GValue ->                           -- values : TInterface "GObject" "Value"+    IO CInt+++objectGetGValueArray ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> T.Text                               -- propertyName+    -> Word64                               -- timestamp+    -> Word64                               -- interval+    -> Word32                               -- nValues+    -> GValue                               -- values+    -> m Bool                               -- result+objectGetGValueArray _obj propertyName timestamp interval nValues values = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    propertyName' <- textToCString propertyName+    let values' = unsafeManagedPtrGetPtr values+    result <- gst_object_get_g_value_array _obj' propertyName' timestamp interval nValues values'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr values+    freeMem propertyName'+    return result'++data ObjectGetGValueArrayMethodInfo+instance (signature ~ (T.Text -> Word64 -> Word64 -> Word32 -> GValue -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectGetGValueArrayMethodInfo a signature where+    overloadedMethod _ = objectGetGValueArray++-- method Object::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_name" gst_object_get_name :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO CString+++objectGetName ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+objectGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_get_name _obj'+    checkUnexpectedReturnNULL "gst_object_get_name" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data ObjectGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, ObjectK a) => MethodInfo ObjectGetNameMethodInfo a signature where+    overloadedMethod _ = objectGetName++-- method Object::get_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_parent" gst_object_get_parent :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO (Ptr Object)+++objectGetParent ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m Object                             -- result+objectGetParent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_get_parent _obj'+    checkUnexpectedReturnNULL "gst_object_get_parent" result+    result' <- (wrapObject Object) result+    touchManagedPtr _obj+    return result'++data ObjectGetParentMethodInfo+instance (signature ~ (m Object), MonadIO m, ObjectK a) => MethodInfo ObjectGetParentMethodInfo a signature where+    overloadedMethod _ = objectGetParent++-- method Object::get_path_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_path_string" gst_object_get_path_string :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO CString+++objectGetPathString ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+objectGetPathString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_get_path_string _obj'+    checkUnexpectedReturnNULL "gst_object_get_path_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data ObjectGetPathStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m, ObjectK a) => MethodInfo ObjectGetPathStringMethodInfo a signature where+    overloadedMethod _ = objectGetPathString++-- method Object::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_value" gst_object_get_value :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    CString ->                              -- property_name : TBasicType TUTF8+    Word64 ->                               -- timestamp : TBasicType TUInt64+    IO (Ptr GValue)+++objectGetValue ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> T.Text                               -- propertyName+    -> Word64                               -- timestamp+    -> m GValue                             -- result+objectGetValue _obj propertyName timestamp = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    propertyName' <- textToCString propertyName+    result <- gst_object_get_value _obj' propertyName' timestamp+    checkUnexpectedReturnNULL "gst_object_get_value" result+    result' <- (wrapBoxed GValue) result+    touchManagedPtr _obj+    freeMem propertyName'+    return result'++data ObjectGetValueMethodInfo+instance (signature ~ (T.Text -> Word64 -> m GValue), MonadIO m, ObjectK a) => MethodInfo ObjectGetValueMethodInfo a signature where+    overloadedMethod _ = objectGetValue++-- method Object::get_value_array+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_get_value_array" gst_object_get_value_array :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    CString ->                              -- property_name : TBasicType TUTF8+    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- interval : TBasicType TUInt64+    Word32 ->                               -- n_values : TBasicType TUInt32+    Ptr () ->                               -- values : TBasicType TVoid+    IO CInt+++objectGetValueArray ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> T.Text                               -- propertyName+    -> Word64                               -- timestamp+    -> Word64                               -- interval+    -> Word32                               -- nValues+    -> Ptr ()                               -- values+    -> m Bool                               -- result+objectGetValueArray _obj propertyName timestamp interval nValues values = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    propertyName' <- textToCString propertyName+    result <- gst_object_get_value_array _obj' propertyName' timestamp interval nValues values+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem propertyName'+    return result'++data ObjectGetValueArrayMethodInfo+instance (signature ~ (T.Text -> Word64 -> Word64 -> Word32 -> Ptr () -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectGetValueArrayMethodInfo a signature where+    overloadedMethod _ = objectGetValueArray++-- method Object::has_active_control_bindings+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_has_active_control_bindings" gst_object_has_active_control_bindings :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO CInt+++objectHasActiveControlBindings ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+objectHasActiveControlBindings _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_has_active_control_bindings _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ObjectHasActiveControlBindingsMethodInfo+instance (signature ~ (m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectHasActiveControlBindingsMethodInfo a signature where+    overloadedMethod _ = objectHasActiveControlBindings++-- method Object::has_ancestor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_has_ancestor" gst_object_has_ancestor :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Ptr Object ->                           -- ancestor : TInterface "Gst" "Object"+    IO CInt++{-# DEPRECATED objectHasAncestor ["Use gst_object_has_as_ancestor() instead.","","MT safe. Grabs and releases @object's locks."]#-}+objectHasAncestor ::+    (MonadIO m, ObjectK a, ObjectK b) =>+    a                                       -- _obj+    -> b                                    -- ancestor+    -> m Bool                               -- result+objectHasAncestor _obj ancestor = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let ancestor' = unsafeManagedPtrCastPtr ancestor+    result <- gst_object_has_ancestor _obj' ancestor'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr ancestor+    return result'++data ObjectHasAncestorMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectHasAncestorMethodInfo a signature where+    overloadedMethod _ = objectHasAncestor++-- method Object::has_as_ancestor+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_has_as_ancestor" gst_object_has_as_ancestor :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Ptr Object ->                           -- ancestor : TInterface "Gst" "Object"+    IO CInt+++objectHasAsAncestor ::+    (MonadIO m, ObjectK a, ObjectK b) =>+    a                                       -- _obj+    -> b                                    -- ancestor+    -> m Bool                               -- result+objectHasAsAncestor _obj ancestor = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let ancestor' = unsafeManagedPtrCastPtr ancestor+    result <- gst_object_has_as_ancestor _obj' ancestor'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr ancestor+    return result'++data ObjectHasAsAncestorMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectHasAsAncestorMethodInfo a signature where+    overloadedMethod _ = objectHasAsAncestor++-- method Object::has_as_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_has_as_parent" gst_object_has_as_parent :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    IO CInt+++objectHasAsParent ::+    (MonadIO m, ObjectK a, ObjectK b) =>+    a                                       -- _obj+    -> b                                    -- parent+    -> m Bool                               -- result+objectHasAsParent _obj parent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let parent' = unsafeManagedPtrCastPtr parent+    result <- gst_object_has_as_parent _obj' parent'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr parent+    return result'++data ObjectHasAsParentMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectHasAsParentMethodInfo a signature where+    overloadedMethod _ = objectHasAsParent++-- method Object::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Object"+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_ref" gst_object_ref :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO (Ptr Object)+++objectRef ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m Object                             -- result+objectRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_ref _obj'+    checkUnexpectedReturnNULL "gst_object_ref" result+    result' <- (wrapObject Object) result+    touchManagedPtr _obj+    return result'++data ObjectRefMethodInfo+instance (signature ~ (m Object), MonadIO m, ObjectK a) => MethodInfo ObjectRefMethodInfo a signature where+    overloadedMethod _ = objectRef++-- method Object::remove_control_binding+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_remove_control_binding" gst_object_remove_control_binding :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Ptr ControlBinding ->                   -- binding : TInterface "Gst" "ControlBinding"+    IO CInt+++objectRemoveControlBinding ::+    (MonadIO m, ObjectK a, ControlBindingK b) =>+    a                                       -- _obj+    -> b                                    -- binding+    -> m Bool                               -- result+objectRemoveControlBinding _obj binding = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let binding' = unsafeManagedPtrCastPtr binding+    result <- gst_object_remove_control_binding _obj' binding'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr binding+    return result'++data ObjectRemoveControlBindingMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ControlBindingK b) => MethodInfo ObjectRemoveControlBindingMethodInfo a signature where+    overloadedMethod _ = objectRemoveControlBinding++-- method Object::set_control_binding_disabled+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_set_control_binding_disabled" gst_object_set_control_binding_disabled :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    CString ->                              -- property_name : TBasicType TUTF8+    CInt ->                                 -- disabled : TBasicType TBoolean+    IO ()+++objectSetControlBindingDisabled ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> T.Text                               -- propertyName+    -> Bool                                 -- disabled+    -> m ()                                 -- result+objectSetControlBindingDisabled _obj propertyName disabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    propertyName' <- textToCString propertyName+    let disabled' = (fromIntegral . fromEnum) disabled+    gst_object_set_control_binding_disabled _obj' propertyName' disabled'+    touchManagedPtr _obj+    freeMem propertyName'+    return ()++data ObjectSetControlBindingDisabledMethodInfo+instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectSetControlBindingDisabledMethodInfo a signature where+    overloadedMethod _ = objectSetControlBindingDisabled++-- method Object::set_control_bindings_disabled+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_set_control_bindings_disabled" gst_object_set_control_bindings_disabled :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    CInt ->                                 -- disabled : TBasicType TBoolean+    IO ()+++objectSetControlBindingsDisabled ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> Bool                                 -- disabled+    -> m ()                                 -- result+objectSetControlBindingsDisabled _obj disabled = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let disabled' = (fromIntegral . fromEnum) disabled+    gst_object_set_control_bindings_disabled _obj' disabled'+    touchManagedPtr _obj+    return ()++data ObjectSetControlBindingsDisabledMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectSetControlBindingsDisabledMethodInfo a signature where+    overloadedMethod _ = objectSetControlBindingsDisabled++-- method Object::set_control_rate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "control_rate", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_set_control_rate" gst_object_set_control_rate :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Word64 ->                               -- control_rate : TBasicType TUInt64+    IO ()+++objectSetControlRate ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> Word64                               -- controlRate+    -> m ()                                 -- result+objectSetControlRate _obj controlRate = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_object_set_control_rate _obj' controlRate+    touchManagedPtr _obj+    return ()++data ObjectSetControlRateMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectSetControlRateMethodInfo a signature where+    overloadedMethod _ = objectSetControlRate++-- method Object::set_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_set_name" gst_object_set_name :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++objectSetName ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- name+    -> m Bool                               -- result+objectSetName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_object_set_name _obj' maybeName+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem maybeName+    return result'++data ObjectSetNameMethodInfo+instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectSetNameMethodInfo a signature where+    overloadedMethod _ = objectSetName++-- method Object::set_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_set_parent" gst_object_set_parent :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    IO CInt+++objectSetParent ::+    (MonadIO m, ObjectK a, ObjectK b) =>+    a                                       -- _obj+    -> b                                    -- parent+    -> m Bool                               -- result+objectSetParent _obj parent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let parent' = unsafeManagedPtrCastPtr parent+    result <- gst_object_set_parent _obj' parent'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr parent+    return result'++data ObjectSetParentMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectSetParentMethodInfo a signature where+    overloadedMethod _ = objectSetParent++-- method Object::suggest_next_sync+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_suggest_next_sync" gst_object_suggest_next_sync :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO Word64+++objectSuggestNextSync ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+objectSuggestNextSync _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_suggest_next_sync _obj'+    touchManagedPtr _obj+    return result++data ObjectSuggestNextSyncMethodInfo+instance (signature ~ (m Word64), MonadIO m, ObjectK a) => MethodInfo ObjectSuggestNextSyncMethodInfo a signature where+    overloadedMethod _ = objectSuggestNextSync++-- method Object::sync_values+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_sync_values" gst_object_sync_values :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    Word64 ->                               -- timestamp : TBasicType TUInt64+    IO CInt+++objectSyncValues ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> Word64                               -- timestamp+    -> m Bool                               -- result+objectSyncValues _obj timestamp = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_object_sync_values _obj' timestamp+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ObjectSyncValuesMethodInfo+instance (signature ~ (Word64 -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectSyncValuesMethodInfo a signature where+    overloadedMethod _ = objectSyncValues++-- method Object::unparent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_unparent" gst_object_unparent :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO ()+++objectUnparent ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+objectUnparent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_object_unparent _obj'+    touchManagedPtr _obj+    return ()++data ObjectUnparentMethodInfo+instance (signature ~ (m ()), MonadIO m, ObjectK a) => MethodInfo ObjectUnparentMethodInfo a signature where+    overloadedMethod _ = objectUnparent++-- method Object::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_unref" gst_object_unref :: +    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"+    IO ()+++objectUnref ::+    (MonadIO m, ObjectK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+objectUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_object_unref _obj'+    touchManagedPtr _obj+    return ()++data ObjectUnrefMethodInfo+instance (signature ~ (m ()), MonadIO m, ObjectK a) => MethodInfo ObjectUnrefMethodInfo a signature where+    overloadedMethod _ = objectUnref++-- method Object::check_uniqueness+-- method type : MemberFunction+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "Object"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_check_uniqueness" gst_object_check_uniqueness :: +    Ptr (GList (Ptr Object)) ->             -- list : TGList (TInterface "Gst" "Object")+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++objectCheckUniqueness ::+    (MonadIO m, ObjectK a) =>+    [a]                                     -- list+    -> T.Text                               -- name+    -> m Bool                               -- result+objectCheckUniqueness list name = liftIO $ do+    let list' = map unsafeManagedPtrCastPtr list+    list'' <- packGList list'+    name' <- textToCString name+    result <- gst_object_check_uniqueness list'' name'+    let result' = (/= 0) result+    mapM_ touchManagedPtr list+    g_list_free list''+    freeMem name'+    return result'++-- method Object::default_deep_notify+-- method type : MemberFunction+-- Args : [Arg {argCName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orig", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "excluded_props", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_default_deep_notify" gst_object_default_deep_notify :: +    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"+    Ptr Object ->                           -- orig : TInterface "Gst" "Object"+    Ptr GParamSpec ->                       -- pspec : TParamSpec+    Ptr CString ->                          -- excluded_props : TCArray True (-1) (-1) (TBasicType TUTF8)+    IO ()+++objectDefaultDeepNotify ::+    (MonadIO m, GObject.ObjectK a, ObjectK b) =>+    a                                       -- object+    -> b                                    -- orig+    -> GParamSpec                           -- pspec+    -> Maybe ([T.Text])                     -- excludedProps+    -> m ()                                 -- result+objectDefaultDeepNotify object orig pspec excludedProps = liftIO $ do+    let object' = unsafeManagedPtrCastPtr object+    let orig' = unsafeManagedPtrCastPtr orig+    let pspec' = unsafeManagedPtrGetPtr pspec+    maybeExcludedProps <- case excludedProps of+        Nothing -> return nullPtr+        Just jExcludedProps -> do+            jExcludedProps' <- packZeroTerminatedUTF8CArray jExcludedProps+            return jExcludedProps'+    gst_object_default_deep_notify object' orig' pspec' maybeExcludedProps+    touchManagedPtr object+    touchManagedPtr orig+    mapZeroTerminatedCArray freeMem maybeExcludedProps+    freeMem maybeExcludedProps+    return ()++-- method Object::replace+-- method type : MemberFunction+-- Args : [Arg {argCName = "oldobj", argType = TInterface "Gst" "Object", direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "newobj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_object_replace" gst_object_replace :: +    Ptr (Ptr Object) ->                     -- oldobj : TInterface "Gst" "Object"+    Ptr Object ->                           -- newobj : TInterface "Gst" "Object"+    IO CInt+++objectReplace ::+    (MonadIO m, ObjectK a, ObjectK b) =>+    Maybe (a)                               -- oldobj+    -> Maybe (b)                            -- newobj+    -> m (Bool,(Maybe Object))              -- result+objectReplace oldobj newobj = liftIO $ do+    maybeOldobj <- case oldobj of+        Nothing -> return nullPtr+        Just jOldobj -> do+            jOldobj' <- refObject jOldobj+            return jOldobj'+    maybeOldobj' <- allocMem :: IO (Ptr (Ptr Object))+    poke maybeOldobj' maybeOldobj+    maybeNewobj <- case newobj of+        Nothing -> return nullPtr+        Just jNewobj -> do+            let jNewobj' = unsafeManagedPtrCastPtr jNewobj+            return jNewobj'+    result <- gst_object_replace maybeOldobj' maybeNewobj+    let result' = (/= 0) result+    maybeOldobj'' <- peek maybeOldobj'+    maybeMaybeOldobj'' <- convertIfNonNull maybeOldobj'' $ \maybeOldobj''' -> do+        maybeOldobj'''' <- (wrapObject Object) maybeOldobj'''+        return maybeOldobj''''+    whenJust oldobj touchManagedPtr+    whenJust newobj touchManagedPtr+    freeMem maybeOldobj'+    return (result', maybeMaybeOldobj'')++
+ GI/Gst/Objects/Object.hs-boot view
@@ -0,0 +1,41 @@+module GI.Gst.Objects.Object 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++newtype Object = Object (ForeignPtr Object)+instance GObject Object where+class GObject o => ObjectK o+instance (GObject o, IsDescendantOf Object o) => ObjectK o+data ObjectNamePropertyInfo+data ObjectParentPropertyInfo+data ObjectDeepNotifySignalInfo+data ObjectAddControlBindingMethodInfo+data ObjectDefaultErrorMethodInfo+data ObjectGetControlBindingMethodInfo+data ObjectGetControlRateMethodInfo+data ObjectGetGValueArrayMethodInfo+data ObjectGetNameMethodInfo+data ObjectGetParentMethodInfo+data ObjectGetPathStringMethodInfo+data ObjectGetValueMethodInfo+data ObjectGetValueArrayMethodInfo+data ObjectHasActiveControlBindingsMethodInfo+data ObjectHasAncestorMethodInfo+data ObjectHasAsAncestorMethodInfo+data ObjectHasAsParentMethodInfo+data ObjectRefMethodInfo+data ObjectRemoveControlBindingMethodInfo+data ObjectSetControlBindingDisabledMethodInfo+data ObjectSetControlBindingsDisabledMethodInfo+data ObjectSetControlRateMethodInfo+data ObjectSetNameMethodInfo+data ObjectSetParentMethodInfo+data ObjectSuggestNextSyncMethodInfo+data ObjectSyncValuesMethodInfo+data ObjectUnparentMethodInfo+data ObjectUnrefMethodInfo
+ GI/Gst/Objects/Pad.hs view
@@ -0,0 +1,3315 @@+++{- |+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.Objects.Pad+    ( ++-- * Exported types+    Pad(..)                                 ,+    PadK                                    ,+    toPad                                   ,+    noPad                                   ,+++ -- * Methods+-- ** padActivateMode+    PadActivateModeMethodInfo               ,+    padActivateMode                         ,+++-- ** padAddProbe+    PadAddProbeMethodInfo                   ,+    padAddProbe                             ,+++-- ** padCanLink+    PadCanLinkMethodInfo                    ,+    padCanLink                              ,+++-- ** padChain+    PadChainMethodInfo                      ,+    padChain                                ,+++-- ** padChainList+    PadChainListMethodInfo                  ,+    padChainList                            ,+++-- ** padCheckReconfigure+    PadCheckReconfigureMethodInfo           ,+    padCheckReconfigure                     ,+++-- ** padCreateStreamId+    PadCreateStreamIdMethodInfo             ,+    padCreateStreamId                       ,+++-- ** padEventDefault+    PadEventDefaultMethodInfo               ,+    padEventDefault                         ,+++-- ** padForward+    PadForwardMethodInfo                    ,+    padForward                              ,+++-- ** padGetAllowedCaps+    PadGetAllowedCapsMethodInfo             ,+    padGetAllowedCaps                       ,+++-- ** padGetCurrentCaps+    PadGetCurrentCapsMethodInfo             ,+    padGetCurrentCaps                       ,+++-- ** padGetDirection+    PadGetDirectionMethodInfo               ,+    padGetDirection                         ,+++-- ** padGetElementPrivate+    PadGetElementPrivateMethodInfo          ,+    padGetElementPrivate                    ,+++-- ** padGetLastFlowReturn+    PadGetLastFlowReturnMethodInfo          ,+    padGetLastFlowReturn                    ,+++-- ** padGetOffset+    PadGetOffsetMethodInfo                  ,+    padGetOffset                            ,+++-- ** padGetPadTemplate+    PadGetPadTemplateMethodInfo             ,+    padGetPadTemplate                       ,+++-- ** padGetPadTemplateCaps+    PadGetPadTemplateCapsMethodInfo         ,+    padGetPadTemplateCaps                   ,+++-- ** padGetParentElement+    PadGetParentElementMethodInfo           ,+    padGetParentElement                     ,+++-- ** padGetPeer+    PadGetPeerMethodInfo                    ,+    padGetPeer                              ,+++-- ** padGetRange+    PadGetRangeMethodInfo                   ,+    padGetRange                             ,+++-- ** padGetStickyEvent+    PadGetStickyEventMethodInfo             ,+    padGetStickyEvent                       ,+++-- ** padGetStreamId+    PadGetStreamIdMethodInfo                ,+    padGetStreamId                          ,+++-- ** padHasCurrentCaps+    PadHasCurrentCapsMethodInfo             ,+    padHasCurrentCaps                       ,+++-- ** padIsActive+    PadIsActiveMethodInfo                   ,+    padIsActive                             ,+++-- ** padIsBlocked+    PadIsBlockedMethodInfo                  ,+    padIsBlocked                            ,+++-- ** padIsBlocking+    PadIsBlockingMethodInfo                 ,+    padIsBlocking                           ,+++-- ** padIsLinked+    PadIsLinkedMethodInfo                   ,+    padIsLinked                             ,+++-- ** padIterateInternalLinks+    PadIterateInternalLinksMethodInfo       ,+    padIterateInternalLinks                 ,+++-- ** padIterateInternalLinksDefault+    PadIterateInternalLinksDefaultMethodInfo,+    padIterateInternalLinksDefault          ,+++-- ** padLink+    PadLinkMethodInfo                       ,+    padLink                                 ,+++-- ** padLinkFull+    PadLinkFullMethodInfo                   ,+    padLinkFull                             ,+++-- ** padLinkGetName+    padLinkGetName                          ,+++-- ** padMarkReconfigure+    PadMarkReconfigureMethodInfo            ,+    padMarkReconfigure                      ,+++-- ** padNeedsReconfigure+    PadNeedsReconfigureMethodInfo           ,+    padNeedsReconfigure                     ,+++-- ** padNew+    padNew                                  ,+++-- ** padNewFromStaticTemplate+    padNewFromStaticTemplate                ,+++-- ** padNewFromTemplate+    padNewFromTemplate                      ,+++-- ** padPauseTask+    PadPauseTaskMethodInfo                  ,+    padPauseTask                            ,+++-- ** padPeerQuery+    PadPeerQueryMethodInfo                  ,+    padPeerQuery                            ,+++-- ** padPeerQueryAcceptCaps+    PadPeerQueryAcceptCapsMethodInfo        ,+    padPeerQueryAcceptCaps                  ,+++-- ** padPeerQueryCaps+    PadPeerQueryCapsMethodInfo              ,+    padPeerQueryCaps                        ,+++-- ** padPeerQueryConvert+    PadPeerQueryConvertMethodInfo           ,+    padPeerQueryConvert                     ,+++-- ** padPeerQueryDuration+    PadPeerQueryDurationMethodInfo          ,+    padPeerQueryDuration                    ,+++-- ** padPeerQueryPosition+    PadPeerQueryPositionMethodInfo          ,+    padPeerQueryPosition                    ,+++-- ** padProxyQueryAcceptCaps+    PadProxyQueryAcceptCapsMethodInfo       ,+    padProxyQueryAcceptCaps                 ,+++-- ** padProxyQueryCaps+    PadProxyQueryCapsMethodInfo             ,+    padProxyQueryCaps                       ,+++-- ** padPullRange+    PadPullRangeMethodInfo                  ,+    padPullRange                            ,+++-- ** padPush+    PadPushMethodInfo                       ,+    padPush                                 ,+++-- ** padPushEvent+    PadPushEventMethodInfo                  ,+    padPushEvent                            ,+++-- ** padPushList+    PadPushListMethodInfo                   ,+    padPushList                             ,+++-- ** padQuery+    PadQueryMethodInfo                      ,+    padQuery                                ,+++-- ** padQueryAcceptCaps+    PadQueryAcceptCapsMethodInfo            ,+    padQueryAcceptCaps                      ,+++-- ** padQueryCaps+    PadQueryCapsMethodInfo                  ,+    padQueryCaps                            ,+++-- ** padQueryConvert+    PadQueryConvertMethodInfo               ,+    padQueryConvert                         ,+++-- ** padQueryDefault+    PadQueryDefaultMethodInfo               ,+    padQueryDefault                         ,+++-- ** padQueryDuration+    PadQueryDurationMethodInfo              ,+    padQueryDuration                        ,+++-- ** padQueryPosition+    PadQueryPositionMethodInfo              ,+    padQueryPosition                        ,+++-- ** padRemoveProbe+    PadRemoveProbeMethodInfo                ,+    padRemoveProbe                          ,+++-- ** padSendEvent+    PadSendEventMethodInfo                  ,+    padSendEvent                            ,+++-- ** padSetActivateFunctionFull+    PadSetActivateFunctionFullMethodInfo    ,+    padSetActivateFunctionFull              ,+++-- ** padSetActivatemodeFunctionFull+    PadSetActivatemodeFunctionFullMethodInfo,+    padSetActivatemodeFunctionFull          ,+++-- ** padSetActive+    PadSetActiveMethodInfo                  ,+    padSetActive                            ,+++-- ** padSetChainFunctionFull+    PadSetChainFunctionFullMethodInfo       ,+    padSetChainFunctionFull                 ,+++-- ** padSetChainListFunctionFull+    PadSetChainListFunctionFullMethodInfo   ,+    padSetChainListFunctionFull             ,+++-- ** padSetElementPrivate+    PadSetElementPrivateMethodInfo          ,+    padSetElementPrivate                    ,+++-- ** padSetEventFunctionFull+    PadSetEventFunctionFullMethodInfo       ,+    padSetEventFunctionFull                 ,+++-- ** padSetGetrangeFunctionFull+    PadSetGetrangeFunctionFullMethodInfo    ,+    padSetGetrangeFunctionFull              ,+++-- ** padSetIterateInternalLinksFunctionFull+    PadSetIterateInternalLinksFunctionFullMethodInfo,+    padSetIterateInternalLinksFunctionFull  ,+++-- ** padSetLinkFunctionFull+    PadSetLinkFunctionFullMethodInfo        ,+    padSetLinkFunctionFull                  ,+++-- ** padSetOffset+    PadSetOffsetMethodInfo                  ,+    padSetOffset                            ,+++-- ** padSetQueryFunctionFull+    PadSetQueryFunctionFullMethodInfo       ,+    padSetQueryFunctionFull                 ,+++-- ** padSetUnlinkFunctionFull+    PadSetUnlinkFunctionFullMethodInfo      ,+    padSetUnlinkFunctionFull                ,+++-- ** padStartTask+    PadStartTaskMethodInfo                  ,+    padStartTask                            ,+++-- ** padStickyEventsForeach+    PadStickyEventsForeachMethodInfo        ,+    padStickyEventsForeach                  ,+++-- ** padStopTask+    PadStopTaskMethodInfo                   ,+    padStopTask                             ,+++-- ** padStoreStickyEvent+    PadStoreStickyEventMethodInfo           ,+    padStoreStickyEvent                     ,+++-- ** padUnlink+    PadUnlinkMethodInfo                     ,+    padUnlink                               ,+++-- ** padUseFixedCaps+    PadUseFixedCapsMethodInfo               ,+    padUseFixedCaps                         ,+++++ -- * Properties+-- ** Caps+    PadCapsPropertyInfo                     ,+    getPadCaps                              ,+++-- ** Direction+    PadDirectionPropertyInfo                ,+    constructPadDirection                   ,+    getPadDirection                         ,+++-- ** Offset+    PadOffsetPropertyInfo                   ,+    constructPadOffset                      ,+    getPadOffset                            ,+    setPadOffset                            ,+++-- ** Template+    PadTemplatePropertyInfo                 ,+    constructPadTemplate                    ,+    getPadTemplate                          ,+    setPadTemplate                          ,+++++ -- * Signals+-- ** Linked+    PadLinkedCallback                       ,+    PadLinkedCallbackC                      ,+    PadLinkedSignalInfo                     ,+    afterPadLinked                          ,+    mkPadLinkedCallback                     ,+    noPadLinkedCallback                     ,+    onPadLinked                             ,+    padLinkedCallbackWrapper                ,+    padLinkedClosure                        ,+++-- ** Unlinked+    PadUnlinkedCallback                     ,+    PadUnlinkedCallbackC                    ,+    PadUnlinkedSignalInfo                   ,+    afterPadUnlinked                        ,+    mkPadUnlinkedCallback                   ,+    noPadUnlinkedCallback                   ,+    onPadUnlinked                           ,+    padUnlinkedCallbackWrapper              ,+    padUnlinkedClosure                      ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Pad = Pad (ForeignPtr Pad)+foreign import ccall "gst_pad_get_type"+    c_gst_pad_get_type :: IO GType++type instance ParentTypes Pad = PadParentTypes+type PadParentTypes = '[Object, GObject.Object]++instance GObject Pad where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_pad_get_type+    ++class GObject o => PadK o+instance (GObject o, IsDescendantOf Pad o) => PadK o++toPad :: PadK o => o -> IO Pad+toPad = unsafeCastTo Pad++noPad :: Maybe Pad+noPad = Nothing++type family ResolvePadMethod (t :: Symbol) (o :: *) :: * where+    ResolvePadMethod "activateMode" o = PadActivateModeMethodInfo+    ResolvePadMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolvePadMethod "addProbe" o = PadAddProbeMethodInfo+    ResolvePadMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolvePadMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolvePadMethod "canLink" o = PadCanLinkMethodInfo+    ResolvePadMethod "chain" o = PadChainMethodInfo+    ResolvePadMethod "chainList" o = PadChainListMethodInfo+    ResolvePadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo+    ResolvePadMethod "createStreamId" o = PadCreateStreamIdMethodInfo+    ResolvePadMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolvePadMethod "eventDefault" o = PadEventDefaultMethodInfo+    ResolvePadMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolvePadMethod "forward" o = PadForwardMethodInfo+    ResolvePadMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolvePadMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolvePadMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolvePadMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolvePadMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolvePadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo+    ResolvePadMethod "isActive" o = PadIsActiveMethodInfo+    ResolvePadMethod "isBlocked" o = PadIsBlockedMethodInfo+    ResolvePadMethod "isBlocking" o = PadIsBlockingMethodInfo+    ResolvePadMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolvePadMethod "isLinked" o = PadIsLinkedMethodInfo+    ResolvePadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo+    ResolvePadMethod "iterateInternalLinksDefault" o = PadIterateInternalLinksDefaultMethodInfo+    ResolvePadMethod "link" o = PadLinkMethodInfo+    ResolvePadMethod "linkFull" o = PadLinkFullMethodInfo+    ResolvePadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo+    ResolvePadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo+    ResolvePadMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolvePadMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolvePadMethod "pauseTask" o = PadPauseTaskMethodInfo+    ResolvePadMethod "peerQuery" o = PadPeerQueryMethodInfo+    ResolvePadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo+    ResolvePadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo+    ResolvePadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo+    ResolvePadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo+    ResolvePadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo+    ResolvePadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo+    ResolvePadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo+    ResolvePadMethod "pullRange" o = PadPullRangeMethodInfo+    ResolvePadMethod "push" o = PadPushMethodInfo+    ResolvePadMethod "pushEvent" o = PadPushEventMethodInfo+    ResolvePadMethod "pushList" o = PadPushListMethodInfo+    ResolvePadMethod "query" o = PadQueryMethodInfo+    ResolvePadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo+    ResolvePadMethod "queryCaps" o = PadQueryCapsMethodInfo+    ResolvePadMethod "queryConvert" o = PadQueryConvertMethodInfo+    ResolvePadMethod "queryDefault" o = PadQueryDefaultMethodInfo+    ResolvePadMethod "queryDuration" o = PadQueryDurationMethodInfo+    ResolvePadMethod "queryPosition" o = PadQueryPositionMethodInfo+    ResolvePadMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolvePadMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolvePadMethod "removeProbe" o = PadRemoveProbeMethodInfo+    ResolvePadMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolvePadMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolvePadMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolvePadMethod "sendEvent" o = PadSendEventMethodInfo+    ResolvePadMethod "startTask" o = PadStartTaskMethodInfo+    ResolvePadMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolvePadMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolvePadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo+    ResolvePadMethod "stopTask" o = PadStopTaskMethodInfo+    ResolvePadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo+    ResolvePadMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolvePadMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolvePadMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolvePadMethod "unlink" o = PadUnlinkMethodInfo+    ResolvePadMethod "unparent" o = ObjectUnparentMethodInfo+    ResolvePadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo+    ResolvePadMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolvePadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo+    ResolvePadMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolvePadMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolvePadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo+    ResolvePadMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolvePadMethod "getDirection" o = PadGetDirectionMethodInfo+    ResolvePadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo+    ResolvePadMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolvePadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo+    ResolvePadMethod "getName" o = ObjectGetNameMethodInfo+    ResolvePadMethod "getOffset" o = PadGetOffsetMethodInfo+    ResolvePadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo+    ResolvePadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo+    ResolvePadMethod "getParent" o = ObjectGetParentMethodInfo+    ResolvePadMethod "getParentElement" o = PadGetParentElementMethodInfo+    ResolvePadMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolvePadMethod "getPeer" o = PadGetPeerMethodInfo+    ResolvePadMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolvePadMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolvePadMethod "getRange" o = PadGetRangeMethodInfo+    ResolvePadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo+    ResolvePadMethod "getStreamId" o = PadGetStreamIdMethodInfo+    ResolvePadMethod "getValue" o = ObjectGetValueMethodInfo+    ResolvePadMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolvePadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo+    ResolvePadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo+    ResolvePadMethod "setActive" o = PadSetActiveMethodInfo+    ResolvePadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo+    ResolvePadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo+    ResolvePadMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolvePadMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolvePadMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolvePadMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolvePadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo+    ResolvePadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo+    ResolvePadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo+    ResolvePadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo+    ResolvePadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo+    ResolvePadMethod "setName" o = ObjectSetNameMethodInfo+    ResolvePadMethod "setOffset" o = PadSetOffsetMethodInfo+    ResolvePadMethod "setParent" o = ObjectSetParentMethodInfo+    ResolvePadMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolvePadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo+    ResolvePadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo+    ResolvePadMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePadMethod t Pad, MethodInfo info Pad p) => IsLabelProxy t (Pad -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePadMethod t Pad, MethodInfo info Pad p) => IsLabel t (Pad -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Pad::linked+type PadLinkedCallback =+    Pad ->+    IO ()++noPadLinkedCallback :: Maybe PadLinkedCallback+noPadLinkedCallback = Nothing++type PadLinkedCallbackC =+    Ptr () ->                               -- object+    Ptr Pad ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPadLinkedCallback :: PadLinkedCallbackC -> IO (FunPtr PadLinkedCallbackC)++padLinkedClosure :: PadLinkedCallback -> IO Closure+padLinkedClosure cb = newCClosure =<< mkPadLinkedCallback wrapped+    where wrapped = padLinkedCallbackWrapper cb++padLinkedCallbackWrapper ::+    PadLinkedCallback ->+    Ptr () ->+    Ptr Pad ->+    Ptr () ->+    IO ()+padLinkedCallbackWrapper _cb _ peer _ = do+    peer' <- (newObject Pad) peer+    _cb  peer'++onPadLinked :: (GObject a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId+onPadLinked obj cb = liftIO $ connectPadLinked obj cb SignalConnectBefore+afterPadLinked :: (GObject a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId+afterPadLinked obj cb = connectPadLinked obj cb SignalConnectAfter++connectPadLinked :: (GObject a, MonadIO m) =>+                    a -> PadLinkedCallback -> SignalConnectMode -> m SignalHandlerId+connectPadLinked obj cb after = liftIO $ do+    cb' <- mkPadLinkedCallback (padLinkedCallbackWrapper cb)+    connectSignalFunPtr obj "linked" cb' after++-- signal Pad::unlinked+type PadUnlinkedCallback =+    Pad ->+    IO ()++noPadUnlinkedCallback :: Maybe PadUnlinkedCallback+noPadUnlinkedCallback = Nothing++type PadUnlinkedCallbackC =+    Ptr () ->                               -- object+    Ptr Pad ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPadUnlinkedCallback :: PadUnlinkedCallbackC -> IO (FunPtr PadUnlinkedCallbackC)++padUnlinkedClosure :: PadUnlinkedCallback -> IO Closure+padUnlinkedClosure cb = newCClosure =<< mkPadUnlinkedCallback wrapped+    where wrapped = padUnlinkedCallbackWrapper cb++padUnlinkedCallbackWrapper ::+    PadUnlinkedCallback ->+    Ptr () ->+    Ptr Pad ->+    Ptr () ->+    IO ()+padUnlinkedCallbackWrapper _cb _ peer _ = do+    peer' <- (newObject Pad) peer+    _cb  peer'++onPadUnlinked :: (GObject a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId+onPadUnlinked obj cb = liftIO $ connectPadUnlinked obj cb SignalConnectBefore+afterPadUnlinked :: (GObject a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId+afterPadUnlinked obj cb = connectPadUnlinked obj cb SignalConnectAfter++connectPadUnlinked :: (GObject a, MonadIO m) =>+                      a -> PadUnlinkedCallback -> SignalConnectMode -> m SignalHandlerId+connectPadUnlinked obj cb after = liftIO $ do+    cb' <- mkPadUnlinkedCallback (padUnlinkedCallbackWrapper cb)+    connectSignalFunPtr obj "unlinked" cb' after++-- VVV Prop "caps"+   -- Type: TInterface "Gst" "Caps"+   -- Flags: [PropertyReadable]++getPadCaps :: (MonadIO m, PadK o) => o -> m Caps+getPadCaps obj = liftIO $ getObjectPropertyBoxed obj "caps" Caps++data PadCapsPropertyInfo+instance AttrInfo PadCapsPropertyInfo where+    type AttrAllowedOps PadCapsPropertyInfo = '[ 'AttrGet]+    type AttrSetTypeConstraint PadCapsPropertyInfo = (~) ()+    type AttrBaseTypeConstraint PadCapsPropertyInfo = PadK+    type AttrGetType PadCapsPropertyInfo = Caps+    type AttrLabel PadCapsPropertyInfo = "caps"+    attrGet _ = getPadCaps+    attrSet _ = undefined+    attrConstruct _ = undefined++-- VVV Prop "direction"+   -- Type: TInterface "Gst" "PadDirection"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getPadDirection :: (MonadIO m, PadK o) => o -> m PadDirection+getPadDirection obj = liftIO $ getObjectPropertyEnum obj "direction"++constructPadDirection :: PadDirection -> IO ([Char], GValue)+constructPadDirection val = constructObjectPropertyEnum "direction" val++data PadDirectionPropertyInfo+instance AttrInfo PadDirectionPropertyInfo where+    type AttrAllowedOps PadDirectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PadDirectionPropertyInfo = (~) PadDirection+    type AttrBaseTypeConstraint PadDirectionPropertyInfo = PadK+    type AttrGetType PadDirectionPropertyInfo = PadDirection+    type AttrLabel PadDirectionPropertyInfo = "direction"+    attrGet _ = getPadDirection+    attrSet _ = undefined+    attrConstruct _ = constructPadDirection++-- VVV Prop "offset"+   -- Type: TBasicType TInt64+   -- Flags: [PropertyReadable,PropertyWritable]++getPadOffset :: (MonadIO m, PadK o) => o -> m Int64+getPadOffset obj = liftIO $ getObjectPropertyInt64 obj "offset"++setPadOffset :: (MonadIO m, PadK o) => o -> Int64 -> m ()+setPadOffset obj val = liftIO $ setObjectPropertyInt64 obj "offset" val++constructPadOffset :: Int64 -> IO ([Char], GValue)+constructPadOffset val = constructObjectPropertyInt64 "offset" val++data PadOffsetPropertyInfo+instance AttrInfo PadOffsetPropertyInfo where+    type AttrAllowedOps PadOffsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PadOffsetPropertyInfo = (~) Int64+    type AttrBaseTypeConstraint PadOffsetPropertyInfo = PadK+    type AttrGetType PadOffsetPropertyInfo = Int64+    type AttrLabel PadOffsetPropertyInfo = "offset"+    attrGet _ = getPadOffset+    attrSet _ = setPadOffset+    attrConstruct _ = constructPadOffset++-- VVV Prop "template"+   -- Type: TInterface "Gst" "PadTemplate"+   -- Flags: [PropertyReadable,PropertyWritable]++getPadTemplate :: (MonadIO m, PadK o) => o -> m PadTemplate+getPadTemplate obj = liftIO $ getObjectPropertyObject obj "template" PadTemplate++setPadTemplate :: (MonadIO m, PadK o, PadTemplateK a) => o -> a -> m ()+setPadTemplate obj val = liftIO $ setObjectPropertyObject obj "template" val++constructPadTemplate :: (PadTemplateK a) => a -> IO ([Char], GValue)+constructPadTemplate val = constructObjectPropertyObject "template" val++data PadTemplatePropertyInfo+instance AttrInfo PadTemplatePropertyInfo where+    type AttrAllowedOps PadTemplatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PadTemplatePropertyInfo = PadTemplateK+    type AttrBaseTypeConstraint PadTemplatePropertyInfo = PadK+    type AttrGetType PadTemplatePropertyInfo = PadTemplate+    type AttrLabel PadTemplatePropertyInfo = "template"+    attrGet _ = getPadTemplate+    attrSet _ = setPadTemplate+    attrConstruct _ = constructPadTemplate++type instance AttributeList Pad = PadAttributeList+type PadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])++data PadLinkedSignalInfo+instance SignalInfo PadLinkedSignalInfo where+    type HaskellCallbackType PadLinkedSignalInfo = PadLinkedCallback+    connectSignal _ = connectPadLinked++data PadUnlinkedSignalInfo+instance SignalInfo PadUnlinkedSignalInfo where+    type HaskellCallbackType PadUnlinkedSignalInfo = PadUnlinkedCallback+    connectSignal _ = connectPadUnlinked++type instance SignalList Pad = PadSignalList+type PadSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])++-- method Pad::new+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_new" gst_pad_new :: +    CString ->                              -- name : TBasicType TUTF8+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"+    IO (Ptr Pad)+++padNew ::+    (MonadIO m) =>+    Maybe (T.Text)                          -- name+    -> PadDirection                         -- direction+    -> m Pad                                -- result+padNew name direction = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    let direction' = (fromIntegral . fromEnum) direction+    result <- gst_pad_new maybeName direction'+    checkUnexpectedReturnNULL "gst_pad_new" result+    result' <- (newObject Pad) result+    freeMem maybeName+    return result'++-- method Pad::new_from_static_template+-- method type : Constructor+-- Args : [Arg {argCName = "templ", argType = TInterface "Gst" "StaticPadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_new_from_static_template" gst_pad_new_from_static_template :: +    Ptr StaticPadTemplate ->                -- templ : TInterface "Gst" "StaticPadTemplate"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Pad)+++padNewFromStaticTemplate ::+    (MonadIO m) =>+    StaticPadTemplate                       -- templ+    -> T.Text                               -- name+    -> m Pad                                -- result+padNewFromStaticTemplate templ name = liftIO $ do+    let templ' = unsafeManagedPtrGetPtr templ+    name' <- textToCString name+    result <- gst_pad_new_from_static_template templ' name'+    checkUnexpectedReturnNULL "gst_pad_new_from_static_template" result+    result' <- (newObject Pad) result+    touchManagedPtr templ+    freeMem name'+    return result'++-- method Pad::new_from_template+-- method type : Constructor+-- Args : [Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_new_from_template" gst_pad_new_from_template :: +    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Pad)+++padNewFromTemplate ::+    (MonadIO m, PadTemplateK a) =>+    a                                       -- templ+    -> Maybe (T.Text)                       -- name+    -> m Pad                                -- result+padNewFromTemplate templ name = liftIO $ do+    let templ' = unsafeManagedPtrCastPtr templ+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_pad_new_from_template templ' maybeName+    checkUnexpectedReturnNULL "gst_pad_new_from_template" result+    result' <- (newObject Pad) result+    touchManagedPtr templ+    freeMem maybeName+    return result'++-- method Pad::activate_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_activate_mode" gst_pad_activate_mode :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++padActivateMode ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadMode                              -- mode+    -> Bool                                 -- active+    -> m Bool                               -- result+padActivateMode _obj mode active = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    let active' = (fromIntegral . fromEnum) active+    result <- gst_pad_activate_mode _obj' mode' active'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadActivateModeMethodInfo+instance (signature ~ (PadMode -> Bool -> m Bool), MonadIO m, PadK a) => MethodInfo PadActivateModeMethodInfo a signature where+    overloadedMethod _ = padActivateMode++-- method Pad::add_probe+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TInterface "Gst" "PadProbeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface "Gst" "PadProbeCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_data", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_add_probe" gst_pad_add_probe :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- mask : TInterface "Gst" "PadProbeType"+    FunPtr PadProbeCallbackC ->             -- callback : TInterface "Gst" "PadProbeCallback"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy_data : TInterface "GLib" "DestroyNotify"+    IO Word64+++padAddProbe ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> [PadProbeType]                       -- mask+    -> PadProbeCallback                     -- callback+    -> m Word64                             -- result+padAddProbe _obj mask callback = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mask' = gflagsToWord mask+    callback' <- mkPadProbeCallback (padProbeCallbackWrapper Nothing callback)+    let userData = castFunPtrToPtr callback'+    let destroyData = safeFreeFunPtrPtr+    result <- gst_pad_add_probe _obj' mask' callback' userData destroyData+    touchManagedPtr _obj+    return result++data PadAddProbeMethodInfo+instance (signature ~ ([PadProbeType] -> PadProbeCallback -> m Word64), MonadIO m, PadK a) => MethodInfo PadAddProbeMethodInfo a signature where+    overloadedMethod _ = padAddProbe++-- method Pad::can_link+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_can_link" gst_pad_can_link :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"+    IO CInt+++padCanLink ::+    (MonadIO m, PadK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- sinkpad+    -> m Bool                               -- result+padCanLink _obj sinkpad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad+    result <- gst_pad_can_link _obj' sinkpad'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr sinkpad+    return result'++data PadCanLinkMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, PadK a, PadK b) => MethodInfo PadCanLinkMethodInfo a signature where+    overloadedMethod _ = padCanLink++-- method Pad::chain+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_chain" gst_pad_chain :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO CUInt+++padChain ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Buffer                               -- buffer+    -> m FlowReturn                         -- result+padChain _obj buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- copyBoxed buffer+    result <- gst_pad_chain _obj' buffer'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr buffer+    return result'++data PadChainMethodInfo+instance (signature ~ (Buffer -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadChainMethodInfo a signature where+    overloadedMethod _ = padChain++-- method Pad::chain_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_chain_list" gst_pad_chain_list :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr BufferList ->                       -- list : TInterface "Gst" "BufferList"+    IO CUInt+++padChainList ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> BufferList                           -- list+    -> m FlowReturn                         -- result+padChainList _obj list = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    list' <- copyBoxed list+    result <- gst_pad_chain_list _obj' list'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr list+    return result'++data PadChainListMethodInfo+instance (signature ~ (BufferList -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadChainListMethodInfo a signature where+    overloadedMethod _ = padChainList++-- method Pad::check_reconfigure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_check_reconfigure" gst_pad_check_reconfigure :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padCheckReconfigure ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padCheckReconfigure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_check_reconfigure _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadCheckReconfigureMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadCheckReconfigureMethodInfo a signature where+    overloadedMethod _ = padCheckReconfigure++-- method Pad::create_stream_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_create_stream_id" gst_pad_create_stream_id :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Element ->                          -- parent : TInterface "Gst" "Element"+    CString ->                              -- stream_id : TBasicType TUTF8+    IO CString+++padCreateStreamId ::+    (MonadIO m, PadK a, ElementK b) =>+    a                                       -- _obj+    -> b                                    -- parent+    -> Maybe (T.Text)                       -- streamId+    -> m T.Text                             -- result+padCreateStreamId _obj parent streamId = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let parent' = unsafeManagedPtrCastPtr parent+    maybeStreamId <- case streamId of+        Nothing -> return nullPtr+        Just jStreamId -> do+            jStreamId' <- textToCString jStreamId+            return jStreamId'+    result <- gst_pad_create_stream_id _obj' parent' maybeStreamId+    checkUnexpectedReturnNULL "gst_pad_create_stream_id" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    touchManagedPtr parent+    freeMem maybeStreamId+    return result'++data PadCreateStreamIdMethodInfo+instance (signature ~ (b -> Maybe (T.Text) -> m T.Text), MonadIO m, PadK a, ElementK b) => MethodInfo PadCreateStreamIdMethodInfo a signature where+    overloadedMethod _ = padCreateStreamId++-- method Pad::event_default+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_event_default" gst_pad_event_default :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    Ptr Event ->                            -- event : TInterface "Gst" "Event"+    IO CInt+++padEventDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- _obj+    -> Maybe (b)                            -- parent+    -> Event                                -- event+    -> m Bool                               -- result+padEventDefault _obj parent event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    event' <- copyBoxed event+    result <- gst_pad_event_default _obj' maybeParent event'+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust parent touchManagedPtr+    touchManagedPtr event+    return result'++data PadEventDefaultMethodInfo+instance (signature ~ (Maybe (b) -> Event -> m Bool), MonadIO m, PadK a, ObjectK b) => MethodInfo PadEventDefaultMethodInfo a signature where+    overloadedMethod _ = padEventDefault++-- method Pad::forward+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "forward", argType = TInterface "Gst" "PadForwardFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_forward" gst_pad_forward :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadForwardFunctionC ->           -- forward : TInterface "Gst" "PadForwardFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++padForward ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadForwardFunction                   -- forward+    -> m Bool                               -- result+padForward _obj forward = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    forward' <- mkPadForwardFunction (padForwardFunctionWrapper Nothing forward)+    let userData = nullPtr+    result <- gst_pad_forward _obj' forward' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr forward'+    touchManagedPtr _obj+    return result'++data PadForwardMethodInfo+instance (signature ~ (PadForwardFunction -> m Bool), MonadIO m, PadK a) => MethodInfo PadForwardMethodInfo a signature where+    overloadedMethod _ = padForward++-- method Pad::get_allowed_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_allowed_caps" gst_pad_get_allowed_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO (Ptr Caps)+++padGetAllowedCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Caps                               -- result+padGetAllowedCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_allowed_caps _obj'+    checkUnexpectedReturnNULL "gst_pad_get_allowed_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data PadGetAllowedCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m, PadK a) => MethodInfo PadGetAllowedCapsMethodInfo a signature where+    overloadedMethod _ = padGetAllowedCaps++-- method Pad::get_current_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_current_caps" gst_pad_get_current_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO (Ptr Caps)+++padGetCurrentCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Caps                               -- result+padGetCurrentCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_current_caps _obj'+    checkUnexpectedReturnNULL "gst_pad_get_current_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data PadGetCurrentCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m, PadK a) => MethodInfo PadGetCurrentCapsMethodInfo a signature where+    overloadedMethod _ = padGetCurrentCaps++-- method Pad::get_direction+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadDirection"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_direction" gst_pad_get_direction :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CUInt+++padGetDirection ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m PadDirection                       -- result+padGetDirection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_direction _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data PadGetDirectionMethodInfo+instance (signature ~ (m PadDirection), MonadIO m, PadK a) => MethodInfo PadGetDirectionMethodInfo a signature where+    overloadedMethod _ = padGetDirection++-- method Pad::get_element_private+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_element_private" gst_pad_get_element_private :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO ()+++padGetElementPrivate ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+padGetElementPrivate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pad_get_element_private _obj'+    touchManagedPtr _obj+    return ()++data PadGetElementPrivateMethodInfo+instance (signature ~ (m ()), MonadIO m, PadK a) => MethodInfo PadGetElementPrivateMethodInfo a signature where+    overloadedMethod _ = padGetElementPrivate++-- method Pad::get_last_flow_return+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_last_flow_return" gst_pad_get_last_flow_return :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CUInt+++padGetLastFlowReturn ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m FlowReturn                         -- result+padGetLastFlowReturn _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_last_flow_return _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data PadGetLastFlowReturnMethodInfo+instance (signature ~ (m FlowReturn), MonadIO m, PadK a) => MethodInfo PadGetLastFlowReturnMethodInfo a signature where+    overloadedMethod _ = padGetLastFlowReturn++-- method Pad::get_offset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_offset" gst_pad_get_offset :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO Int64+++padGetOffset ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Int64                              -- result+padGetOffset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_offset _obj'+    touchManagedPtr _obj+    return result++data PadGetOffsetMethodInfo+instance (signature ~ (m Int64), MonadIO m, PadK a) => MethodInfo PadGetOffsetMethodInfo a signature where+    overloadedMethod _ = padGetOffset++-- method Pad::get_pad_template+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadTemplate"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_pad_template" gst_pad_get_pad_template :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO (Ptr PadTemplate)+++padGetPadTemplate ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m PadTemplate                        -- result+padGetPadTemplate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_pad_template _obj'+    checkUnexpectedReturnNULL "gst_pad_get_pad_template" result+    result' <- (wrapObject PadTemplate) result+    touchManagedPtr _obj+    return result'++data PadGetPadTemplateMethodInfo+instance (signature ~ (m PadTemplate), MonadIO m, PadK a) => MethodInfo PadGetPadTemplateMethodInfo a signature where+    overloadedMethod _ = padGetPadTemplate++-- method Pad::get_pad_template_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_pad_template_caps" gst_pad_get_pad_template_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO (Ptr Caps)+++padGetPadTemplateCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Caps                               -- result+padGetPadTemplateCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_pad_template_caps _obj'+    checkUnexpectedReturnNULL "gst_pad_get_pad_template_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data PadGetPadTemplateCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m, PadK a) => MethodInfo PadGetPadTemplateCapsMethodInfo a signature where+    overloadedMethod _ = padGetPadTemplateCaps++-- method Pad::get_parent_element+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Element"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_parent_element" gst_pad_get_parent_element :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO (Ptr Element)+++padGetParentElement ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Element                            -- result+padGetParentElement _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_parent_element _obj'+    checkUnexpectedReturnNULL "gst_pad_get_parent_element" result+    result' <- (wrapObject Element) result+    touchManagedPtr _obj+    return result'++data PadGetParentElementMethodInfo+instance (signature ~ (m Element), MonadIO m, PadK a) => MethodInfo PadGetParentElementMethodInfo a signature where+    overloadedMethod _ = padGetParentElement++-- method Pad::get_peer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_peer" gst_pad_get_peer :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO (Ptr Pad)+++padGetPeer ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Pad                                -- result+padGetPeer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_peer _obj'+    checkUnexpectedReturnNULL "gst_pad_get_peer" result+    result' <- (wrapObject Pad) result+    touchManagedPtr _obj+    return result'++data PadGetPeerMethodInfo+instance (signature ~ (m Pad), MonadIO m, PadK a) => MethodInfo PadGetPeerMethodInfo a signature where+    overloadedMethod _ = padGetPeer++-- method Pad::get_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_range" gst_pad_get_range :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word32 ->                               -- size : TBasicType TUInt32+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO CUInt+++padGetRange ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Word64                               -- offset+    -> Word32                               -- size+    -> m (FlowReturn,Buffer)                -- result+padGetRange _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)+    result <- gst_pad_get_range _obj' offset size buffer+    let result' = (toEnum . fromIntegral) result+    buffer' <- (wrapBoxed Buffer) buffer+    touchManagedPtr _obj+    return (result', buffer')++data PadGetRangeMethodInfo+instance (signature ~ (Word64 -> Word32 -> m (FlowReturn,Buffer)), MonadIO m, PadK a) => MethodInfo PadGetRangeMethodInfo a signature where+    overloadedMethod _ = padGetRange++-- method Pad::get_sticky_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event_type", argType = TInterface "Gst" "EventType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_sticky_event" gst_pad_get_sticky_event :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- event_type : TInterface "Gst" "EventType"+    Word32 ->                               -- idx : TBasicType TUInt32+    IO (Ptr Event)+++padGetStickyEvent ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> EventType                            -- eventType+    -> Word32                               -- idx+    -> m Event                              -- result+padGetStickyEvent _obj eventType idx = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let eventType' = (fromIntegral . fromEnum) eventType+    result <- gst_pad_get_sticky_event _obj' eventType' idx+    checkUnexpectedReturnNULL "gst_pad_get_sticky_event" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr _obj+    return result'++data PadGetStickyEventMethodInfo+instance (signature ~ (EventType -> Word32 -> m Event), MonadIO m, PadK a) => MethodInfo PadGetStickyEventMethodInfo a signature where+    overloadedMethod _ = padGetStickyEvent++-- method Pad::get_stream_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_get_stream_id" gst_pad_get_stream_id :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CString+++padGetStreamId ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+padGetStreamId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_get_stream_id _obj'+    checkUnexpectedReturnNULL "gst_pad_get_stream_id" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data PadGetStreamIdMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PadK a) => MethodInfo PadGetStreamIdMethodInfo a signature where+    overloadedMethod _ = padGetStreamId++-- method Pad::has_current_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_has_current_caps" gst_pad_has_current_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padHasCurrentCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padHasCurrentCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_has_current_caps _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadHasCurrentCapsMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadHasCurrentCapsMethodInfo a signature where+    overloadedMethod _ = padHasCurrentCaps++-- method Pad::is_active+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_is_active" gst_pad_is_active :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padIsActive ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padIsActive _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_is_active _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadIsActiveMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsActiveMethodInfo a signature where+    overloadedMethod _ = padIsActive++-- method Pad::is_blocked+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_is_blocked" gst_pad_is_blocked :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padIsBlocked ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padIsBlocked _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_is_blocked _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadIsBlockedMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsBlockedMethodInfo a signature where+    overloadedMethod _ = padIsBlocked++-- method Pad::is_blocking+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_is_blocking" gst_pad_is_blocking :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padIsBlocking ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padIsBlocking _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_is_blocking _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadIsBlockingMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsBlockingMethodInfo a signature where+    overloadedMethod _ = padIsBlocking++-- method Pad::is_linked+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_is_linked" gst_pad_is_linked :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padIsLinked ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padIsLinked _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_is_linked _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadIsLinkedMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsLinkedMethodInfo a signature where+    overloadedMethod _ = padIsLinked++-- method Pad::iterate_internal_links+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_iterate_internal_links" gst_pad_iterate_internal_links :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO (Ptr Iterator)+++padIterateInternalLinks ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Iterator                           -- result+padIterateInternalLinks _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_iterate_internal_links _obj'+    checkUnexpectedReturnNULL "gst_pad_iterate_internal_links" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data PadIterateInternalLinksMethodInfo+instance (signature ~ (m Iterator), MonadIO m, PadK a) => MethodInfo PadIterateInternalLinksMethodInfo a signature where+    overloadedMethod _ = padIterateInternalLinks++-- method Pad::iterate_internal_links_default+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_iterate_internal_links_default" gst_pad_iterate_internal_links_default :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    IO (Ptr Iterator)+++padIterateInternalLinksDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- _obj+    -> Maybe (b)                            -- parent+    -> m Iterator                           -- result+padIterateInternalLinksDefault _obj parent = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    result <- gst_pad_iterate_internal_links_default _obj' maybeParent+    checkUnexpectedReturnNULL "gst_pad_iterate_internal_links_default" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    whenJust parent touchManagedPtr+    return result'++data PadIterateInternalLinksDefaultMethodInfo+instance (signature ~ (Maybe (b) -> m Iterator), MonadIO m, PadK a, ObjectK b) => MethodInfo PadIterateInternalLinksDefaultMethodInfo a signature where+    overloadedMethod _ = padIterateInternalLinksDefault++-- method Pad::link+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadLinkReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_link" gst_pad_link :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"+    IO CUInt+++padLink ::+    (MonadIO m, PadK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- sinkpad+    -> m PadLinkReturn                      -- result+padLink _obj sinkpad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad+    result <- gst_pad_link _obj' sinkpad'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr sinkpad+    return result'++data PadLinkMethodInfo+instance (signature ~ (b -> m PadLinkReturn), MonadIO m, PadK a, PadK b) => MethodInfo PadLinkMethodInfo a signature where+    overloadedMethod _ = padLink++-- method Pad::link_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PadLinkCheck", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadLinkReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_link_full" gst_pad_link_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"+    CUInt ->                                -- flags : TInterface "Gst" "PadLinkCheck"+    IO CUInt+++padLinkFull ::+    (MonadIO m, PadK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- sinkpad+    -> [PadLinkCheck]                       -- flags+    -> m PadLinkReturn                      -- result+padLinkFull _obj sinkpad flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad+    let flags' = gflagsToWord flags+    result <- gst_pad_link_full _obj' sinkpad' flags'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr sinkpad+    return result'++data PadLinkFullMethodInfo+instance (signature ~ (b -> [PadLinkCheck] -> m PadLinkReturn), MonadIO m, PadK a, PadK b) => MethodInfo PadLinkFullMethodInfo a signature where+    overloadedMethod _ = padLinkFull++-- method Pad::mark_reconfigure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_mark_reconfigure" gst_pad_mark_reconfigure :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO ()+++padMarkReconfigure ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+padMarkReconfigure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pad_mark_reconfigure _obj'+    touchManagedPtr _obj+    return ()++data PadMarkReconfigureMethodInfo+instance (signature ~ (m ()), MonadIO m, PadK a) => MethodInfo PadMarkReconfigureMethodInfo a signature where+    overloadedMethod _ = padMarkReconfigure++-- method Pad::needs_reconfigure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_needs_reconfigure" gst_pad_needs_reconfigure :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padNeedsReconfigure ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padNeedsReconfigure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_needs_reconfigure _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadNeedsReconfigureMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadNeedsReconfigureMethodInfo a signature where+    overloadedMethod _ = padNeedsReconfigure++-- method Pad::pause_task+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_pause_task" gst_pad_pause_task :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padPauseTask ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padPauseTask _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_pause_task _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadPauseTaskMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadPauseTaskMethodInfo a signature where+    overloadedMethod _ = padPauseTask++-- method Pad::peer_query+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_peer_query" gst_pad_peer_query :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Query ->                            -- query : TInterface "Gst" "Query"+    IO CInt+++padPeerQuery ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Query                                -- query+    -> m Bool                               -- result+padPeerQuery _obj query = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_pad_peer_query _obj' query'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr query+    return result'++data PadPeerQueryMethodInfo+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadPeerQueryMethodInfo a signature where+    overloadedMethod _ = padPeerQuery++-- method Pad::peer_query_accept_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_peer_query_accept_caps" gst_pad_peer_query_accept_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO CInt+++padPeerQueryAcceptCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Caps                                 -- caps+    -> m Bool                               -- result+padPeerQueryAcceptCaps _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_pad_peer_query_accept_caps _obj' caps'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps+    return result'++data PadPeerQueryAcceptCapsMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m, PadK a) => MethodInfo PadPeerQueryAcceptCapsMethodInfo a signature where+    overloadedMethod _ = padPeerQueryAcceptCaps++-- method Pad::peer_query_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_peer_query_caps" gst_pad_peer_query_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++padPeerQueryCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Maybe (Caps)                         -- filter+    -> m Caps                               -- result+padPeerQueryCaps _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFilter <- case filter of+        Nothing -> return nullPtr+        Just jFilter -> do+            let jFilter' = unsafeManagedPtrGetPtr jFilter+            return jFilter'+    result <- gst_pad_peer_query_caps _obj' maybeFilter+    checkUnexpectedReturnNULL "gst_pad_peer_query_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    whenJust filter touchManagedPtr+    return result'++data PadPeerQueryCapsMethodInfo+instance (signature ~ (Maybe (Caps) -> m Caps), MonadIO m, PadK a) => MethodInfo PadPeerQueryCapsMethodInfo a signature where+    overloadedMethod _ = padPeerQueryCaps++-- method Pad::peer_query_convert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_peer_query_convert" gst_pad_peer_query_convert :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- src_format : TInterface "Gst" "Format"+    Int64 ->                                -- src_val : TBasicType TInt64+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- dest_val : TBasicType TInt64+    IO CInt+++padPeerQueryConvert ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Format                               -- srcFormat+    -> Int64                                -- srcVal+    -> Format                               -- destFormat+    -> m (Bool,Int64)                       -- result+padPeerQueryConvert _obj srcFormat srcVal destFormat = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let srcFormat' = (fromIntegral . fromEnum) srcFormat+    let destFormat' = (fromIntegral . fromEnum) destFormat+    destVal <- allocMem :: IO (Ptr Int64)+    result <- gst_pad_peer_query_convert _obj' srcFormat' srcVal destFormat' destVal+    let result' = (/= 0) result+    destVal' <- peek destVal+    touchManagedPtr _obj+    freeMem destVal+    return (result', destVal')++data PadPeerQueryConvertMethodInfo+instance (signature ~ (Format -> Int64 -> Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadPeerQueryConvertMethodInfo a signature where+    overloadedMethod _ = padPeerQueryConvert++-- method Pad::peer_query_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_peer_query_duration" gst_pad_peer_query_duration :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- duration : TBasicType TInt64+    IO CInt+++padPeerQueryDuration ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Format                               -- format+    -> m (Bool,Int64)                       -- result+padPeerQueryDuration _obj format = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let format' = (fromIntegral . fromEnum) format+    duration <- allocMem :: IO (Ptr Int64)+    result <- gst_pad_peer_query_duration _obj' format' duration+    let result' = (/= 0) result+    duration' <- peek duration+    touchManagedPtr _obj+    freeMem duration+    return (result', duration')++data PadPeerQueryDurationMethodInfo+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadPeerQueryDurationMethodInfo a signature where+    overloadedMethod _ = padPeerQueryDuration++-- method Pad::peer_query_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_peer_query_position" gst_pad_peer_query_position :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- cur : TBasicType TInt64+    IO CInt+++padPeerQueryPosition ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Format                               -- format+    -> m (Bool,Int64)                       -- result+padPeerQueryPosition _obj format = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let format' = (fromIntegral . fromEnum) format+    cur <- allocMem :: IO (Ptr Int64)+    result <- gst_pad_peer_query_position _obj' format' cur+    let result' = (/= 0) result+    cur' <- peek cur+    touchManagedPtr _obj+    freeMem cur+    return (result', cur')++data PadPeerQueryPositionMethodInfo+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadPeerQueryPositionMethodInfo a signature where+    overloadedMethod _ = padPeerQueryPosition++-- method Pad::proxy_query_accept_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_proxy_query_accept_caps" gst_pad_proxy_query_accept_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Query ->                            -- query : TInterface "Gst" "Query"+    IO CInt+++padProxyQueryAcceptCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Query                                -- query+    -> m Bool                               -- result+padProxyQueryAcceptCaps _obj query = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_pad_proxy_query_accept_caps _obj' query'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr query+    return result'++data PadProxyQueryAcceptCapsMethodInfo+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadProxyQueryAcceptCapsMethodInfo a signature where+    overloadedMethod _ = padProxyQueryAcceptCaps++-- method Pad::proxy_query_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_proxy_query_caps" gst_pad_proxy_query_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Query ->                            -- query : TInterface "Gst" "Query"+    IO CInt+++padProxyQueryCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Query                                -- query+    -> m Bool                               -- result+padProxyQueryCaps _obj query = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_pad_proxy_query_caps _obj' query'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr query+    return result'++data PadProxyQueryCapsMethodInfo+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadProxyQueryCapsMethodInfo a signature where+    overloadedMethod _ = padProxyQueryCaps++-- method Pad::pull_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_pull_range" gst_pad_pull_range :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word32 ->                               -- size : TBasicType TUInt32+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO CUInt+++padPullRange ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Word64                               -- offset+    -> Word32                               -- size+    -> m (FlowReturn,Buffer)                -- result+padPullRange _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)+    result <- gst_pad_pull_range _obj' offset size buffer+    let result' = (toEnum . fromIntegral) result+    buffer' <- (wrapBoxed Buffer) buffer+    touchManagedPtr _obj+    return (result', buffer')++data PadPullRangeMethodInfo+instance (signature ~ (Word64 -> Word32 -> m (FlowReturn,Buffer)), MonadIO m, PadK a) => MethodInfo PadPullRangeMethodInfo a signature where+    overloadedMethod _ = padPullRange++-- method Pad::push+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_push" gst_pad_push :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO CUInt+++padPush ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Buffer                               -- buffer+    -> m FlowReturn                         -- result+padPush _obj buffer = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    buffer' <- copyBoxed buffer+    result <- gst_pad_push _obj' buffer'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr buffer+    return result'++data PadPushMethodInfo+instance (signature ~ (Buffer -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadPushMethodInfo a signature where+    overloadedMethod _ = padPush++-- method Pad::push_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_push_event" gst_pad_push_event :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Event ->                            -- event : TInterface "Gst" "Event"+    IO CInt+++padPushEvent ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Event                                -- event+    -> m Bool                               -- result+padPushEvent _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    event' <- copyBoxed event+    result <- gst_pad_push_event _obj' event'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr event+    return result'++data PadPushEventMethodInfo+instance (signature ~ (Event -> m Bool), MonadIO m, PadK a) => MethodInfo PadPushEventMethodInfo a signature where+    overloadedMethod _ = padPushEvent++-- method Pad::push_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_push_list" gst_pad_push_list :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr BufferList ->                       -- list : TInterface "Gst" "BufferList"+    IO CUInt+++padPushList ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> BufferList                           -- list+    -> m FlowReturn                         -- result+padPushList _obj list = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    list' <- copyBoxed list+    result <- gst_pad_push_list _obj' list'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr list+    return result'++data PadPushListMethodInfo+instance (signature ~ (BufferList -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadPushListMethodInfo a signature where+    overloadedMethod _ = padPushList++-- method Pad::query+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_query" gst_pad_query :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Query ->                            -- query : TInterface "Gst" "Query"+    IO CInt+++padQuery ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Query                                -- query+    -> m Bool                               -- result+padQuery _obj query = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_pad_query _obj' query'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr query+    return result'++data PadQueryMethodInfo+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadQueryMethodInfo a signature where+    overloadedMethod _ = padQuery++-- method Pad::query_accept_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_query_accept_caps" gst_pad_query_accept_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO CInt+++padQueryAcceptCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Caps                                 -- caps+    -> m Bool                               -- result+padQueryAcceptCaps _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_pad_query_accept_caps _obj' caps'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps+    return result'++data PadQueryAcceptCapsMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m, PadK a) => MethodInfo PadQueryAcceptCapsMethodInfo a signature where+    overloadedMethod _ = padQueryAcceptCaps++-- method Pad::query_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_query_caps" gst_pad_query_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++padQueryCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Maybe (Caps)                         -- filter+    -> m Caps                               -- result+padQueryCaps _obj filter = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeFilter <- case filter of+        Nothing -> return nullPtr+        Just jFilter -> do+            let jFilter' = unsafeManagedPtrGetPtr jFilter+            return jFilter'+    result <- gst_pad_query_caps _obj' maybeFilter+    checkUnexpectedReturnNULL "gst_pad_query_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    whenJust filter touchManagedPtr+    return result'++data PadQueryCapsMethodInfo+instance (signature ~ (Maybe (Caps) -> m Caps), MonadIO m, PadK a) => MethodInfo PadQueryCapsMethodInfo a signature where+    overloadedMethod _ = padQueryCaps++-- method Pad::query_convert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_query_convert" gst_pad_query_convert :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- src_format : TInterface "Gst" "Format"+    Int64 ->                                -- src_val : TBasicType TInt64+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- dest_val : TBasicType TInt64+    IO CInt+++padQueryConvert ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Format                               -- srcFormat+    -> Int64                                -- srcVal+    -> Format                               -- destFormat+    -> m (Bool,Int64)                       -- result+padQueryConvert _obj srcFormat srcVal destFormat = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let srcFormat' = (fromIntegral . fromEnum) srcFormat+    let destFormat' = (fromIntegral . fromEnum) destFormat+    destVal <- allocMem :: IO (Ptr Int64)+    result <- gst_pad_query_convert _obj' srcFormat' srcVal destFormat' destVal+    let result' = (/= 0) result+    destVal' <- peek destVal+    touchManagedPtr _obj+    freeMem destVal+    return (result', destVal')++data PadQueryConvertMethodInfo+instance (signature ~ (Format -> Int64 -> Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadQueryConvertMethodInfo a signature where+    overloadedMethod _ = padQueryConvert++-- method Pad::query_default+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_query_default" gst_pad_query_default :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    Ptr Query ->                            -- query : TInterface "Gst" "Query"+    IO CInt+++padQueryDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- _obj+    -> Maybe (b)                            -- parent+    -> Query                                -- query+    -> m Bool                               -- result+padQueryDefault _obj parent query = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    let query' = unsafeManagedPtrGetPtr query+    result <- gst_pad_query_default _obj' maybeParent query'+    let result' = (/= 0) result+    touchManagedPtr _obj+    whenJust parent touchManagedPtr+    touchManagedPtr query+    return result'++data PadQueryDefaultMethodInfo+instance (signature ~ (Maybe (b) -> Query -> m Bool), MonadIO m, PadK a, ObjectK b) => MethodInfo PadQueryDefaultMethodInfo a signature where+    overloadedMethod _ = padQueryDefault++-- method Pad::query_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_query_duration" gst_pad_query_duration :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- duration : TBasicType TInt64+    IO CInt+++padQueryDuration ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Format                               -- format+    -> m (Bool,Int64)                       -- result+padQueryDuration _obj format = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let format' = (fromIntegral . fromEnum) format+    duration <- allocMem :: IO (Ptr Int64)+    result <- gst_pad_query_duration _obj' format' duration+    let result' = (/= 0) result+    duration' <- peek duration+    touchManagedPtr _obj+    freeMem duration+    return (result', duration')++data PadQueryDurationMethodInfo+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadQueryDurationMethodInfo a signature where+    overloadedMethod _ = padQueryDuration++-- method Pad::query_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_query_position" gst_pad_query_position :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- cur : TBasicType TInt64+    IO CInt+++padQueryPosition ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Format                               -- format+    -> m (Bool,Int64)                       -- result+padQueryPosition _obj format = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let format' = (fromIntegral . fromEnum) format+    cur <- allocMem :: IO (Ptr Int64)+    result <- gst_pad_query_position _obj' format' cur+    let result' = (/= 0) result+    cur' <- peek cur+    touchManagedPtr _obj+    freeMem cur+    return (result', cur')++data PadQueryPositionMethodInfo+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadQueryPositionMethodInfo a signature where+    overloadedMethod _ = padQueryPosition++-- method Pad::remove_probe+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_remove_probe" gst_pad_remove_probe :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Word64 ->                               -- id : TBasicType TUInt64+    IO ()+++padRemoveProbe ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Word64                               -- id+    -> m ()                                 -- result+padRemoveProbe _obj id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pad_remove_probe _obj' id+    touchManagedPtr _obj+    return ()++data PadRemoveProbeMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, PadK a) => MethodInfo PadRemoveProbeMethodInfo a signature where+    overloadedMethod _ = padRemoveProbe++-- method Pad::send_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_send_event" gst_pad_send_event :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Event ->                            -- event : TInterface "Gst" "Event"+    IO CInt+++padSendEvent ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Event                                -- event+    -> m Bool                               -- result+padSendEvent _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    event' <- copyBoxed event+    result <- gst_pad_send_event _obj' event'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr event+    return result'++data PadSendEventMethodInfo+instance (signature ~ (Event -> m Bool), MonadIO m, PadK a) => MethodInfo PadSendEventMethodInfo a signature where+    overloadedMethod _ = padSendEvent++-- method Pad::set_activate_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "activate", argType = TInterface "Gst" "PadActivateFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_activate_function_full" gst_pad_set_activate_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadActivateFunctionC ->          -- activate : TInterface "Gst" "PadActivateFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetActivateFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadActivateFunction                  -- activate+    -> m ()                                 -- result+padSetActivateFunctionFull _obj activate = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    activate' <- mkPadActivateFunction (padActivateFunctionWrapper Nothing activate)+    let userData = castFunPtrToPtr activate'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_activate_function_full _obj' activate' userData notify+    touchManagedPtr _obj+    return ()++data PadSetActivateFunctionFullMethodInfo+instance (signature ~ (PadActivateFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetActivateFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetActivateFunctionFull++-- method Pad::set_activatemode_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "activatemode", argType = TInterface "Gst" "PadActivateModeFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_activatemode_function_full" gst_pad_set_activatemode_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadActivateModeFunctionC ->      -- activatemode : TInterface "Gst" "PadActivateModeFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetActivatemodeFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadActivateModeFunction              -- activatemode+    -> m ()                                 -- result+padSetActivatemodeFunctionFull _obj activatemode = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    activatemode' <- mkPadActivateModeFunction (padActivateModeFunctionWrapper Nothing activatemode)+    let userData = castFunPtrToPtr activatemode'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_activatemode_function_full _obj' activatemode' userData notify+    touchManagedPtr _obj+    return ()++data PadSetActivatemodeFunctionFullMethodInfo+instance (signature ~ (PadActivateModeFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetActivatemodeFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetActivatemodeFunctionFull++-- method Pad::set_active+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_active" gst_pad_set_active :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++padSetActive ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Bool                                 -- active+    -> m Bool                               -- result+padSetActive _obj active = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let active' = (fromIntegral . fromEnum) active+    result <- gst_pad_set_active _obj' active'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadSetActiveMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m, PadK a) => MethodInfo PadSetActiveMethodInfo a signature where+    overloadedMethod _ = padSetActive++-- method Pad::set_chain_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chain", argType = TInterface "Gst" "PadChainFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_chain_function_full" gst_pad_set_chain_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadChainFunctionC ->             -- chain : TInterface "Gst" "PadChainFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetChainFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadChainFunction                     -- chain+    -> m ()                                 -- result+padSetChainFunctionFull _obj chain = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    chain' <- mkPadChainFunction (padChainFunctionWrapper Nothing chain)+    let userData = castFunPtrToPtr chain'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_chain_function_full _obj' chain' userData notify+    touchManagedPtr _obj+    return ()++data PadSetChainFunctionFullMethodInfo+instance (signature ~ (PadChainFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetChainFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetChainFunctionFull++-- method Pad::set_chain_list_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chainlist", argType = TInterface "Gst" "PadChainListFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_chain_list_function_full" gst_pad_set_chain_list_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadChainListFunctionC ->         -- chainlist : TInterface "Gst" "PadChainListFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetChainListFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadChainListFunction                 -- chainlist+    -> m ()                                 -- result+padSetChainListFunctionFull _obj chainlist = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    chainlist' <- mkPadChainListFunction (padChainListFunctionWrapper Nothing chainlist)+    let userData = castFunPtrToPtr chainlist'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_chain_list_function_full _obj' chainlist' userData notify+    touchManagedPtr _obj+    return ()++data PadSetChainListFunctionFullMethodInfo+instance (signature ~ (PadChainListFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetChainListFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetChainListFunctionFull++-- method Pad::set_element_private+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priv", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_element_private" gst_pad_set_element_private :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr () ->                               -- priv : TBasicType TVoid+    IO ()+++padSetElementPrivate ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Ptr ()                               -- priv+    -> m ()                                 -- result+padSetElementPrivate _obj priv = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pad_set_element_private _obj' priv+    touchManagedPtr _obj+    return ()++data PadSetElementPrivateMethodInfo+instance (signature ~ (Ptr () -> m ()), MonadIO m, PadK a) => MethodInfo PadSetElementPrivateMethodInfo a signature where+    overloadedMethod _ = padSetElementPrivate++-- method Pad::set_event_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "PadEventFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_event_function_full" gst_pad_set_event_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadEventFunctionC ->             -- event : TInterface "Gst" "PadEventFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetEventFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadEventFunction                     -- event+    -> m ()                                 -- result+padSetEventFunctionFull _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    event' <- mkPadEventFunction (padEventFunctionWrapper Nothing event)+    let userData = castFunPtrToPtr event'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_event_function_full _obj' event' userData notify+    touchManagedPtr _obj+    return ()++data PadSetEventFunctionFullMethodInfo+instance (signature ~ (PadEventFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetEventFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetEventFunctionFull++-- method Pad::set_getrange_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "get", argType = TInterface "Gst" "PadGetRangeFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_getrange_function_full" gst_pad_set_getrange_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadGetRangeFunctionC ->          -- get : TInterface "Gst" "PadGetRangeFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetGetrangeFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadGetRangeFunction                  -- get+    -> m ()                                 -- result+padSetGetrangeFunctionFull _obj get = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    get' <- mkPadGetRangeFunction (padGetRangeFunctionWrapper Nothing get)+    let userData = castFunPtrToPtr get'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_getrange_function_full _obj' get' userData notify+    touchManagedPtr _obj+    return ()++data PadSetGetrangeFunctionFullMethodInfo+instance (signature ~ (PadGetRangeFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetGetrangeFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetGetrangeFunctionFull++-- method Pad::set_iterate_internal_links_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iterintlink", argType = TInterface "Gst" "PadIterIntLinkFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_iterate_internal_links_function_full" gst_pad_set_iterate_internal_links_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadIterIntLinkFunctionC ->       -- iterintlink : TInterface "Gst" "PadIterIntLinkFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetIterateInternalLinksFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadIterIntLinkFunction               -- iterintlink+    -> m ()                                 -- result+padSetIterateInternalLinksFunctionFull _obj iterintlink = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    iterintlink' <- mkPadIterIntLinkFunction (padIterIntLinkFunctionWrapper Nothing iterintlink)+    let userData = castFunPtrToPtr iterintlink'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_iterate_internal_links_function_full _obj' iterintlink' userData notify+    touchManagedPtr _obj+    return ()++data PadSetIterateInternalLinksFunctionFullMethodInfo+instance (signature ~ (PadIterIntLinkFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetIterateInternalLinksFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetIterateInternalLinksFunctionFull++-- method Pad::set_link_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "link", argType = TInterface "Gst" "PadLinkFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_link_function_full" gst_pad_set_link_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadLinkFunctionC ->              -- link : TInterface "Gst" "PadLinkFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetLinkFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadLinkFunction                      -- link+    -> m ()                                 -- result+padSetLinkFunctionFull _obj link = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    link' <- mkPadLinkFunction (padLinkFunctionWrapper Nothing link)+    let userData = castFunPtrToPtr link'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_link_function_full _obj' link' userData notify+    touchManagedPtr _obj+    return ()++data PadSetLinkFunctionFullMethodInfo+instance (signature ~ (PadLinkFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetLinkFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetLinkFunctionFull++-- method Pad::set_offset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_offset" gst_pad_set_offset :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Int64 ->                                -- offset : TBasicType TInt64+    IO ()+++padSetOffset ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Int64                                -- offset+    -> m ()                                 -- result+padSetOffset _obj offset = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pad_set_offset _obj' offset+    touchManagedPtr _obj+    return ()++data PadSetOffsetMethodInfo+instance (signature ~ (Int64 -> m ()), MonadIO m, PadK a) => MethodInfo PadSetOffsetMethodInfo a signature where+    overloadedMethod _ = padSetOffset++-- method Pad::set_query_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "PadQueryFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_query_function_full" gst_pad_set_query_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadQueryFunctionC ->             -- query : TInterface "Gst" "PadQueryFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetQueryFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadQueryFunction                     -- query+    -> m ()                                 -- result+padSetQueryFunctionFull _obj query = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    query' <- mkPadQueryFunction (padQueryFunctionWrapper Nothing query)+    let userData = castFunPtrToPtr query'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_query_function_full _obj' query' userData notify+    touchManagedPtr _obj+    return ()++data PadSetQueryFunctionFullMethodInfo+instance (signature ~ (PadQueryFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetQueryFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetQueryFunctionFull++-- method Pad::set_unlink_function_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unlink", argType = TInterface "Gst" "PadUnlinkFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_set_unlink_function_full" gst_pad_set_unlink_function_full :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadUnlinkFunctionC ->            -- unlink : TInterface "Gst" "PadUnlinkFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++padSetUnlinkFunctionFull ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadUnlinkFunction                    -- unlink+    -> m ()                                 -- result+padSetUnlinkFunctionFull _obj unlink = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    unlink' <- mkPadUnlinkFunction (padUnlinkFunctionWrapper Nothing unlink)+    let userData = castFunPtrToPtr unlink'+    let notify = safeFreeFunPtrPtr+    gst_pad_set_unlink_function_full _obj' unlink' userData notify+    touchManagedPtr _obj+    return ()++data PadSetUnlinkFunctionFullMethodInfo+instance (signature ~ (PadUnlinkFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetUnlinkFunctionFullMethodInfo a signature where+    overloadedMethod _ = padSetUnlinkFunctionFull++-- method Pad::start_task+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TaskFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_start_task" gst_pad_start_task :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr TaskFunctionC ->                 -- func : TInterface "Gst" "TaskFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO CInt+++padStartTask ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> TaskFunction                         -- func+    -> m Bool                               -- result+padStartTask _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    func' <- mkTaskFunction (taskFunctionWrapper Nothing func)+    let userData = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    result <- gst_pad_start_task _obj' func' userData notify+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadStartTaskMethodInfo+instance (signature ~ (TaskFunction -> m Bool), MonadIO m, PadK a) => MethodInfo PadStartTaskMethodInfo a signature where+    overloadedMethod _ = padStartTask++-- method Pad::sticky_events_foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "foreach_func", argType = TInterface "Gst" "PadStickyEventsForeachFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_sticky_events_foreach" gst_pad_sticky_events_foreach :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    FunPtr PadStickyEventsForeachFunctionC -> -- foreach_func : TInterface "Gst" "PadStickyEventsForeachFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++padStickyEventsForeach ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> PadStickyEventsForeachFunction       -- foreachFunc+    -> m ()                                 -- result+padStickyEventsForeach _obj foreachFunc = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    foreachFunc' <- mkPadStickyEventsForeachFunction (padStickyEventsForeachFunctionWrapper Nothing foreachFunc)+    let userData = nullPtr+    gst_pad_sticky_events_foreach _obj' foreachFunc' userData+    safeFreeFunPtr $ castFunPtrToPtr foreachFunc'+    touchManagedPtr _obj+    return ()++data PadStickyEventsForeachMethodInfo+instance (signature ~ (PadStickyEventsForeachFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadStickyEventsForeachMethodInfo a signature where+    overloadedMethod _ = padStickyEventsForeach++-- method Pad::stop_task+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_stop_task" gst_pad_stop_task :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO CInt+++padStopTask ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+padStopTask _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_stop_task _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PadStopTaskMethodInfo+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadStopTaskMethodInfo a signature where+    overloadedMethod _ = padStopTask++-- method Pad::store_sticky_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_store_sticky_event" gst_pad_store_sticky_event :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Event ->                            -- event : TInterface "Gst" "Event"+    IO CUInt+++padStoreStickyEvent ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> Event                                -- event+    -> m FlowReturn                         -- result+padStoreStickyEvent _obj event = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let event' = unsafeManagedPtrGetPtr event+    result <- gst_pad_store_sticky_event _obj' event'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    touchManagedPtr event+    return result'++data PadStoreStickyEventMethodInfo+instance (signature ~ (Event -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadStoreStickyEventMethodInfo a signature where+    overloadedMethod _ = padStoreStickyEvent++-- method Pad::unlink+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_unlink" gst_pad_unlink :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"+    IO CInt+++padUnlink ::+    (MonadIO m, PadK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- sinkpad+    -> m Bool                               -- result+padUnlink _obj sinkpad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad+    result <- gst_pad_unlink _obj' sinkpad'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr sinkpad+    return result'++data PadUnlinkMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, PadK a, PadK b) => MethodInfo PadUnlinkMethodInfo a signature where+    overloadedMethod _ = padUnlink++-- method Pad::use_fixed_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_use_fixed_caps" gst_pad_use_fixed_caps :: +    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"+    IO ()+++padUseFixedCaps ::+    (MonadIO m, PadK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+padUseFixedCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pad_use_fixed_caps _obj'+    touchManagedPtr _obj+    return ()++data PadUseFixedCapsMethodInfo+instance (signature ~ (m ()), MonadIO m, PadK a) => MethodInfo PadUseFixedCapsMethodInfo a signature where+    overloadedMethod _ = padUseFixedCaps++-- method Pad::link_get_name+-- method type : MemberFunction+-- Args : [Arg {argCName = "ret", argType = TInterface "Gst" "PadLinkReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_link_get_name" gst_pad_link_get_name :: +    CUInt ->                                -- ret : TInterface "Gst" "PadLinkReturn"+    IO CString+++padLinkGetName ::+    (MonadIO m) =>+    PadLinkReturn                           -- ret+    -> m T.Text                             -- result+padLinkGetName ret = liftIO $ do+    let ret' = (fromIntegral . fromEnum) ret+    result <- gst_pad_link_get_name ret'+    checkUnexpectedReturnNULL "gst_pad_link_get_name" result+    result' <- cstringToText result+    return result'++
+ GI/Gst/Objects/Pad.hs-boot view
@@ -0,0 +1,93 @@+module GI.Gst.Objects.Pad 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++newtype Pad = Pad (ForeignPtr Pad)+instance GObject Pad where+class GObject o => PadK o+instance (GObject o, IsDescendantOf Pad o) => PadK o+data PadCapsPropertyInfo+data PadDirectionPropertyInfo+data PadOffsetPropertyInfo+data PadTemplatePropertyInfo+data PadLinkedSignalInfo+data PadUnlinkedSignalInfo+data PadActivateModeMethodInfo+data PadAddProbeMethodInfo+data PadCanLinkMethodInfo+data PadChainMethodInfo+data PadChainListMethodInfo+data PadCheckReconfigureMethodInfo+data PadCreateStreamIdMethodInfo+data PadEventDefaultMethodInfo+data PadForwardMethodInfo+data PadGetAllowedCapsMethodInfo+data PadGetCurrentCapsMethodInfo+data PadGetDirectionMethodInfo+data PadGetElementPrivateMethodInfo+data PadGetLastFlowReturnMethodInfo+data PadGetOffsetMethodInfo+data PadGetPadTemplateMethodInfo+data PadGetPadTemplateCapsMethodInfo+data PadGetParentElementMethodInfo+data PadGetPeerMethodInfo+data PadGetRangeMethodInfo+data PadGetStickyEventMethodInfo+data PadGetStreamIdMethodInfo+data PadHasCurrentCapsMethodInfo+data PadIsActiveMethodInfo+data PadIsBlockedMethodInfo+data PadIsBlockingMethodInfo+data PadIsLinkedMethodInfo+data PadIterateInternalLinksMethodInfo+data PadIterateInternalLinksDefaultMethodInfo+data PadLinkMethodInfo+data PadLinkFullMethodInfo+data PadMarkReconfigureMethodInfo+data PadNeedsReconfigureMethodInfo+data PadPauseTaskMethodInfo+data PadPeerQueryMethodInfo+data PadPeerQueryAcceptCapsMethodInfo+data PadPeerQueryCapsMethodInfo+data PadPeerQueryConvertMethodInfo+data PadPeerQueryDurationMethodInfo+data PadPeerQueryPositionMethodInfo+data PadProxyQueryAcceptCapsMethodInfo+data PadProxyQueryCapsMethodInfo+data PadPullRangeMethodInfo+data PadPushMethodInfo+data PadPushEventMethodInfo+data PadPushListMethodInfo+data PadQueryMethodInfo+data PadQueryAcceptCapsMethodInfo+data PadQueryCapsMethodInfo+data PadQueryConvertMethodInfo+data PadQueryDefaultMethodInfo+data PadQueryDurationMethodInfo+data PadQueryPositionMethodInfo+data PadRemoveProbeMethodInfo+data PadSendEventMethodInfo+data PadSetActivateFunctionFullMethodInfo+data PadSetActivatemodeFunctionFullMethodInfo+data PadSetActiveMethodInfo+data PadSetChainFunctionFullMethodInfo+data PadSetChainListFunctionFullMethodInfo+data PadSetElementPrivateMethodInfo+data PadSetEventFunctionFullMethodInfo+data PadSetGetrangeFunctionFullMethodInfo+data PadSetIterateInternalLinksFunctionFullMethodInfo+data PadSetLinkFunctionFullMethodInfo+data PadSetOffsetMethodInfo+data PadSetQueryFunctionFullMethodInfo+data PadSetUnlinkFunctionFullMethodInfo+data PadStartTaskMethodInfo+data PadStickyEventsForeachMethodInfo+data PadStopTaskMethodInfo+data PadStoreStickyEventMethodInfo+data PadUnlinkMethodInfo+data PadUseFixedCapsMethodInfo
+ GI/Gst/Objects/PadTemplate.hs view
@@ -0,0 +1,400 @@+++{- |+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.Objects.PadTemplate+    ( ++-- * Exported types+    PadTemplate(..)                         ,+    PadTemplateK                            ,+    toPadTemplate                           ,+    noPadTemplate                           ,+++ -- * Methods+-- ** padTemplateGetCaps+    PadTemplateGetCapsMethodInfo            ,+    padTemplateGetCaps                      ,+++-- ** padTemplateNew+    padTemplateNew                          ,+++-- ** padTemplatePadCreated+    PadTemplatePadCreatedMethodInfo         ,+    padTemplatePadCreated                   ,+++++ -- * Properties+-- ** Caps+    PadTemplateCapsPropertyInfo             ,+    constructPadTemplateCaps                ,+    getPadTemplateCaps                      ,+++-- ** Direction+    PadTemplateDirectionPropertyInfo        ,+    constructPadTemplateDirection           ,+    getPadTemplateDirection                 ,+++-- ** NameTemplate+    PadTemplateNameTemplatePropertyInfo     ,+    constructPadTemplateNameTemplate        ,+    getPadTemplateNameTemplate              ,+++-- ** Presence+    PadTemplatePresencePropertyInfo         ,+    constructPadTemplatePresence            ,+    getPadTemplatePresence                  ,+++++ -- * Signals+-- ** PadCreated+    PadTemplatePadCreatedCallback           ,+    PadTemplatePadCreatedCallbackC          ,+    PadTemplatePadCreatedSignalInfo         ,+    afterPadTemplatePadCreated              ,+    mkPadTemplatePadCreatedCallback         ,+    noPadTemplatePadCreatedCallback         ,+    onPadTemplatePadCreated                 ,+    padTemplatePadCreatedCallbackWrapper    ,+    padTemplatePadCreatedClosure            ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype PadTemplate = PadTemplate (ForeignPtr PadTemplate)+foreign import ccall "gst_pad_template_get_type"+    c_gst_pad_template_get_type :: IO GType++type instance ParentTypes PadTemplate = PadTemplateParentTypes+type PadTemplateParentTypes = '[Object, GObject.Object]++instance GObject PadTemplate where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_pad_template_get_type+    ++class GObject o => PadTemplateK o+instance (GObject o, IsDescendantOf PadTemplate o) => PadTemplateK o++toPadTemplate :: PadTemplateK o => o -> IO PadTemplate+toPadTemplate = unsafeCastTo PadTemplate++noPadTemplate :: Maybe PadTemplate+noPadTemplate = Nothing++type family ResolvePadTemplateMethod (t :: Symbol) (o :: *) :: * where+    ResolvePadTemplateMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolvePadTemplateMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolvePadTemplateMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolvePadTemplateMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolvePadTemplateMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolvePadTemplateMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolvePadTemplateMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolvePadTemplateMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolvePadTemplateMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolvePadTemplateMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolvePadTemplateMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolvePadTemplateMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolvePadTemplateMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolvePadTemplateMethod "padCreated" o = PadTemplatePadCreatedMethodInfo+    ResolvePadTemplateMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolvePadTemplateMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolvePadTemplateMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolvePadTemplateMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolvePadTemplateMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolvePadTemplateMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolvePadTemplateMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolvePadTemplateMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolvePadTemplateMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolvePadTemplateMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolvePadTemplateMethod "unparent" o = ObjectUnparentMethodInfo+    ResolvePadTemplateMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolvePadTemplateMethod "getCaps" o = PadTemplateGetCapsMethodInfo+    ResolvePadTemplateMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolvePadTemplateMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolvePadTemplateMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolvePadTemplateMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolvePadTemplateMethod "getName" o = ObjectGetNameMethodInfo+    ResolvePadTemplateMethod "getParent" o = ObjectGetParentMethodInfo+    ResolvePadTemplateMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolvePadTemplateMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolvePadTemplateMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolvePadTemplateMethod "getValue" o = ObjectGetValueMethodInfo+    ResolvePadTemplateMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolvePadTemplateMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolvePadTemplateMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolvePadTemplateMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolvePadTemplateMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolvePadTemplateMethod "setName" o = ObjectSetNameMethodInfo+    ResolvePadTemplateMethod "setParent" o = ObjectSetParentMethodInfo+    ResolvePadTemplateMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolvePadTemplateMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePadTemplateMethod t PadTemplate, MethodInfo info PadTemplate p) => IsLabelProxy t (PadTemplate -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePadTemplateMethod t PadTemplate, MethodInfo info PadTemplate p) => IsLabel t (PadTemplate -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal PadTemplate::pad-created+type PadTemplatePadCreatedCallback =+    Pad ->+    IO ()++noPadTemplatePadCreatedCallback :: Maybe PadTemplatePadCreatedCallback+noPadTemplatePadCreatedCallback = Nothing++type PadTemplatePadCreatedCallbackC =+    Ptr () ->                               -- object+    Ptr Pad ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkPadTemplatePadCreatedCallback :: PadTemplatePadCreatedCallbackC -> IO (FunPtr PadTemplatePadCreatedCallbackC)++padTemplatePadCreatedClosure :: PadTemplatePadCreatedCallback -> IO Closure+padTemplatePadCreatedClosure cb = newCClosure =<< mkPadTemplatePadCreatedCallback wrapped+    where wrapped = padTemplatePadCreatedCallbackWrapper cb++padTemplatePadCreatedCallbackWrapper ::+    PadTemplatePadCreatedCallback ->+    Ptr () ->+    Ptr Pad ->+    Ptr () ->+    IO ()+padTemplatePadCreatedCallbackWrapper _cb _ pad _ = do+    pad' <- (newObject Pad) pad+    _cb  pad'++onPadTemplatePadCreated :: (GObject a, MonadIO m) => a -> PadTemplatePadCreatedCallback -> m SignalHandlerId+onPadTemplatePadCreated obj cb = liftIO $ connectPadTemplatePadCreated obj cb SignalConnectBefore+afterPadTemplatePadCreated :: (GObject a, MonadIO m) => a -> PadTemplatePadCreatedCallback -> m SignalHandlerId+afterPadTemplatePadCreated obj cb = connectPadTemplatePadCreated obj cb SignalConnectAfter++connectPadTemplatePadCreated :: (GObject a, MonadIO m) =>+                                a -> PadTemplatePadCreatedCallback -> SignalConnectMode -> m SignalHandlerId+connectPadTemplatePadCreated obj cb after = liftIO $ do+    cb' <- mkPadTemplatePadCreatedCallback (padTemplatePadCreatedCallbackWrapper cb)+    connectSignalFunPtr obj "pad-created" cb' after++-- VVV Prop "caps"+   -- Type: TInterface "Gst" "Caps"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getPadTemplateCaps :: (MonadIO m, PadTemplateK o) => o -> m Caps+getPadTemplateCaps obj = liftIO $ getObjectPropertyBoxed obj "caps" Caps++constructPadTemplateCaps :: Caps -> IO ([Char], GValue)+constructPadTemplateCaps val = constructObjectPropertyBoxed "caps" val++data PadTemplateCapsPropertyInfo+instance AttrInfo PadTemplateCapsPropertyInfo where+    type AttrAllowedOps PadTemplateCapsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PadTemplateCapsPropertyInfo = (~) Caps+    type AttrBaseTypeConstraint PadTemplateCapsPropertyInfo = PadTemplateK+    type AttrGetType PadTemplateCapsPropertyInfo = Caps+    type AttrLabel PadTemplateCapsPropertyInfo = "caps"+    attrGet _ = getPadTemplateCaps+    attrSet _ = undefined+    attrConstruct _ = constructPadTemplateCaps++-- VVV Prop "direction"+   -- Type: TInterface "Gst" "PadDirection"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getPadTemplateDirection :: (MonadIO m, PadTemplateK o) => o -> m PadDirection+getPadTemplateDirection obj = liftIO $ getObjectPropertyEnum obj "direction"++constructPadTemplateDirection :: PadDirection -> IO ([Char], GValue)+constructPadTemplateDirection val = constructObjectPropertyEnum "direction" val++data PadTemplateDirectionPropertyInfo+instance AttrInfo PadTemplateDirectionPropertyInfo where+    type AttrAllowedOps PadTemplateDirectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PadTemplateDirectionPropertyInfo = (~) PadDirection+    type AttrBaseTypeConstraint PadTemplateDirectionPropertyInfo = PadTemplateK+    type AttrGetType PadTemplateDirectionPropertyInfo = PadDirection+    type AttrLabel PadTemplateDirectionPropertyInfo = "direction"+    attrGet _ = getPadTemplateDirection+    attrSet _ = undefined+    attrConstruct _ = constructPadTemplateDirection++-- VVV Prop "name-template"+   -- Type: TBasicType TUTF8+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getPadTemplateNameTemplate :: (MonadIO m, PadTemplateK o) => o -> m T.Text+getPadTemplateNameTemplate obj = liftIO $ getObjectPropertyString obj "name-template"++constructPadTemplateNameTemplate :: T.Text -> IO ([Char], GValue)+constructPadTemplateNameTemplate val = constructObjectPropertyString "name-template" val++data PadTemplateNameTemplatePropertyInfo+instance AttrInfo PadTemplateNameTemplatePropertyInfo where+    type AttrAllowedOps PadTemplateNameTemplatePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PadTemplateNameTemplatePropertyInfo = (~) T.Text+    type AttrBaseTypeConstraint PadTemplateNameTemplatePropertyInfo = PadTemplateK+    type AttrGetType PadTemplateNameTemplatePropertyInfo = T.Text+    type AttrLabel PadTemplateNameTemplatePropertyInfo = "name-template"+    attrGet _ = getPadTemplateNameTemplate+    attrSet _ = undefined+    attrConstruct _ = constructPadTemplateNameTemplate++-- VVV Prop "presence"+   -- Type: TInterface "Gst" "PadPresence"+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]++getPadTemplatePresence :: (MonadIO m, PadTemplateK o) => o -> m PadPresence+getPadTemplatePresence obj = liftIO $ getObjectPropertyEnum obj "presence"++constructPadTemplatePresence :: PadPresence -> IO ([Char], GValue)+constructPadTemplatePresence val = constructObjectPropertyEnum "presence" val++data PadTemplatePresencePropertyInfo+instance AttrInfo PadTemplatePresencePropertyInfo where+    type AttrAllowedOps PadTemplatePresencePropertyInfo = '[ 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PadTemplatePresencePropertyInfo = (~) PadPresence+    type AttrBaseTypeConstraint PadTemplatePresencePropertyInfo = PadTemplateK+    type AttrGetType PadTemplatePresencePropertyInfo = PadPresence+    type AttrLabel PadTemplatePresencePropertyInfo = "presence"+    attrGet _ = getPadTemplatePresence+    attrSet _ = undefined+    attrConstruct _ = constructPadTemplatePresence++type instance AttributeList PadTemplate = PadTemplateAttributeList+type PadTemplateAttributeList = ('[ '("caps", PadTemplateCapsPropertyInfo), '("direction", PadTemplateDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("nameTemplate", PadTemplateNameTemplatePropertyInfo), '("parent", ObjectParentPropertyInfo), '("presence", PadTemplatePresencePropertyInfo)] :: [(Symbol, *)])++data PadTemplatePadCreatedSignalInfo+instance SignalInfo PadTemplatePadCreatedSignalInfo where+    type HaskellCallbackType PadTemplatePadCreatedSignalInfo = PadTemplatePadCreatedCallback+    connectSignal _ = connectPadTemplatePadCreated++type instance SignalList PadTemplate = PadTemplateSignalList+type PadTemplateSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padCreated", PadTemplatePadCreatedSignalInfo)] :: [(Symbol, *)])++-- method PadTemplate::new+-- method type : Constructor+-- Args : [Arg {argCName = "name_template", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "presence", argType = TInterface "Gst" "PadPresence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadTemplate"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_template_new" gst_pad_template_new :: +    CString ->                              -- name_template : TBasicType TUTF8+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"+    CUInt ->                                -- presence : TInterface "Gst" "PadPresence"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO (Ptr PadTemplate)+++padTemplateNew ::+    (MonadIO m) =>+    T.Text                                  -- nameTemplate+    -> PadDirection                         -- direction+    -> PadPresence                          -- presence+    -> Caps                                 -- caps+    -> m PadTemplate                        -- result+padTemplateNew nameTemplate direction presence caps = liftIO $ do+    nameTemplate' <- textToCString nameTemplate+    let direction' = (fromIntegral . fromEnum) direction+    let presence' = (fromIntegral . fromEnum) presence+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_pad_template_new nameTemplate' direction' presence' caps'+    checkUnexpectedReturnNULL "gst_pad_template_new" result+    result' <- (newObject PadTemplate) result+    touchManagedPtr caps+    freeMem nameTemplate'+    return result'++-- method PadTemplate::get_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_template_get_caps" gst_pad_template_get_caps :: +    Ptr PadTemplate ->                      -- _obj : TInterface "Gst" "PadTemplate"+    IO (Ptr Caps)+++padTemplateGetCaps ::+    (MonadIO m, PadTemplateK a) =>+    a                                       -- _obj+    -> m Caps                               -- result+padTemplateGetCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pad_template_get_caps _obj'+    checkUnexpectedReturnNULL "gst_pad_template_get_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data PadTemplateGetCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m, PadTemplateK a) => MethodInfo PadTemplateGetCapsMethodInfo a signature where+    overloadedMethod _ = padTemplateGetCaps++-- method PadTemplate::pad_created+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_template_pad_created" gst_pad_template_pad_created :: +    Ptr PadTemplate ->                      -- _obj : TInterface "Gst" "PadTemplate"+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    IO ()+++padTemplatePadCreated ::+    (MonadIO m, PadTemplateK a, PadK b) =>+    a                                       -- _obj+    -> b                                    -- pad+    -> m ()                                 -- result+padTemplatePadCreated _obj pad = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pad' = unsafeManagedPtrCastPtr pad+    gst_pad_template_pad_created _obj' pad'+    touchManagedPtr _obj+    touchManagedPtr pad+    return ()++data PadTemplatePadCreatedMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, PadTemplateK a, PadK b) => MethodInfo PadTemplatePadCreatedMethodInfo a signature where+    overloadedMethod _ = padTemplatePadCreated++
+ GI/Gst/Objects/PadTemplate.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gst.Objects.PadTemplate 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++newtype PadTemplate = PadTemplate (ForeignPtr PadTemplate)+instance GObject PadTemplate where+class GObject o => PadTemplateK o+instance (GObject o, IsDescendantOf PadTemplate o) => PadTemplateK o+data PadTemplateCapsPropertyInfo+data PadTemplateDirectionPropertyInfo+data PadTemplateNameTemplatePropertyInfo+data PadTemplatePresencePropertyInfo+data PadTemplatePadCreatedSignalInfo+data PadTemplateGetCapsMethodInfo+data PadTemplatePadCreatedMethodInfo
+ GI/Gst/Objects/Pipeline.hs view
@@ -0,0 +1,660 @@+++{- |+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.Objects.Pipeline+    ( ++-- * Exported types+    Pipeline(..)                            ,+    PipelineK                               ,+    toPipeline                              ,+    noPipeline                              ,+++ -- * Methods+-- ** pipelineAutoClock+    PipelineAutoClockMethodInfo             ,+    pipelineAutoClock                       ,+++-- ** pipelineGetAutoFlushBus+    PipelineGetAutoFlushBusMethodInfo       ,+    pipelineGetAutoFlushBus                 ,+++-- ** pipelineGetBus+    PipelineGetBusMethodInfo                ,+    pipelineGetBus                          ,+++-- ** pipelineGetDelay+    PipelineGetDelayMethodInfo              ,+    pipelineGetDelay                        ,+++-- ** pipelineGetLatency+    PipelineGetLatencyMethodInfo            ,+    pipelineGetLatency                      ,+++-- ** pipelineGetPipelineClock+    PipelineGetPipelineClockMethodInfo      ,+    pipelineGetPipelineClock                ,+++-- ** pipelineNew+    pipelineNew                             ,+++-- ** pipelineSetAutoFlushBus+    PipelineSetAutoFlushBusMethodInfo       ,+    pipelineSetAutoFlushBus                 ,+++-- ** pipelineSetDelay+    PipelineSetDelayMethodInfo              ,+    pipelineSetDelay                        ,+++-- ** pipelineSetLatency+    PipelineSetLatencyMethodInfo            ,+    pipelineSetLatency                      ,+++-- ** pipelineUseClock+    PipelineUseClockMethodInfo              ,+    pipelineUseClock                        ,+++++ -- * Properties+-- ** AutoFlushBus+    PipelineAutoFlushBusPropertyInfo        ,+    constructPipelineAutoFlushBus           ,+    getPipelineAutoFlushBus                 ,+    setPipelineAutoFlushBus                 ,+++-- ** Delay+    PipelineDelayPropertyInfo               ,+    constructPipelineDelay                  ,+    getPipelineDelay                        ,+    setPipelineDelay                        ,+++-- ** Latency+    PipelineLatencyPropertyInfo             ,+    constructPipelineLatency                ,+    getPipelineLatency                      ,+    setPipelineLatency                      ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Pipeline = Pipeline (ForeignPtr Pipeline)+foreign import ccall "gst_pipeline_get_type"+    c_gst_pipeline_get_type :: IO GType++type instance ParentTypes Pipeline = PipelineParentTypes+type PipelineParentTypes = '[Bin, Element, Object, GObject.Object, ChildProxy]++instance GObject Pipeline where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_pipeline_get_type+    ++class GObject o => PipelineK o+instance (GObject o, IsDescendantOf Pipeline o) => PipelineK o++toPipeline :: PipelineK o => o -> IO Pipeline+toPipeline = unsafeCastTo Pipeline++noPipeline :: Maybe Pipeline+noPipeline = Nothing++type family ResolvePipelineMethod (t :: Symbol) (o :: *) :: * where+    ResolvePipelineMethod "abortState" o = ElementAbortStateMethodInfo+    ResolvePipelineMethod "add" o = BinAddMethodInfo+    ResolvePipelineMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolvePipelineMethod "addPad" o = ElementAddPadMethodInfo+    ResolvePipelineMethod "autoClock" o = PipelineAutoClockMethodInfo+    ResolvePipelineMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolvePipelineMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolvePipelineMethod "changeState" o = ElementChangeStateMethodInfo+    ResolvePipelineMethod "childAdded" o = ChildProxyChildAddedMethodInfo+    ResolvePipelineMethod "childRemoved" o = ChildProxyChildRemovedMethodInfo+    ResolvePipelineMethod "continueState" o = ElementContinueStateMethodInfo+    ResolvePipelineMethod "createAllPads" o = ElementCreateAllPadsMethodInfo+    ResolvePipelineMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolvePipelineMethod "findUnlinkedPad" o = BinFindUnlinkedPadMethodInfo+    ResolvePipelineMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolvePipelineMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolvePipelineMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolvePipelineMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolvePipelineMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolvePipelineMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolvePipelineMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolvePipelineMethod "isLockedState" o = ElementIsLockedStateMethodInfo+    ResolvePipelineMethod "iterateAllByInterface" o = BinIterateAllByInterfaceMethodInfo+    ResolvePipelineMethod "iterateElements" o = BinIterateElementsMethodInfo+    ResolvePipelineMethod "iteratePads" o = ElementIteratePadsMethodInfo+    ResolvePipelineMethod "iterateRecurse" o = BinIterateRecurseMethodInfo+    ResolvePipelineMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo+    ResolvePipelineMethod "iterateSinks" o = BinIterateSinksMethodInfo+    ResolvePipelineMethod "iterateSorted" o = BinIterateSortedMethodInfo+    ResolvePipelineMethod "iterateSources" o = BinIterateSourcesMethodInfo+    ResolvePipelineMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo+    ResolvePipelineMethod "link" o = ElementLinkMethodInfo+    ResolvePipelineMethod "linkFiltered" o = ElementLinkFilteredMethodInfo+    ResolvePipelineMethod "linkPads" o = ElementLinkPadsMethodInfo+    ResolvePipelineMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo+    ResolvePipelineMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo+    ResolvePipelineMethod "lookup" o = ChildProxyLookupMethodInfo+    ResolvePipelineMethod "lostState" o = ElementLostStateMethodInfo+    ResolvePipelineMethod "messageFull" o = ElementMessageFullMethodInfo+    ResolvePipelineMethod "noMorePads" o = ElementNoMorePadsMethodInfo+    ResolvePipelineMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolvePipelineMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolvePipelineMethod "postMessage" o = ElementPostMessageMethodInfo+    ResolvePipelineMethod "provideClock" o = ElementProvideClockMethodInfo+    ResolvePipelineMethod "query" o = ElementQueryMethodInfo+    ResolvePipelineMethod "queryConvert" o = ElementQueryConvertMethodInfo+    ResolvePipelineMethod "queryDuration" o = ElementQueryDurationMethodInfo+    ResolvePipelineMethod "queryPosition" o = ElementQueryPositionMethodInfo+    ResolvePipelineMethod "recalculateLatency" o = BinRecalculateLatencyMethodInfo+    ResolvePipelineMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolvePipelineMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo+    ResolvePipelineMethod "remove" o = BinRemoveMethodInfo+    ResolvePipelineMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolvePipelineMethod "removePad" o = ElementRemovePadMethodInfo+    ResolvePipelineMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolvePipelineMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolvePipelineMethod "requestPad" o = ElementRequestPadMethodInfo+    ResolvePipelineMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolvePipelineMethod "seek" o = ElementSeekMethodInfo+    ResolvePipelineMethod "seekSimple" o = ElementSeekSimpleMethodInfo+    ResolvePipelineMethod "sendEvent" o = ElementSendEventMethodInfo+    ResolvePipelineMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolvePipelineMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolvePipelineMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolvePipelineMethod "syncChildrenStates" o = BinSyncChildrenStatesMethodInfo+    ResolvePipelineMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo+    ResolvePipelineMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolvePipelineMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolvePipelineMethod "unlink" o = ElementUnlinkMethodInfo+    ResolvePipelineMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo+    ResolvePipelineMethod "unparent" o = ObjectUnparentMethodInfo+    ResolvePipelineMethod "useClock" o = PipelineUseClockMethodInfo+    ResolvePipelineMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolvePipelineMethod "getAutoFlushBus" o = PipelineGetAutoFlushBusMethodInfo+    ResolvePipelineMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo+    ResolvePipelineMethod "getByInterface" o = BinGetByInterfaceMethodInfo+    ResolvePipelineMethod "getByName" o = BinGetByNameMethodInfo+    ResolvePipelineMethod "getByNameRecurseUp" o = BinGetByNameRecurseUpMethodInfo+    ResolvePipelineMethod "getChildByIndex" o = ChildProxyGetChildByIndexMethodInfo+    ResolvePipelineMethod "getChildByName" o = ChildProxyGetChildByNameMethodInfo+    ResolvePipelineMethod "getChildrenCount" o = ChildProxyGetChildrenCountMethodInfo+    ResolvePipelineMethod "getClock" o = ElementGetClockMethodInfo+    ResolvePipelineMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo+    ResolvePipelineMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo+    ResolvePipelineMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolvePipelineMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolvePipelineMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolvePipelineMethod "getDelay" o = PipelineGetDelayMethodInfo+    ResolvePipelineMethod "getFactory" o = ElementGetFactoryMethodInfo+    ResolvePipelineMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolvePipelineMethod "getLatency" o = PipelineGetLatencyMethodInfo+    ResolvePipelineMethod "getName" o = ObjectGetNameMethodInfo+    ResolvePipelineMethod "getParent" o = ObjectGetParentMethodInfo+    ResolvePipelineMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolvePipelineMethod "getPipelineClock" o = PipelineGetPipelineClockMethodInfo+    ResolvePipelineMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolvePipelineMethod "getRequestPad" o = ElementGetRequestPadMethodInfo+    ResolvePipelineMethod "getStartTime" o = ElementGetStartTimeMethodInfo+    ResolvePipelineMethod "getState" o = ElementGetStateMethodInfo+    ResolvePipelineMethod "getStaticPad" o = ElementGetStaticPadMethodInfo+    ResolvePipelineMethod "getValue" o = ObjectGetValueMethodInfo+    ResolvePipelineMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolvePipelineMethod "setAutoFlushBus" o = PipelineSetAutoFlushBusMethodInfo+    ResolvePipelineMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo+    ResolvePipelineMethod "setBus" o = ElementSetBusMethodInfo+    ResolvePipelineMethod "setClock" o = ElementSetClockMethodInfo+    ResolvePipelineMethod "setContext" o = ElementSetContextMethodInfo+    ResolvePipelineMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolvePipelineMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolvePipelineMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolvePipelineMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolvePipelineMethod "setDelay" o = PipelineSetDelayMethodInfo+    ResolvePipelineMethod "setLatency" o = PipelineSetLatencyMethodInfo+    ResolvePipelineMethod "setLockedState" o = ElementSetLockedStateMethodInfo+    ResolvePipelineMethod "setName" o = ObjectSetNameMethodInfo+    ResolvePipelineMethod "setParent" o = ObjectSetParentMethodInfo+    ResolvePipelineMethod "setStartTime" o = ElementSetStartTimeMethodInfo+    ResolvePipelineMethod "setState" o = ElementSetStateMethodInfo+    ResolvePipelineMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePipelineMethod t Pipeline, MethodInfo info Pipeline p) => IsLabelProxy t (Pipeline -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePipelineMethod t Pipeline, MethodInfo info Pipeline p) => IsLabel t (Pipeline -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- VVV Prop "auto-flush-bus"+   -- Type: TBasicType TBoolean+   -- Flags: [PropertyReadable,PropertyWritable]++getPipelineAutoFlushBus :: (MonadIO m, PipelineK o) => o -> m Bool+getPipelineAutoFlushBus obj = liftIO $ getObjectPropertyBool obj "auto-flush-bus"++setPipelineAutoFlushBus :: (MonadIO m, PipelineK o) => o -> Bool -> m ()+setPipelineAutoFlushBus obj val = liftIO $ setObjectPropertyBool obj "auto-flush-bus" val++constructPipelineAutoFlushBus :: Bool -> IO ([Char], GValue)+constructPipelineAutoFlushBus val = constructObjectPropertyBool "auto-flush-bus" val++data PipelineAutoFlushBusPropertyInfo+instance AttrInfo PipelineAutoFlushBusPropertyInfo where+    type AttrAllowedOps PipelineAutoFlushBusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PipelineAutoFlushBusPropertyInfo = (~) Bool+    type AttrBaseTypeConstraint PipelineAutoFlushBusPropertyInfo = PipelineK+    type AttrGetType PipelineAutoFlushBusPropertyInfo = Bool+    type AttrLabel PipelineAutoFlushBusPropertyInfo = "auto-flush-bus"+    attrGet _ = getPipelineAutoFlushBus+    attrSet _ = setPipelineAutoFlushBus+    attrConstruct _ = constructPipelineAutoFlushBus++-- VVV Prop "delay"+   -- Type: TBasicType TUInt64+   -- Flags: [PropertyReadable,PropertyWritable]++getPipelineDelay :: (MonadIO m, PipelineK o) => o -> m Word64+getPipelineDelay obj = liftIO $ getObjectPropertyUInt64 obj "delay"++setPipelineDelay :: (MonadIO m, PipelineK o) => o -> Word64 -> m ()+setPipelineDelay obj val = liftIO $ setObjectPropertyUInt64 obj "delay" val++constructPipelineDelay :: Word64 -> IO ([Char], GValue)+constructPipelineDelay val = constructObjectPropertyUInt64 "delay" val++data PipelineDelayPropertyInfo+instance AttrInfo PipelineDelayPropertyInfo where+    type AttrAllowedOps PipelineDelayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PipelineDelayPropertyInfo = (~) Word64+    type AttrBaseTypeConstraint PipelineDelayPropertyInfo = PipelineK+    type AttrGetType PipelineDelayPropertyInfo = Word64+    type AttrLabel PipelineDelayPropertyInfo = "delay"+    attrGet _ = getPipelineDelay+    attrSet _ = setPipelineDelay+    attrConstruct _ = constructPipelineDelay++-- VVV Prop "latency"+   -- Type: TBasicType TUInt64+   -- Flags: [PropertyReadable,PropertyWritable]++getPipelineLatency :: (MonadIO m, PipelineK o) => o -> m Word64+getPipelineLatency obj = liftIO $ getObjectPropertyUInt64 obj "latency"++setPipelineLatency :: (MonadIO m, PipelineK o) => o -> Word64 -> m ()+setPipelineLatency obj val = liftIO $ setObjectPropertyUInt64 obj "latency" val++constructPipelineLatency :: Word64 -> IO ([Char], GValue)+constructPipelineLatency val = constructObjectPropertyUInt64 "latency" val++data PipelineLatencyPropertyInfo+instance AttrInfo PipelineLatencyPropertyInfo where+    type AttrAllowedOps PipelineLatencyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint PipelineLatencyPropertyInfo = (~) Word64+    type AttrBaseTypeConstraint PipelineLatencyPropertyInfo = PipelineK+    type AttrGetType PipelineLatencyPropertyInfo = Word64+    type AttrLabel PipelineLatencyPropertyInfo = "latency"+    attrGet _ = getPipelineLatency+    attrSet _ = setPipelineLatency+    attrConstruct _ = constructPipelineLatency++type instance AttributeList Pipeline = PipelineAttributeList+type PipelineAttributeList = ('[ '("asyncHandling", BinAsyncHandlingPropertyInfo), '("autoFlushBus", PipelineAutoFlushBusPropertyInfo), '("delay", PipelineDelayPropertyInfo), '("latency", PipelineLatencyPropertyInfo), '("messageForward", BinMessageForwardPropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Pipeline = PipelineSignalList+type PipelineSignalList = ('[ '("childAdded", ChildProxyChildAddedSignalInfo), '("childRemoved", ChildProxyChildRemovedSignalInfo), '("deepNotify", ObjectDeepNotifySignalInfo), '("doLatency", BinDoLatencySignalInfo), '("elementAdded", BinElementAddedSignalInfo), '("elementRemoved", BinElementRemovedSignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])++-- method Pipeline::new+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Pipeline"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_new" gst_pipeline_new :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Pipeline)+++pipelineNew ::+    (MonadIO m) =>+    Maybe (T.Text)                          -- name+    -> m Pipeline                           -- result+pipelineNew name = liftIO $ do+    maybeName <- case name of+        Nothing -> return nullPtr+        Just jName -> do+            jName' <- textToCString jName+            return jName'+    result <- gst_pipeline_new maybeName+    checkUnexpectedReturnNULL "gst_pipeline_new" result+    result' <- (newObject Pipeline) result+    freeMem maybeName+    return result'++-- method Pipeline::auto_clock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_auto_clock" gst_pipeline_auto_clock :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    IO ()+++pipelineAutoClock ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+pipelineAutoClock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pipeline_auto_clock _obj'+    touchManagedPtr _obj+    return ()++data PipelineAutoClockMethodInfo+instance (signature ~ (m ()), MonadIO m, PipelineK a) => MethodInfo PipelineAutoClockMethodInfo a signature where+    overloadedMethod _ = pipelineAutoClock++-- method Pipeline::get_auto_flush_bus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_get_auto_flush_bus" gst_pipeline_get_auto_flush_bus :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    IO CInt+++pipelineGetAutoFlushBus ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+pipelineGetAutoFlushBus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pipeline_get_auto_flush_bus _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PipelineGetAutoFlushBusMethodInfo+instance (signature ~ (m Bool), MonadIO m, PipelineK a) => MethodInfo PipelineGetAutoFlushBusMethodInfo a signature where+    overloadedMethod _ = pipelineGetAutoFlushBus++-- method Pipeline::get_bus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Bus"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_get_bus" gst_pipeline_get_bus :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    IO (Ptr Bus)+++pipelineGetBus ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> m Bus                                -- result+pipelineGetBus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pipeline_get_bus _obj'+    checkUnexpectedReturnNULL "gst_pipeline_get_bus" result+    result' <- (wrapObject Bus) result+    touchManagedPtr _obj+    return result'++data PipelineGetBusMethodInfo+instance (signature ~ (m Bus), MonadIO m, PipelineK a) => MethodInfo PipelineGetBusMethodInfo a signature where+    overloadedMethod _ = pipelineGetBus++-- method Pipeline::get_delay+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_get_delay" gst_pipeline_get_delay :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    IO Word64+++pipelineGetDelay ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+pipelineGetDelay _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pipeline_get_delay _obj'+    touchManagedPtr _obj+    return result++data PipelineGetDelayMethodInfo+instance (signature ~ (m Word64), MonadIO m, PipelineK a) => MethodInfo PipelineGetDelayMethodInfo a signature where+    overloadedMethod _ = pipelineGetDelay++-- method Pipeline::get_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_get_latency" gst_pipeline_get_latency :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    IO Word64+++pipelineGetLatency ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> m Word64                             -- result+pipelineGetLatency _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pipeline_get_latency _obj'+    touchManagedPtr _obj+    return result++data PipelineGetLatencyMethodInfo+instance (signature ~ (m Word64), MonadIO m, PipelineK a) => MethodInfo PipelineGetLatencyMethodInfo a signature where+    overloadedMethod _ = pipelineGetLatency++-- method Pipeline::get_pipeline_clock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Clock"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_get_pipeline_clock" gst_pipeline_get_pipeline_clock :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    IO (Ptr Clock)+++pipelineGetPipelineClock ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> m Clock                              -- result+pipelineGetPipelineClock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_pipeline_get_pipeline_clock _obj'+    checkUnexpectedReturnNULL "gst_pipeline_get_pipeline_clock" result+    result' <- (wrapObject Clock) result+    touchManagedPtr _obj+    return result'++data PipelineGetPipelineClockMethodInfo+instance (signature ~ (m Clock), MonadIO m, PipelineK a) => MethodInfo PipelineGetPipelineClockMethodInfo a signature where+    overloadedMethod _ = pipelineGetPipelineClock++-- method Pipeline::set_auto_flush_bus+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "auto_flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_set_auto_flush_bus" gst_pipeline_set_auto_flush_bus :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    CInt ->                                 -- auto_flush : TBasicType TBoolean+    IO ()+++pipelineSetAutoFlushBus ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> Bool                                 -- autoFlush+    -> m ()                                 -- result+pipelineSetAutoFlushBus _obj autoFlush = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let autoFlush' = (fromIntegral . fromEnum) autoFlush+    gst_pipeline_set_auto_flush_bus _obj' autoFlush'+    touchManagedPtr _obj+    return ()++data PipelineSetAutoFlushBusMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m, PipelineK a) => MethodInfo PipelineSetAutoFlushBusMethodInfo a signature where+    overloadedMethod _ = pipelineSetAutoFlushBus++-- method Pipeline::set_delay+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delay", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_set_delay" gst_pipeline_set_delay :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    Word64 ->                               -- delay : TBasicType TUInt64+    IO ()+++pipelineSetDelay ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> Word64                               -- delay+    -> m ()                                 -- result+pipelineSetDelay _obj delay = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pipeline_set_delay _obj' delay+    touchManagedPtr _obj+    return ()++data PipelineSetDelayMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, PipelineK a) => MethodInfo PipelineSetDelayMethodInfo a signature where+    overloadedMethod _ = pipelineSetDelay++-- method Pipeline::set_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_set_latency" gst_pipeline_set_latency :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    Word64 ->                               -- latency : TBasicType TUInt64+    IO ()+++pipelineSetLatency ::+    (MonadIO m, PipelineK a) =>+    a                                       -- _obj+    -> Word64                               -- latency+    -> m ()                                 -- result+pipelineSetLatency _obj latency = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_pipeline_set_latency _obj' latency+    touchManagedPtr _obj+    return ()++data PipelineSetLatencyMethodInfo+instance (signature ~ (Word64 -> m ()), MonadIO m, PipelineK a) => MethodInfo PipelineSetLatencyMethodInfo a signature where+    overloadedMethod _ = pipelineSetLatency++-- method Pipeline::use_clock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_pipeline_use_clock" gst_pipeline_use_clock :: +    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"+    IO ()+++pipelineUseClock ::+    (MonadIO m, PipelineK a, ClockK b) =>+    a                                       -- _obj+    -> Maybe (b)                            -- clock+    -> m ()                                 -- result+pipelineUseClock _obj clock = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeClock <- case clock of+        Nothing -> return nullPtr+        Just jClock -> do+            let jClock' = unsafeManagedPtrCastPtr jClock+            return jClock'+    gst_pipeline_use_clock _obj' maybeClock+    touchManagedPtr _obj+    whenJust clock touchManagedPtr+    return ()++data PipelineUseClockMethodInfo+instance (signature ~ (Maybe (b) -> m ()), MonadIO m, PipelineK a, ClockK b) => MethodInfo PipelineUseClockMethodInfo a signature where+    overloadedMethod _ = pipelineUseClock++
+ GI/Gst/Objects/Pipeline.hs-boot view
@@ -0,0 +1,26 @@+module GI.Gst.Objects.Pipeline 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++newtype Pipeline = Pipeline (ForeignPtr Pipeline)+instance GObject Pipeline where+class GObject o => PipelineK o+instance (GObject o, IsDescendantOf Pipeline o) => PipelineK o+data PipelineAutoFlushBusPropertyInfo+data PipelineDelayPropertyInfo+data PipelineLatencyPropertyInfo+data PipelineAutoClockMethodInfo+data PipelineGetAutoFlushBusMethodInfo+data PipelineGetBusMethodInfo+data PipelineGetDelayMethodInfo+data PipelineGetLatencyMethodInfo+data PipelineGetPipelineClockMethodInfo+data PipelineSetAutoFlushBusMethodInfo+data PipelineSetDelayMethodInfo+data PipelineSetLatencyMethodInfo+data PipelineUseClockMethodInfo
+ GI/Gst/Objects/Plugin.hs view
@@ -0,0 +1,903 @@+++{- |+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.Objects.Plugin+    ( ++-- * Exported types+    Plugin(..)                              ,+    PluginK                                 ,+    toPlugin                                ,+    noPlugin                                ,+++ -- * Methods+-- ** pluginAddDependency+    PluginAddDependencyMethodInfo           ,+    pluginAddDependency                     ,+++-- ** pluginAddDependencySimple+    PluginAddDependencySimpleMethodInfo     ,+    pluginAddDependencySimple               ,+++-- ** pluginGetCacheData+    PluginGetCacheDataMethodInfo            ,+    pluginGetCacheData                      ,+++-- ** pluginGetDescription+    PluginGetDescriptionMethodInfo          ,+    pluginGetDescription                    ,+++-- ** pluginGetFilename+    PluginGetFilenameMethodInfo             ,+    pluginGetFilename                       ,+++-- ** pluginGetLicense+    PluginGetLicenseMethodInfo              ,+    pluginGetLicense                        ,+++-- ** pluginGetName+    PluginGetNameMethodInfo                 ,+    pluginGetName                           ,+++-- ** pluginGetOrigin+    PluginGetOriginMethodInfo               ,+    pluginGetOrigin                         ,+++-- ** pluginGetPackage+    PluginGetPackageMethodInfo              ,+    pluginGetPackage                        ,+++-- ** pluginGetReleaseDateString+    PluginGetReleaseDateStringMethodInfo    ,+    pluginGetReleaseDateString              ,+++-- ** pluginGetSource+    PluginGetSourceMethodInfo               ,+    pluginGetSource                         ,+++-- ** pluginGetVersion+    PluginGetVersionMethodInfo              ,+    pluginGetVersion                        ,+++-- ** pluginIsLoaded+    PluginIsLoadedMethodInfo                ,+    pluginIsLoaded                          ,+++-- ** pluginListFree+    pluginListFree                          ,+++-- ** pluginLoad+    PluginLoadMethodInfo                    ,+    pluginLoad                              ,+++-- ** pluginLoadByName+    pluginLoadByName                        ,+++-- ** pluginLoadFile+    pluginLoadFile                          ,+++-- ** pluginRegisterStatic+    pluginRegisterStatic                    ,+++-- ** pluginRegisterStaticFull+    pluginRegisterStaticFull                ,+++-- ** pluginSetCacheData+    PluginSetCacheDataMethodInfo            ,+    pluginSetCacheData                      ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Plugin = Plugin (ForeignPtr Plugin)+foreign import ccall "gst_plugin_get_type"+    c_gst_plugin_get_type :: IO GType++type instance ParentTypes Plugin = PluginParentTypes+type PluginParentTypes = '[Object, GObject.Object]++instance GObject Plugin where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_plugin_get_type+    ++class GObject o => PluginK o+instance (GObject o, IsDescendantOf Plugin o) => PluginK o++toPlugin :: PluginK o => o -> IO Plugin+toPlugin = unsafeCastTo Plugin++noPlugin :: Maybe Plugin+noPlugin = Nothing++type family ResolvePluginMethod (t :: Symbol) (o :: *) :: * where+    ResolvePluginMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolvePluginMethod "addDependency" o = PluginAddDependencyMethodInfo+    ResolvePluginMethod "addDependencySimple" o = PluginAddDependencySimpleMethodInfo+    ResolvePluginMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolvePluginMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolvePluginMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolvePluginMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolvePluginMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolvePluginMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolvePluginMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolvePluginMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolvePluginMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolvePluginMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolvePluginMethod "isLoaded" o = PluginIsLoadedMethodInfo+    ResolvePluginMethod "load" o = PluginLoadMethodInfo+    ResolvePluginMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolvePluginMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolvePluginMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolvePluginMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolvePluginMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolvePluginMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolvePluginMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolvePluginMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolvePluginMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolvePluginMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolvePluginMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolvePluginMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolvePluginMethod "unparent" o = ObjectUnparentMethodInfo+    ResolvePluginMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolvePluginMethod "getCacheData" o = PluginGetCacheDataMethodInfo+    ResolvePluginMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolvePluginMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolvePluginMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolvePluginMethod "getDescription" o = PluginGetDescriptionMethodInfo+    ResolvePluginMethod "getFilename" o = PluginGetFilenameMethodInfo+    ResolvePluginMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolvePluginMethod "getLicense" o = PluginGetLicenseMethodInfo+    ResolvePluginMethod "getOrigin" o = PluginGetOriginMethodInfo+    ResolvePluginMethod "getPackage" o = PluginGetPackageMethodInfo+    ResolvePluginMethod "getParent" o = ObjectGetParentMethodInfo+    ResolvePluginMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolvePluginMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolvePluginMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolvePluginMethod "getReleaseDateString" o = PluginGetReleaseDateStringMethodInfo+    ResolvePluginMethod "getSource" o = PluginGetSourceMethodInfo+    ResolvePluginMethod "getValue" o = ObjectGetValueMethodInfo+    ResolvePluginMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolvePluginMethod "getVersion" o = PluginGetVersionMethodInfo+    ResolvePluginMethod "setCacheData" o = PluginSetCacheDataMethodInfo+    ResolvePluginMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolvePluginMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolvePluginMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolvePluginMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolvePluginMethod "setName" o = ObjectSetNameMethodInfo+    ResolvePluginMethod "setParent" o = ObjectSetParentMethodInfo+    ResolvePluginMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolvePluginMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePluginMethod t Plugin, MethodInfo info Plugin p) => IsLabelProxy t (Plugin -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePluginMethod t Plugin, MethodInfo info Plugin p) => IsLabel t (Plugin -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList Plugin = PluginAttributeList+type PluginAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Plugin = PluginSignalList+type PluginSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Plugin::add_dependency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "env_vars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paths", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "names", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PluginDependencyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_add_dependency" gst_plugin_add_dependency :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    CString ->                              -- env_vars : TBasicType TUTF8+    CString ->                              -- paths : TBasicType TUTF8+    CString ->                              -- names : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gst" "PluginDependencyFlags"+    IO ()+++pluginAddDependency ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- envVars+    -> Maybe (T.Text)                       -- paths+    -> Maybe (T.Text)                       -- names+    -> [PluginDependencyFlags]              -- flags+    -> m ()                                 -- result+pluginAddDependency _obj envVars paths names flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeEnvVars <- case envVars of+        Nothing -> return nullPtr+        Just jEnvVars -> do+            jEnvVars' <- textToCString jEnvVars+            return jEnvVars'+    maybePaths <- case paths of+        Nothing -> return nullPtr+        Just jPaths -> do+            jPaths' <- textToCString jPaths+            return jPaths'+    maybeNames <- case names of+        Nothing -> return nullPtr+        Just jNames -> do+            jNames' <- textToCString jNames+            return jNames'+    let flags' = gflagsToWord flags+    gst_plugin_add_dependency _obj' maybeEnvVars maybePaths maybeNames flags'+    touchManagedPtr _obj+    freeMem maybeEnvVars+    freeMem maybePaths+    freeMem maybeNames+    return ()++data PluginAddDependencyMethodInfo+instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> [PluginDependencyFlags] -> m ()), MonadIO m, PluginK a) => MethodInfo PluginAddDependencyMethodInfo a signature where+    overloadedMethod _ = pluginAddDependency++-- method Plugin::add_dependency_simple+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "env_vars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paths", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "names", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PluginDependencyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_add_dependency_simple" gst_plugin_add_dependency_simple :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    CString ->                              -- env_vars : TBasicType TUTF8+    CString ->                              -- paths : TBasicType TUTF8+    CString ->                              -- names : TBasicType TUTF8+    CUInt ->                                -- flags : TInterface "Gst" "PluginDependencyFlags"+    IO ()+++pluginAddDependencySimple ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> Maybe (T.Text)                       -- envVars+    -> Maybe (T.Text)                       -- paths+    -> Maybe (T.Text)                       -- names+    -> [PluginDependencyFlags]              -- flags+    -> m ()                                 -- result+pluginAddDependencySimple _obj envVars paths names flags = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    maybeEnvVars <- case envVars of+        Nothing -> return nullPtr+        Just jEnvVars -> do+            jEnvVars' <- textToCString jEnvVars+            return jEnvVars'+    maybePaths <- case paths of+        Nothing -> return nullPtr+        Just jPaths -> do+            jPaths' <- textToCString jPaths+            return jPaths'+    maybeNames <- case names of+        Nothing -> return nullPtr+        Just jNames -> do+            jNames' <- textToCString jNames+            return jNames'+    let flags' = gflagsToWord flags+    gst_plugin_add_dependency_simple _obj' maybeEnvVars maybePaths maybeNames flags'+    touchManagedPtr _obj+    freeMem maybeEnvVars+    freeMem maybePaths+    freeMem maybeNames+    return ()++data PluginAddDependencySimpleMethodInfo+instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> [PluginDependencyFlags] -> m ()), MonadIO m, PluginK a) => MethodInfo PluginAddDependencySimpleMethodInfo a signature where+    overloadedMethod _ = pluginAddDependencySimple++-- method Plugin::get_cache_data+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_cache_data" gst_plugin_get_cache_data :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO (Ptr Structure)+++pluginGetCacheData ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m Structure                          -- result+pluginGetCacheData _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_cache_data _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_cache_data" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data PluginGetCacheDataMethodInfo+instance (signature ~ (m Structure), MonadIO m, PluginK a) => MethodInfo PluginGetCacheDataMethodInfo a signature where+    overloadedMethod _ = pluginGetCacheData++-- method Plugin::get_description+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_description" gst_plugin_get_description :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetDescription ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetDescription _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_description _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_description" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetDescriptionMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetDescriptionMethodInfo a signature where+    overloadedMethod _ = pluginGetDescription++-- method Plugin::get_filename+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_filename" gst_plugin_get_filename :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetFilename ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetFilename _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_filename _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_filename" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetFilenameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetFilenameMethodInfo a signature where+    overloadedMethod _ = pluginGetFilename++-- method Plugin::get_license+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_license" gst_plugin_get_license :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetLicense ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetLicense _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_license _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_license" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetLicenseMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetLicenseMethodInfo a signature where+    overloadedMethod _ = pluginGetLicense++-- method Plugin::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_name" gst_plugin_get_name :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetName ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_name _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetNameMethodInfo a signature where+    overloadedMethod _ = pluginGetName++-- method Plugin::get_origin+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_origin" gst_plugin_get_origin :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetOrigin ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetOrigin _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_origin _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_origin" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetOriginMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetOriginMethodInfo a signature where+    overloadedMethod _ = pluginGetOrigin++-- method Plugin::get_package+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_package" gst_plugin_get_package :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetPackage ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetPackage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_package _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_package" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetPackageMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetPackageMethodInfo a signature where+    overloadedMethod _ = pluginGetPackage++-- method Plugin::get_release_date_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_release_date_string" gst_plugin_get_release_date_string :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetReleaseDateString ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetReleaseDateString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_release_date_string _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_release_date_string" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetReleaseDateStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetReleaseDateStringMethodInfo a signature where+    overloadedMethod _ = pluginGetReleaseDateString++-- method Plugin::get_source+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_source" gst_plugin_get_source :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetSource ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetSource _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_source _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_source" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetSourceMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetSourceMethodInfo a signature where+    overloadedMethod _ = pluginGetSource++-- method Plugin::get_version+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_get_version" gst_plugin_get_version :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CString+++pluginGetVersion ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginGetVersion _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_get_version _obj'+    checkUnexpectedReturnNULL "gst_plugin_get_version" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginGetVersionMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetVersionMethodInfo a signature where+    overloadedMethod _ = pluginGetVersion++-- method Plugin::is_loaded+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_is_loaded" gst_plugin_is_loaded :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO CInt+++pluginIsLoaded ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+pluginIsLoaded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_is_loaded _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PluginIsLoadedMethodInfo+instance (signature ~ (m Bool), MonadIO m, PluginK a) => MethodInfo PluginIsLoadedMethodInfo a signature where+    overloadedMethod _ = pluginIsLoaded++-- method Plugin::load+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Plugin"+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_load" gst_plugin_load :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    IO (Ptr Plugin)+++pluginLoad ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> m Plugin                             -- result+pluginLoad _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_load _obj'+    checkUnexpectedReturnNULL "gst_plugin_load" result+    result' <- (wrapObject Plugin) result+    touchManagedPtr _obj+    return result'++data PluginLoadMethodInfo+instance (signature ~ (m Plugin), MonadIO m, PluginK a) => MethodInfo PluginLoadMethodInfo a signature where+    overloadedMethod _ = pluginLoad++-- method Plugin::set_cache_data+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cache_data", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_set_cache_data" gst_plugin_set_cache_data :: +    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"+    Ptr Structure ->                        -- cache_data : TInterface "Gst" "Structure"+    IO ()+++pluginSetCacheData ::+    (MonadIO m, PluginK a) =>+    a                                       -- _obj+    -> Structure                            -- cacheData+    -> m ()                                 -- result+pluginSetCacheData _obj cacheData = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    cacheData' <- copyBoxed cacheData+    gst_plugin_set_cache_data _obj' cacheData'+    touchManagedPtr _obj+    touchManagedPtr cacheData+    return ()++data PluginSetCacheDataMethodInfo+instance (signature ~ (Structure -> m ()), MonadIO m, PluginK a) => MethodInfo PluginSetCacheDataMethodInfo a signature where+    overloadedMethod _ = pluginSetCacheData++-- method Plugin::list_free+-- method type : MemberFunction+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "Plugin"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_list_free" gst_plugin_list_free :: +    Ptr (GList (Ptr Plugin)) ->             -- list : TGList (TInterface "Gst" "Plugin")+    IO ()+++pluginListFree ::+    (MonadIO m, PluginK a) =>+    [a]                                     -- list+    -> m ()                                 -- result+pluginListFree list = liftIO $ do+    list' <- mapM refObject list+    list'' <- packGList list'+    gst_plugin_list_free list''+    mapM_ touchManagedPtr list+    return ()++-- method Plugin::load_by_name+-- method type : MemberFunction+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Plugin"+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_load_by_name" gst_plugin_load_by_name :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Plugin)+++pluginLoadByName ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> m Plugin                             -- result+pluginLoadByName name = liftIO $ do+    name' <- textToCString name+    result <- gst_plugin_load_by_name name'+    checkUnexpectedReturnNULL "gst_plugin_load_by_name" result+    result' <- (wrapObject Plugin) result+    freeMem name'+    return result'++-- method Plugin::load_file+-- method type : MemberFunction+-- Args : [Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Plugin"+-- throws : True+-- Skip return : False++foreign import ccall "gst_plugin_load_file" gst_plugin_load_file :: +    CString ->                              -- filename : TBasicType TUTF8+    Ptr (Ptr GError) ->                     -- error+    IO (Ptr Plugin)+++pluginLoadFile ::+    (MonadIO m) =>+    T.Text                                  -- filename+    -> m Plugin                             -- result+pluginLoadFile filename = liftIO $ do+    filename' <- textToCString filename+    onException (do+        result <- propagateGError $ gst_plugin_load_file filename'+        checkUnexpectedReturnNULL "gst_plugin_load_file" result+        result' <- (wrapObject Plugin) result+        freeMem filename'+        return result'+     ) (do+        freeMem filename'+     )++-- method Plugin::register_static+-- method type : MemberFunction+-- Args : [Arg {argCName = "major_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minor_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init_func", argType = TInterface "Gst" "PluginInitFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "license", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "package", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_register_static" gst_plugin_register_static :: +    Int32 ->                                -- major_version : TBasicType TInt32+    Int32 ->                                -- minor_version : TBasicType TInt32+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- description : TBasicType TUTF8+    FunPtr PluginInitFuncC ->               -- init_func : TInterface "Gst" "PluginInitFunc"+    CString ->                              -- version : TBasicType TUTF8+    CString ->                              -- license : TBasicType TUTF8+    CString ->                              -- source : TBasicType TUTF8+    CString ->                              -- package : TBasicType TUTF8+    CString ->                              -- origin : TBasicType TUTF8+    IO CInt+++pluginRegisterStatic ::+    (MonadIO m) =>+    Int32                                   -- majorVersion+    -> Int32                                -- minorVersion+    -> T.Text                               -- name+    -> T.Text                               -- description+    -> PluginInitFunc                       -- initFunc+    -> T.Text                               -- version+    -> T.Text                               -- license+    -> T.Text                               -- source+    -> T.Text                               -- package+    -> T.Text                               -- origin+    -> m Bool                               -- result+pluginRegisterStatic majorVersion minorVersion name description initFunc version license source package origin = liftIO $ do+    name' <- textToCString name+    description' <- textToCString description+    initFunc' <- mkPluginInitFunc (pluginInitFuncWrapper Nothing initFunc)+    version' <- textToCString version+    license' <- textToCString license+    source' <- textToCString source+    package' <- textToCString package+    origin' <- textToCString origin+    result <- gst_plugin_register_static majorVersion minorVersion name' description' initFunc' version' license' source' package' origin'+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr initFunc'+    freeMem name'+    freeMem description'+    freeMem version'+    freeMem license'+    freeMem source'+    freeMem package'+    freeMem origin'+    return result'++-- method Plugin::register_static_full+-- method type : MemberFunction+-- Args : [Arg {argCName = "major_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minor_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init_full_func", argType = TInterface "Gst" "PluginInitFullFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 10, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "license", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "package", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_register_static_full" gst_plugin_register_static_full :: +    Int32 ->                                -- major_version : TBasicType TInt32+    Int32 ->                                -- minor_version : TBasicType TInt32+    CString ->                              -- name : TBasicType TUTF8+    CString ->                              -- description : TBasicType TUTF8+    FunPtr PluginInitFullFuncC ->           -- init_full_func : TInterface "Gst" "PluginInitFullFunc"+    CString ->                              -- version : TBasicType TUTF8+    CString ->                              -- license : TBasicType TUTF8+    CString ->                              -- source : TBasicType TUTF8+    CString ->                              -- package : TBasicType TUTF8+    CString ->                              -- origin : TBasicType TUTF8+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++pluginRegisterStaticFull ::+    (MonadIO m) =>+    Int32                                   -- majorVersion+    -> Int32                                -- minorVersion+    -> T.Text                               -- name+    -> T.Text                               -- description+    -> PluginInitFullFunc                   -- initFullFunc+    -> T.Text                               -- version+    -> T.Text                               -- license+    -> T.Text                               -- source+    -> T.Text                               -- package+    -> T.Text                               -- origin+    -> m Bool                               -- result+pluginRegisterStaticFull majorVersion minorVersion name description initFullFunc version license source package origin = liftIO $ do+    name' <- textToCString name+    description' <- textToCString description+    initFullFunc' <- mkPluginInitFullFunc (pluginInitFullFuncWrapper Nothing initFullFunc)+    version' <- textToCString version+    license' <- textToCString license+    source' <- textToCString source+    package' <- textToCString package+    origin' <- textToCString origin+    let userData = nullPtr+    result <- gst_plugin_register_static_full majorVersion minorVersion name' description' initFullFunc' version' license' source' package' origin' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr initFullFunc'+    freeMem name'+    freeMem description'+    freeMem version'+    freeMem license'+    freeMem source'+    freeMem package'+    freeMem origin'+    return result'++
+ GI/Gst/Objects/Plugin.hs-boot view
@@ -0,0 +1,28 @@+module GI.Gst.Objects.Plugin 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++newtype Plugin = Plugin (ForeignPtr Plugin)+instance GObject Plugin where+class GObject o => PluginK o+instance (GObject o, IsDescendantOf Plugin o) => PluginK o+data PluginAddDependencyMethodInfo+data PluginAddDependencySimpleMethodInfo+data PluginGetCacheDataMethodInfo+data PluginGetDescriptionMethodInfo+data PluginGetFilenameMethodInfo+data PluginGetLicenseMethodInfo+data PluginGetNameMethodInfo+data PluginGetOriginMethodInfo+data PluginGetPackageMethodInfo+data PluginGetReleaseDateStringMethodInfo+data PluginGetSourceMethodInfo+data PluginGetVersionMethodInfo+data PluginIsLoadedMethodInfo+data PluginLoadMethodInfo+data PluginSetCacheDataMethodInfo
+ GI/Gst/Objects/PluginFeature.hs view
@@ -0,0 +1,446 @@+++{- |+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.Objects.PluginFeature+    ( ++-- * Exported types+    PluginFeature(..)                       ,+    PluginFeatureK                          ,+    toPluginFeature                         ,+    noPluginFeature                         ,+++ -- * Methods+-- ** pluginFeatureCheckVersion+    PluginFeatureCheckVersionMethodInfo     ,+    pluginFeatureCheckVersion               ,+++-- ** pluginFeatureGetPlugin+    PluginFeatureGetPluginMethodInfo        ,+    pluginFeatureGetPlugin                  ,+++-- ** pluginFeatureGetPluginName+    PluginFeatureGetPluginNameMethodInfo    ,+    pluginFeatureGetPluginName              ,+++-- ** pluginFeatureGetRank+    PluginFeatureGetRankMethodInfo          ,+    pluginFeatureGetRank                    ,+++-- ** pluginFeatureListCopy+    pluginFeatureListCopy                   ,+++-- ** pluginFeatureListDebug+    pluginFeatureListDebug                  ,+++-- ** pluginFeatureListFree+    pluginFeatureListFree                   ,+++-- ** pluginFeatureLoad+    PluginFeatureLoadMethodInfo             ,+    pluginFeatureLoad                       ,+++-- ** pluginFeatureRankCompareFunc+    pluginFeatureRankCompareFunc            ,+++-- ** pluginFeatureSetRank+    PluginFeatureSetRankMethodInfo          ,+    pluginFeatureSetRank                    ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype PluginFeature = PluginFeature (ForeignPtr PluginFeature)+foreign import ccall "gst_plugin_feature_get_type"+    c_gst_plugin_feature_get_type :: IO GType++type instance ParentTypes PluginFeature = PluginFeatureParentTypes+type PluginFeatureParentTypes = '[Object, GObject.Object]++instance GObject PluginFeature where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_plugin_feature_get_type+    ++class GObject o => PluginFeatureK o+instance (GObject o, IsDescendantOf PluginFeature o) => PluginFeatureK o++toPluginFeature :: PluginFeatureK o => o -> IO PluginFeature+toPluginFeature = unsafeCastTo PluginFeature++noPluginFeature :: Maybe PluginFeature+noPluginFeature = Nothing++type family ResolvePluginFeatureMethod (t :: Symbol) (o :: *) :: * where+    ResolvePluginFeatureMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolvePluginFeatureMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolvePluginFeatureMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolvePluginFeatureMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo+    ResolvePluginFeatureMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolvePluginFeatureMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolvePluginFeatureMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolvePluginFeatureMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolvePluginFeatureMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolvePluginFeatureMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolvePluginFeatureMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolvePluginFeatureMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolvePluginFeatureMethod "load" o = PluginFeatureLoadMethodInfo+    ResolvePluginFeatureMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolvePluginFeatureMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolvePluginFeatureMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolvePluginFeatureMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolvePluginFeatureMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolvePluginFeatureMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolvePluginFeatureMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolvePluginFeatureMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolvePluginFeatureMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolvePluginFeatureMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolvePluginFeatureMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolvePluginFeatureMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolvePluginFeatureMethod "unparent" o = ObjectUnparentMethodInfo+    ResolvePluginFeatureMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolvePluginFeatureMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolvePluginFeatureMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolvePluginFeatureMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolvePluginFeatureMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolvePluginFeatureMethod "getName" o = ObjectGetNameMethodInfo+    ResolvePluginFeatureMethod "getParent" o = ObjectGetParentMethodInfo+    ResolvePluginFeatureMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolvePluginFeatureMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo+    ResolvePluginFeatureMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo+    ResolvePluginFeatureMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolvePluginFeatureMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolvePluginFeatureMethod "getRank" o = PluginFeatureGetRankMethodInfo+    ResolvePluginFeatureMethod "getValue" o = ObjectGetValueMethodInfo+    ResolvePluginFeatureMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolvePluginFeatureMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolvePluginFeatureMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolvePluginFeatureMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolvePluginFeatureMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolvePluginFeatureMethod "setName" o = ObjectSetNameMethodInfo+    ResolvePluginFeatureMethod "setParent" o = ObjectSetParentMethodInfo+    ResolvePluginFeatureMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolvePluginFeatureMethod "setRank" o = PluginFeatureSetRankMethodInfo+    ResolvePluginFeatureMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePluginFeatureMethod t PluginFeature, MethodInfo info PluginFeature p) => IsLabelProxy t (PluginFeature -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePluginFeatureMethod t PluginFeature, MethodInfo info PluginFeature p) => IsLabel t (PluginFeature -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList PluginFeature = PluginFeatureAttributeList+type PluginFeatureAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList PluginFeature = PluginFeatureSignalList+type PluginFeatureSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method PluginFeature::check_version+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_major", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_minor", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_micro", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_check_version" gst_plugin_feature_check_version :: +    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"+    Word32 ->                               -- min_major : TBasicType TUInt32+    Word32 ->                               -- min_minor : TBasicType TUInt32+    Word32 ->                               -- min_micro : TBasicType TUInt32+    IO CInt+++pluginFeatureCheckVersion ::+    (MonadIO m, PluginFeatureK a) =>+    a                                       -- _obj+    -> Word32                               -- minMajor+    -> Word32                               -- minMinor+    -> Word32                               -- minMicro+    -> m Bool                               -- result+pluginFeatureCheckVersion _obj minMajor minMinor minMicro = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_feature_check_version _obj' minMajor minMinor minMicro+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PluginFeatureCheckVersionMethodInfo+instance (signature ~ (Word32 -> Word32 -> Word32 -> m Bool), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureCheckVersionMethodInfo a signature where+    overloadedMethod _ = pluginFeatureCheckVersion++-- method PluginFeature::get_plugin+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Plugin"+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_get_plugin" gst_plugin_feature_get_plugin :: +    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"+    IO (Ptr Plugin)+++pluginFeatureGetPlugin ::+    (MonadIO m, PluginFeatureK a) =>+    a                                       -- _obj+    -> m Plugin                             -- result+pluginFeatureGetPlugin _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_feature_get_plugin _obj'+    checkUnexpectedReturnNULL "gst_plugin_feature_get_plugin" result+    result' <- (wrapObject Plugin) result+    touchManagedPtr _obj+    return result'++data PluginFeatureGetPluginMethodInfo+instance (signature ~ (m Plugin), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureGetPluginMethodInfo a signature where+    overloadedMethod _ = pluginFeatureGetPlugin++-- method PluginFeature::get_plugin_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_get_plugin_name" gst_plugin_feature_get_plugin_name :: +    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"+    IO CString+++pluginFeatureGetPluginName ::+    (MonadIO m, PluginFeatureK a) =>+    a                                       -- _obj+    -> m T.Text                             -- result+pluginFeatureGetPluginName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_feature_get_plugin_name _obj'+    checkUnexpectedReturnNULL "gst_plugin_feature_get_plugin_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data PluginFeatureGetPluginNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureGetPluginNameMethodInfo a signature where+    overloadedMethod _ = pluginFeatureGetPluginName++-- method PluginFeature::get_rank+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_get_rank" gst_plugin_feature_get_rank :: +    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"+    IO Word32+++pluginFeatureGetRank ::+    (MonadIO m, PluginFeatureK a) =>+    a                                       -- _obj+    -> m Word32                             -- result+pluginFeatureGetRank _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_feature_get_rank _obj'+    touchManagedPtr _obj+    return result++data PluginFeatureGetRankMethodInfo+instance (signature ~ (m Word32), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureGetRankMethodInfo a signature where+    overloadedMethod _ = pluginFeatureGetRank++-- method PluginFeature::load+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PluginFeature"+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_load" gst_plugin_feature_load :: +    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"+    IO (Ptr PluginFeature)+++pluginFeatureLoad ::+    (MonadIO m, PluginFeatureK a) =>+    a                                       -- _obj+    -> m PluginFeature                      -- result+pluginFeatureLoad _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_plugin_feature_load _obj'+    checkUnexpectedReturnNULL "gst_plugin_feature_load" result+    result' <- (wrapObject PluginFeature) result+    touchManagedPtr _obj+    return result'++data PluginFeatureLoadMethodInfo+instance (signature ~ (m PluginFeature), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureLoadMethodInfo a signature where+    overloadedMethod _ = pluginFeatureLoad++-- method PluginFeature::set_rank+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_set_rank" gst_plugin_feature_set_rank :: +    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"+    Word32 ->                               -- rank : TBasicType TUInt32+    IO ()+++pluginFeatureSetRank ::+    (MonadIO m, PluginFeatureK a) =>+    a                                       -- _obj+    -> Word32                               -- rank+    -> m ()                                 -- result+pluginFeatureSetRank _obj rank = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_plugin_feature_set_rank _obj' rank+    touchManagedPtr _obj+    return ()++data PluginFeatureSetRankMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureSetRankMethodInfo a signature where+    overloadedMethod _ = pluginFeatureSetRank++-- method PluginFeature::list_copy+-- method type : MemberFunction+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "PluginFeature"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "PluginFeature")+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_list_copy" gst_plugin_feature_list_copy :: +    Ptr (GList (Ptr PluginFeature)) ->      -- list : TGList (TInterface "Gst" "PluginFeature")+    IO (Ptr (GList (Ptr PluginFeature)))+++pluginFeatureListCopy ::+    (MonadIO m, PluginFeatureK a) =>+    [a]                                     -- list+    -> m [PluginFeature]                    -- result+pluginFeatureListCopy list = liftIO $ do+    let list' = map unsafeManagedPtrCastPtr list+    list'' <- packGList list'+    result <- gst_plugin_feature_list_copy list''+    checkUnexpectedReturnNULL "gst_plugin_feature_list_copy" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject PluginFeature) result'+    g_list_free result+    mapM_ touchManagedPtr list+    g_list_free list''+    return result''++-- method PluginFeature::list_debug+-- method type : MemberFunction+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "PluginFeature"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_list_debug" gst_plugin_feature_list_debug :: +    Ptr (GList (Ptr PluginFeature)) ->      -- list : TGList (TInterface "Gst" "PluginFeature")+    IO ()+++pluginFeatureListDebug ::+    (MonadIO m, PluginFeatureK a) =>+    [a]                                     -- list+    -> m ()                                 -- result+pluginFeatureListDebug list = liftIO $ do+    let list' = map unsafeManagedPtrCastPtr list+    list'' <- packGList list'+    gst_plugin_feature_list_debug list''+    mapM_ touchManagedPtr list+    g_list_free list''+    return ()++-- method PluginFeature::list_free+-- method type : MemberFunction+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "PluginFeature"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_list_free" gst_plugin_feature_list_free :: +    Ptr (GList (Ptr PluginFeature)) ->      -- list : TGList (TInterface "Gst" "PluginFeature")+    IO ()+++pluginFeatureListFree ::+    (MonadIO m, PluginFeatureK a) =>+    [a]                                     -- list+    -> m ()                                 -- result+pluginFeatureListFree list = liftIO $ do+    list' <- mapM refObject list+    list'' <- packGList list'+    gst_plugin_feature_list_free list''+    mapM_ touchManagedPtr list+    return ()++-- method PluginFeature::rank_compare_func+-- method type : MemberFunction+-- Args : [Arg {argCName = "p1", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "p2", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_plugin_feature_rank_compare_func" gst_plugin_feature_rank_compare_func :: +    Ptr () ->                               -- p1 : TBasicType TVoid+    Ptr () ->                               -- p2 : TBasicType TVoid+    IO Int32+++pluginFeatureRankCompareFunc ::+    (MonadIO m) =>+    Ptr ()                                  -- p1+    -> Ptr ()                               -- p2+    -> m Int32                              -- result+pluginFeatureRankCompareFunc p1 p2 = liftIO $ do+    result <- gst_plugin_feature_rank_compare_func p1 p2+    return result++
+ GI/Gst/Objects/PluginFeature.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gst.Objects.PluginFeature 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++newtype PluginFeature = PluginFeature (ForeignPtr PluginFeature)+instance GObject PluginFeature where+class GObject o => PluginFeatureK o+instance (GObject o, IsDescendantOf PluginFeature o) => PluginFeatureK o+data PluginFeatureCheckVersionMethodInfo+data PluginFeatureGetPluginMethodInfo+data PluginFeatureGetPluginNameMethodInfo+data PluginFeatureGetRankMethodInfo+data PluginFeatureLoadMethodInfo+data PluginFeatureSetRankMethodInfo
+ GI/Gst/Objects/ProxyPad.hs view
@@ -0,0 +1,380 @@+++{- |+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.Objects.ProxyPad+    ( ++-- * Exported types+    ProxyPad(..)                            ,+    ProxyPadK                               ,+    toProxyPad                              ,+    noProxyPad                              ,+++ -- * Methods+-- ** proxyPadChainDefault+    proxyPadChainDefault                    ,+++-- ** proxyPadChainListDefault+    proxyPadChainListDefault                ,+++-- ** proxyPadGetInternal+    ProxyPadGetInternalMethodInfo           ,+    proxyPadGetInternal                     ,+++-- ** proxyPadGetrangeDefault+    proxyPadGetrangeDefault                 ,+++-- ** proxyPadIterateInternalLinksDefault+    proxyPadIterateInternalLinksDefault     ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype ProxyPad = ProxyPad (ForeignPtr ProxyPad)+foreign import ccall "gst_proxy_pad_get_type"+    c_gst_proxy_pad_get_type :: IO GType++type instance ParentTypes ProxyPad = ProxyPadParentTypes+type ProxyPadParentTypes = '[Pad, Object, GObject.Object]++instance GObject ProxyPad where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_proxy_pad_get_type+    ++class GObject o => ProxyPadK o+instance (GObject o, IsDescendantOf ProxyPad o) => ProxyPadK o++toProxyPad :: ProxyPadK o => o -> IO ProxyPad+toProxyPad = unsafeCastTo ProxyPad++noProxyPad :: Maybe ProxyPad+noProxyPad = Nothing++type family ResolveProxyPadMethod (t :: Symbol) (o :: *) :: * where+    ResolveProxyPadMethod "activateMode" o = PadActivateModeMethodInfo+    ResolveProxyPadMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveProxyPadMethod "addProbe" o = PadAddProbeMethodInfo+    ResolveProxyPadMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveProxyPadMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveProxyPadMethod "canLink" o = PadCanLinkMethodInfo+    ResolveProxyPadMethod "chain" o = PadChainMethodInfo+    ResolveProxyPadMethod "chainList" o = PadChainListMethodInfo+    ResolveProxyPadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo+    ResolveProxyPadMethod "createStreamId" o = PadCreateStreamIdMethodInfo+    ResolveProxyPadMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveProxyPadMethod "eventDefault" o = PadEventDefaultMethodInfo+    ResolveProxyPadMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveProxyPadMethod "forward" o = PadForwardMethodInfo+    ResolveProxyPadMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveProxyPadMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveProxyPadMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveProxyPadMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveProxyPadMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveProxyPadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo+    ResolveProxyPadMethod "isActive" o = PadIsActiveMethodInfo+    ResolveProxyPadMethod "isBlocked" o = PadIsBlockedMethodInfo+    ResolveProxyPadMethod "isBlocking" o = PadIsBlockingMethodInfo+    ResolveProxyPadMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveProxyPadMethod "isLinked" o = PadIsLinkedMethodInfo+    ResolveProxyPadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo+    ResolveProxyPadMethod "link" o = PadLinkMethodInfo+    ResolveProxyPadMethod "linkFull" o = PadLinkFullMethodInfo+    ResolveProxyPadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo+    ResolveProxyPadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo+    ResolveProxyPadMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveProxyPadMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveProxyPadMethod "pauseTask" o = PadPauseTaskMethodInfo+    ResolveProxyPadMethod "peerQuery" o = PadPeerQueryMethodInfo+    ResolveProxyPadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo+    ResolveProxyPadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo+    ResolveProxyPadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo+    ResolveProxyPadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo+    ResolveProxyPadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo+    ResolveProxyPadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo+    ResolveProxyPadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo+    ResolveProxyPadMethod "pullRange" o = PadPullRangeMethodInfo+    ResolveProxyPadMethod "push" o = PadPushMethodInfo+    ResolveProxyPadMethod "pushEvent" o = PadPushEventMethodInfo+    ResolveProxyPadMethod "pushList" o = PadPushListMethodInfo+    ResolveProxyPadMethod "query" o = PadQueryMethodInfo+    ResolveProxyPadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo+    ResolveProxyPadMethod "queryCaps" o = PadQueryCapsMethodInfo+    ResolveProxyPadMethod "queryConvert" o = PadQueryConvertMethodInfo+    ResolveProxyPadMethod "queryDefault" o = PadQueryDefaultMethodInfo+    ResolveProxyPadMethod "queryDuration" o = PadQueryDurationMethodInfo+    ResolveProxyPadMethod "queryPosition" o = PadQueryPositionMethodInfo+    ResolveProxyPadMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveProxyPadMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveProxyPadMethod "removeProbe" o = PadRemoveProbeMethodInfo+    ResolveProxyPadMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveProxyPadMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveProxyPadMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveProxyPadMethod "sendEvent" o = PadSendEventMethodInfo+    ResolveProxyPadMethod "startTask" o = PadStartTaskMethodInfo+    ResolveProxyPadMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveProxyPadMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveProxyPadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo+    ResolveProxyPadMethod "stopTask" o = PadStopTaskMethodInfo+    ResolveProxyPadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo+    ResolveProxyPadMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveProxyPadMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveProxyPadMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveProxyPadMethod "unlink" o = PadUnlinkMethodInfo+    ResolveProxyPadMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveProxyPadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo+    ResolveProxyPadMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveProxyPadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo+    ResolveProxyPadMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveProxyPadMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveProxyPadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo+    ResolveProxyPadMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveProxyPadMethod "getDirection" o = PadGetDirectionMethodInfo+    ResolveProxyPadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo+    ResolveProxyPadMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveProxyPadMethod "getInternal" o = ProxyPadGetInternalMethodInfo+    ResolveProxyPadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo+    ResolveProxyPadMethod "getName" o = ObjectGetNameMethodInfo+    ResolveProxyPadMethod "getOffset" o = PadGetOffsetMethodInfo+    ResolveProxyPadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo+    ResolveProxyPadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo+    ResolveProxyPadMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveProxyPadMethod "getParentElement" o = PadGetParentElementMethodInfo+    ResolveProxyPadMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveProxyPadMethod "getPeer" o = PadGetPeerMethodInfo+    ResolveProxyPadMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveProxyPadMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveProxyPadMethod "getRange" o = PadGetRangeMethodInfo+    ResolveProxyPadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo+    ResolveProxyPadMethod "getStreamId" o = PadGetStreamIdMethodInfo+    ResolveProxyPadMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveProxyPadMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveProxyPadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo+    ResolveProxyPadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo+    ResolveProxyPadMethod "setActive" o = PadSetActiveMethodInfo+    ResolveProxyPadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo+    ResolveProxyPadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo+    ResolveProxyPadMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveProxyPadMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveProxyPadMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveProxyPadMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveProxyPadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo+    ResolveProxyPadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo+    ResolveProxyPadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo+    ResolveProxyPadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo+    ResolveProxyPadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo+    ResolveProxyPadMethod "setName" o = ObjectSetNameMethodInfo+    ResolveProxyPadMethod "setOffset" o = PadSetOffsetMethodInfo+    ResolveProxyPadMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveProxyPadMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveProxyPadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo+    ResolveProxyPadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo+    ResolveProxyPadMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveProxyPadMethod t ProxyPad, MethodInfo info ProxyPad p) => IsLabelProxy t (ProxyPad -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveProxyPadMethod t ProxyPad, MethodInfo info ProxyPad p) => IsLabel t (ProxyPad -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList ProxyPad = ProxyPadAttributeList+type ProxyPadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])++type instance SignalList ProxyPad = ProxyPadSignalList+type ProxyPadSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])++-- method ProxyPad::get_internal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ProxyPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "ProxyPad"+-- throws : False+-- Skip return : False++foreign import ccall "gst_proxy_pad_get_internal" gst_proxy_pad_get_internal :: +    Ptr ProxyPad ->                         -- _obj : TInterface "Gst" "ProxyPad"+    IO (Ptr ProxyPad)+++proxyPadGetInternal ::+    (MonadIO m, ProxyPadK a) =>+    a                                       -- _obj+    -> m ProxyPad                           -- result+proxyPadGetInternal _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_proxy_pad_get_internal _obj'+    checkUnexpectedReturnNULL "gst_proxy_pad_get_internal" result+    result' <- (wrapObject ProxyPad) result+    touchManagedPtr _obj+    return result'++data ProxyPadGetInternalMethodInfo+instance (signature ~ (m ProxyPad), MonadIO m, ProxyPadK a) => MethodInfo ProxyPadGetInternalMethodInfo a signature where+    overloadedMethod _ = proxyPadGetInternal++-- method ProxyPad::chain_default+-- method type : MemberFunction+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_proxy_pad_chain_default" gst_proxy_pad_chain_default :: +    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO CUInt+++proxyPadChainDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- pad+    -> Maybe (b)                            -- parent+    -> Buffer                               -- buffer+    -> m FlowReturn                         -- result+proxyPadChainDefault pad parent buffer = liftIO $ do+    let pad' = unsafeManagedPtrCastPtr pad+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    buffer' <- copyBoxed buffer+    result <- gst_proxy_pad_chain_default pad' maybeParent buffer'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr pad+    whenJust parent touchManagedPtr+    touchManagedPtr buffer+    return result'++-- method ProxyPad::chain_list_default+-- method type : MemberFunction+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_proxy_pad_chain_list_default" gst_proxy_pad_chain_list_default :: +    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    Ptr BufferList ->                       -- list : TInterface "Gst" "BufferList"+    IO CUInt+++proxyPadChainListDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- pad+    -> Maybe (b)                            -- parent+    -> BufferList                           -- list+    -> m FlowReturn                         -- result+proxyPadChainListDefault pad parent list = liftIO $ do+    let pad' = unsafeManagedPtrCastPtr pad+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    list' <- copyBoxed list+    result <- gst_proxy_pad_chain_list_default pad' maybeParent list'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr pad+    whenJust parent touchManagedPtr+    touchManagedPtr list+    return result'++-- method ProxyPad::getrange_default+-- method type : MemberFunction+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "FlowReturn"+-- throws : False+-- Skip return : False++foreign import ccall "gst_proxy_pad_getrange_default" gst_proxy_pad_getrange_default :: +    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word32 ->                               -- size : TBasicType TUInt32+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO CUInt+++proxyPadGetrangeDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- pad+    -> b                                    -- parent+    -> Word64                               -- offset+    -> Word32                               -- size+    -> m (FlowReturn,Buffer)                -- result+proxyPadGetrangeDefault pad parent offset size = liftIO $ do+    let pad' = unsafeManagedPtrCastPtr pad+    let parent' = unsafeManagedPtrCastPtr parent+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)+    result <- gst_proxy_pad_getrange_default pad' parent' offset size buffer+    let result' = (toEnum . fromIntegral) result+    buffer' <- (wrapBoxed Buffer) buffer+    touchManagedPtr pad+    touchManagedPtr parent+    return (result', buffer')++-- method ProxyPad::iterate_internal_links_default+-- method type : MemberFunction+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_proxy_pad_iterate_internal_links_default" gst_proxy_pad_iterate_internal_links_default :: +    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"+    IO (Ptr Iterator)+++proxyPadIterateInternalLinksDefault ::+    (MonadIO m, PadK a, ObjectK b) =>+    a                                       -- pad+    -> Maybe (b)                            -- parent+    -> m Iterator                           -- result+proxyPadIterateInternalLinksDefault pad parent = liftIO $ do+    let pad' = unsafeManagedPtrCastPtr pad+    maybeParent <- case parent of+        Nothing -> return nullPtr+        Just jParent -> do+            let jParent' = unsafeManagedPtrCastPtr jParent+            return jParent'+    result <- gst_proxy_pad_iterate_internal_links_default pad' maybeParent+    checkUnexpectedReturnNULL "gst_proxy_pad_iterate_internal_links_default" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr pad+    whenJust parent touchManagedPtr+    return result'++
+ GI/Gst/Objects/ProxyPad.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gst.Objects.ProxyPad 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++newtype ProxyPad = ProxyPad (ForeignPtr ProxyPad)+instance GObject ProxyPad where+class GObject o => ProxyPadK o+instance (GObject o, IsDescendantOf ProxyPad o) => ProxyPadK o+data ProxyPadGetInternalMethodInfo
+ GI/Gst/Objects/Registry.hs view
@@ -0,0 +1,946 @@+++{- |+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.Objects.Registry+    ( ++-- * Exported types+    Registry(..)                            ,+    RegistryK                               ,+    toRegistry                              ,+    noRegistry                              ,+++ -- * Methods+-- ** registryAddFeature+    RegistryAddFeatureMethodInfo            ,+    registryAddFeature                      ,+++-- ** registryAddPlugin+    RegistryAddPluginMethodInfo             ,+    registryAddPlugin                       ,+++-- ** registryCheckFeatureVersion+    RegistryCheckFeatureVersionMethodInfo   ,+    registryCheckFeatureVersion             ,+++-- ** registryFeatureFilter+    RegistryFeatureFilterMethodInfo         ,+    registryFeatureFilter                   ,+++-- ** registryFindFeature+    RegistryFindFeatureMethodInfo           ,+    registryFindFeature                     ,+++-- ** registryFindPlugin+    RegistryFindPluginMethodInfo            ,+    registryFindPlugin                      ,+++-- ** registryForkIsEnabled+    registryForkIsEnabled                   ,+++-- ** registryForkSetEnabled+    registryForkSetEnabled                  ,+++-- ** registryGet+    registryGet                             ,+++-- ** registryGetFeatureList+    RegistryGetFeatureListMethodInfo        ,+    registryGetFeatureList                  ,+++-- ** registryGetFeatureListByPlugin+    RegistryGetFeatureListByPluginMethodInfo,+    registryGetFeatureListByPlugin          ,+++-- ** registryGetFeatureListCookie+    RegistryGetFeatureListCookieMethodInfo  ,+    registryGetFeatureListCookie            ,+++-- ** registryGetPluginList+    RegistryGetPluginListMethodInfo         ,+    registryGetPluginList                   ,+++-- ** registryLookup+    RegistryLookupMethodInfo                ,+    registryLookup                          ,+++-- ** registryLookupFeature+    RegistryLookupFeatureMethodInfo         ,+    registryLookupFeature                   ,+++-- ** registryPluginFilter+    RegistryPluginFilterMethodInfo          ,+    registryPluginFilter                    ,+++-- ** registryRemoveFeature+    RegistryRemoveFeatureMethodInfo         ,+    registryRemoveFeature                   ,+++-- ** registryRemovePlugin+    RegistryRemovePluginMethodInfo          ,+    registryRemovePlugin                    ,+++-- ** registryScanPath+    RegistryScanPathMethodInfo              ,+    registryScanPath                        ,+++++ -- * Signals+-- ** FeatureAdded+    RegistryFeatureAddedCallback            ,+    RegistryFeatureAddedCallbackC           ,+    RegistryFeatureAddedSignalInfo          ,+    afterRegistryFeatureAdded               ,+    mkRegistryFeatureAddedCallback          ,+    noRegistryFeatureAddedCallback          ,+    onRegistryFeatureAdded                  ,+    registryFeatureAddedCallbackWrapper     ,+    registryFeatureAddedClosure             ,+++-- ** PluginAdded+    RegistryPluginAddedCallback             ,+    RegistryPluginAddedCallbackC            ,+    RegistryPluginAddedSignalInfo           ,+    afterRegistryPluginAdded                ,+    mkRegistryPluginAddedCallback           ,+    noRegistryPluginAddedCallback           ,+    onRegistryPluginAdded                   ,+    registryPluginAddedCallbackWrapper      ,+    registryPluginAddedClosure              ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype Registry = Registry (ForeignPtr Registry)+foreign import ccall "gst_registry_get_type"+    c_gst_registry_get_type :: IO GType++type instance ParentTypes Registry = RegistryParentTypes+type RegistryParentTypes = '[Object, GObject.Object]++instance GObject Registry where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_registry_get_type+    ++class GObject o => RegistryK o+instance (GObject o, IsDescendantOf Registry o) => RegistryK o++toRegistry :: RegistryK o => o -> IO Registry+toRegistry = unsafeCastTo Registry++noRegistry :: Maybe Registry+noRegistry = Nothing++type family ResolveRegistryMethod (t :: Symbol) (o :: *) :: * where+    ResolveRegistryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveRegistryMethod "addFeature" o = RegistryAddFeatureMethodInfo+    ResolveRegistryMethod "addPlugin" o = RegistryAddPluginMethodInfo+    ResolveRegistryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveRegistryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveRegistryMethod "checkFeatureVersion" o = RegistryCheckFeatureVersionMethodInfo+    ResolveRegistryMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveRegistryMethod "featureFilter" o = RegistryFeatureFilterMethodInfo+    ResolveRegistryMethod "findFeature" o = RegistryFindFeatureMethodInfo+    ResolveRegistryMethod "findPlugin" o = RegistryFindPluginMethodInfo+    ResolveRegistryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveRegistryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveRegistryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveRegistryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveRegistryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveRegistryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveRegistryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveRegistryMethod "lookup" o = RegistryLookupMethodInfo+    ResolveRegistryMethod "lookupFeature" o = RegistryLookupFeatureMethodInfo+    ResolveRegistryMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveRegistryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveRegistryMethod "pluginFilter" o = RegistryPluginFilterMethodInfo+    ResolveRegistryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveRegistryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveRegistryMethod "removeFeature" o = RegistryRemoveFeatureMethodInfo+    ResolveRegistryMethod "removePlugin" o = RegistryRemovePluginMethodInfo+    ResolveRegistryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveRegistryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveRegistryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveRegistryMethod "scanPath" o = RegistryScanPathMethodInfo+    ResolveRegistryMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveRegistryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveRegistryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveRegistryMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveRegistryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveRegistryMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveRegistryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveRegistryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveRegistryMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveRegistryMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveRegistryMethod "getFeatureList" o = RegistryGetFeatureListMethodInfo+    ResolveRegistryMethod "getFeatureListByPlugin" o = RegistryGetFeatureListByPluginMethodInfo+    ResolveRegistryMethod "getFeatureListCookie" o = RegistryGetFeatureListCookieMethodInfo+    ResolveRegistryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveRegistryMethod "getName" o = ObjectGetNameMethodInfo+    ResolveRegistryMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveRegistryMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveRegistryMethod "getPluginList" o = RegistryGetPluginListMethodInfo+    ResolveRegistryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveRegistryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveRegistryMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveRegistryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveRegistryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveRegistryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveRegistryMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveRegistryMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveRegistryMethod "setName" o = ObjectSetNameMethodInfo+    ResolveRegistryMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveRegistryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveRegistryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveRegistryMethod t Registry, MethodInfo info Registry p) => IsLabelProxy t (Registry -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveRegistryMethod t Registry, MethodInfo info Registry p) => IsLabel t (Registry -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- signal Registry::feature-added+type RegistryFeatureAddedCallback =+    PluginFeature ->+    IO ()++noRegistryFeatureAddedCallback :: Maybe RegistryFeatureAddedCallback+noRegistryFeatureAddedCallback = Nothing++type RegistryFeatureAddedCallbackC =+    Ptr () ->                               -- object+    Ptr PluginFeature ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRegistryFeatureAddedCallback :: RegistryFeatureAddedCallbackC -> IO (FunPtr RegistryFeatureAddedCallbackC)++registryFeatureAddedClosure :: RegistryFeatureAddedCallback -> IO Closure+registryFeatureAddedClosure cb = newCClosure =<< mkRegistryFeatureAddedCallback wrapped+    where wrapped = registryFeatureAddedCallbackWrapper cb++registryFeatureAddedCallbackWrapper ::+    RegistryFeatureAddedCallback ->+    Ptr () ->+    Ptr PluginFeature ->+    Ptr () ->+    IO ()+registryFeatureAddedCallbackWrapper _cb _ feature _ = do+    feature' <- (newObject PluginFeature) feature+    _cb  feature'++onRegistryFeatureAdded :: (GObject a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId+onRegistryFeatureAdded obj cb = liftIO $ connectRegistryFeatureAdded obj cb SignalConnectBefore+afterRegistryFeatureAdded :: (GObject a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId+afterRegistryFeatureAdded obj cb = connectRegistryFeatureAdded obj cb SignalConnectAfter++connectRegistryFeatureAdded :: (GObject a, MonadIO m) =>+                               a -> RegistryFeatureAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectRegistryFeatureAdded obj cb after = liftIO $ do+    cb' <- mkRegistryFeatureAddedCallback (registryFeatureAddedCallbackWrapper cb)+    connectSignalFunPtr obj "feature-added" cb' after++-- signal Registry::plugin-added+type RegistryPluginAddedCallback =+    Plugin ->+    IO ()++noRegistryPluginAddedCallback :: Maybe RegistryPluginAddedCallback+noRegistryPluginAddedCallback = Nothing++type RegistryPluginAddedCallbackC =+    Ptr () ->                               -- object+    Ptr Plugin ->+    Ptr () ->                               -- user_data+    IO ()++foreign import ccall "wrapper"+    mkRegistryPluginAddedCallback :: RegistryPluginAddedCallbackC -> IO (FunPtr RegistryPluginAddedCallbackC)++registryPluginAddedClosure :: RegistryPluginAddedCallback -> IO Closure+registryPluginAddedClosure cb = newCClosure =<< mkRegistryPluginAddedCallback wrapped+    where wrapped = registryPluginAddedCallbackWrapper cb++registryPluginAddedCallbackWrapper ::+    RegistryPluginAddedCallback ->+    Ptr () ->+    Ptr Plugin ->+    Ptr () ->+    IO ()+registryPluginAddedCallbackWrapper _cb _ plugin _ = do+    plugin' <- (newObject Plugin) plugin+    _cb  plugin'++onRegistryPluginAdded :: (GObject a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId+onRegistryPluginAdded obj cb = liftIO $ connectRegistryPluginAdded obj cb SignalConnectBefore+afterRegistryPluginAdded :: (GObject a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId+afterRegistryPluginAdded obj cb = connectRegistryPluginAdded obj cb SignalConnectAfter++connectRegistryPluginAdded :: (GObject a, MonadIO m) =>+                              a -> RegistryPluginAddedCallback -> SignalConnectMode -> m SignalHandlerId+connectRegistryPluginAdded obj cb after = liftIO $ do+    cb' <- mkRegistryPluginAddedCallback (registryPluginAddedCallbackWrapper cb)+    connectSignalFunPtr obj "plugin-added" cb' after++type instance AttributeList Registry = RegistryAttributeList+type RegistryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++data RegistryFeatureAddedSignalInfo+instance SignalInfo RegistryFeatureAddedSignalInfo where+    type HaskellCallbackType RegistryFeatureAddedSignalInfo = RegistryFeatureAddedCallback+    connectSignal _ = connectRegistryFeatureAdded++data RegistryPluginAddedSignalInfo+instance SignalInfo RegistryPluginAddedSignalInfo where+    type HaskellCallbackType RegistryPluginAddedSignalInfo = RegistryPluginAddedCallback+    connectSignal _ = connectRegistryPluginAdded++type instance SignalList Registry = RegistrySignalList+type RegistrySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("featureAdded", RegistryFeatureAddedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pluginAdded", RegistryPluginAddedSignalInfo)] :: [(Symbol, *)])++-- method Registry::add_feature+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_add_feature" gst_registry_add_feature :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    Ptr PluginFeature ->                    -- feature : TInterface "Gst" "PluginFeature"+    IO CInt+++registryAddFeature ::+    (MonadIO m, RegistryK a, PluginFeatureK b) =>+    a                                       -- _obj+    -> b                                    -- feature+    -> m Bool                               -- result+registryAddFeature _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    feature' <- refObject feature+    result <- gst_registry_add_feature _obj' feature'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr feature+    return result'++data RegistryAddFeatureMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, RegistryK a, PluginFeatureK b) => MethodInfo RegistryAddFeatureMethodInfo a signature where+    overloadedMethod _ = registryAddFeature++-- method Registry::add_plugin+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_add_plugin" gst_registry_add_plugin :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"+    IO CInt+++registryAddPlugin ::+    (MonadIO m, RegistryK a, PluginK b) =>+    a                                       -- _obj+    -> b                                    -- plugin+    -> m Bool                               -- result+registryAddPlugin _obj plugin = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    plugin' <- refObject plugin+    result <- gst_registry_add_plugin _obj' plugin'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr plugin+    return result'++data RegistryAddPluginMethodInfo+instance (signature ~ (b -> m Bool), MonadIO m, RegistryK a, PluginK b) => MethodInfo RegistryAddPluginMethodInfo a signature where+    overloadedMethod _ = registryAddPlugin++-- method Registry::check_feature_version+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_major", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_minor", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_micro", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_check_feature_version" gst_registry_check_feature_version :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CString ->                              -- feature_name : TBasicType TUTF8+    Word32 ->                               -- min_major : TBasicType TUInt32+    Word32 ->                               -- min_minor : TBasicType TUInt32+    Word32 ->                               -- min_micro : TBasicType TUInt32+    IO CInt+++registryCheckFeatureVersion ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> T.Text                               -- featureName+    -> Word32                               -- minMajor+    -> Word32                               -- minMinor+    -> Word32                               -- minMicro+    -> m Bool                               -- result+registryCheckFeatureVersion _obj featureName minMajor minMinor minMicro = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    featureName' <- textToCString featureName+    result <- gst_registry_check_feature_version _obj' featureName' minMajor minMinor minMicro+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem featureName'+    return result'++data RegistryCheckFeatureVersionMethodInfo+instance (signature ~ (T.Text -> Word32 -> Word32 -> Word32 -> m Bool), MonadIO m, RegistryK a) => MethodInfo RegistryCheckFeatureVersionMethodInfo a signature where+    overloadedMethod _ = registryCheckFeatureVersion++-- method Registry::feature_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "PluginFeatureFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "PluginFeature")+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_feature_filter" gst_registry_feature_filter :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    FunPtr PluginFeatureFilterC ->          -- filter : TInterface "Gst" "PluginFeatureFilter"+    CInt ->                                 -- first : TBasicType TBoolean+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO (Ptr (GList (Ptr PluginFeature)))+++registryFeatureFilter ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> PluginFeatureFilter                  -- filter+    -> Bool                                 -- first+    -> m [PluginFeature]                    -- result+registryFeatureFilter _obj filter first = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filter' <- mkPluginFeatureFilter (pluginFeatureFilterWrapper Nothing filter)+    let first' = (fromIntegral . fromEnum) first+    let userData = nullPtr+    result <- gst_registry_feature_filter _obj' filter' first' userData+    checkUnexpectedReturnNULL "gst_registry_feature_filter" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject PluginFeature) result'+    g_list_free result+    safeFreeFunPtr $ castFunPtrToPtr filter'+    touchManagedPtr _obj+    return result''++data RegistryFeatureFilterMethodInfo+instance (signature ~ (PluginFeatureFilter -> Bool -> m [PluginFeature]), MonadIO m, RegistryK a) => MethodInfo RegistryFeatureFilterMethodInfo a signature where+    overloadedMethod _ = registryFeatureFilter++-- method Registry::find_feature+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PluginFeature"+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_find_feature" gst_registry_find_feature :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CString ->                              -- name : TBasicType TUTF8+    CGType ->                               -- type : TBasicType TGType+    IO (Ptr PluginFeature)+++registryFindFeature ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> GType                                -- type_+    -> m PluginFeature                      -- result+registryFindFeature _obj name type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    let type_' = gtypeToCGType type_+    result <- gst_registry_find_feature _obj' name' type_'+    checkUnexpectedReturnNULL "gst_registry_find_feature" result+    result' <- (wrapObject PluginFeature) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data RegistryFindFeatureMethodInfo+instance (signature ~ (T.Text -> GType -> m PluginFeature), MonadIO m, RegistryK a) => MethodInfo RegistryFindFeatureMethodInfo a signature where+    overloadedMethod _ = registryFindFeature++-- method Registry::find_plugin+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Plugin"+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_find_plugin" gst_registry_find_plugin :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Plugin)+++registryFindPlugin ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m Plugin                             -- result+registryFindPlugin _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_registry_find_plugin _obj' name'+    checkUnexpectedReturnNULL "gst_registry_find_plugin" result+    result' <- (wrapObject Plugin) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data RegistryFindPluginMethodInfo+instance (signature ~ (T.Text -> m Plugin), MonadIO m, RegistryK a) => MethodInfo RegistryFindPluginMethodInfo a signature where+    overloadedMethod _ = registryFindPlugin++-- method Registry::get_feature_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "PluginFeature")+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_get_feature_list" gst_registry_get_feature_list :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CGType ->                               -- type : TBasicType TGType+    IO (Ptr (GList (Ptr PluginFeature)))+++registryGetFeatureList ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> GType                                -- type_+    -> m [PluginFeature]                    -- result+registryGetFeatureList _obj type_ = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let type_' = gtypeToCGType type_+    result <- gst_registry_get_feature_list _obj' type_'+    checkUnexpectedReturnNULL "gst_registry_get_feature_list" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject PluginFeature) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++data RegistryGetFeatureListMethodInfo+instance (signature ~ (GType -> m [PluginFeature]), MonadIO m, RegistryK a) => MethodInfo RegistryGetFeatureListMethodInfo a signature where+    overloadedMethod _ = registryGetFeatureList++-- method Registry::get_feature_list_by_plugin+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "PluginFeature")+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_get_feature_list_by_plugin" gst_registry_get_feature_list_by_plugin :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr (GList (Ptr PluginFeature)))+++registryGetFeatureListByPlugin ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m [PluginFeature]                    -- result+registryGetFeatureListByPlugin _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_registry_get_feature_list_by_plugin _obj' name'+    checkUnexpectedReturnNULL "gst_registry_get_feature_list_by_plugin" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject PluginFeature) result'+    g_list_free result+    touchManagedPtr _obj+    freeMem name'+    return result''++data RegistryGetFeatureListByPluginMethodInfo+instance (signature ~ (T.Text -> m [PluginFeature]), MonadIO m, RegistryK a) => MethodInfo RegistryGetFeatureListByPluginMethodInfo a signature where+    overloadedMethod _ = registryGetFeatureListByPlugin++-- method Registry::get_feature_list_cookie+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_get_feature_list_cookie" gst_registry_get_feature_list_cookie :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    IO Word32+++registryGetFeatureListCookie ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> m Word32                             -- result+registryGetFeatureListCookie _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_registry_get_feature_list_cookie _obj'+    touchManagedPtr _obj+    return result++data RegistryGetFeatureListCookieMethodInfo+instance (signature ~ (m Word32), MonadIO m, RegistryK a) => MethodInfo RegistryGetFeatureListCookieMethodInfo a signature where+    overloadedMethod _ = registryGetFeatureListCookie++-- method Registry::get_plugin_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "Plugin")+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_get_plugin_list" gst_registry_get_plugin_list :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    IO (Ptr (GList (Ptr Plugin)))+++registryGetPluginList ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> m [Plugin]                           -- result+registryGetPluginList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_registry_get_plugin_list _obj'+    checkUnexpectedReturnNULL "gst_registry_get_plugin_list" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Plugin) result'+    g_list_free result+    touchManagedPtr _obj+    return result''++data RegistryGetPluginListMethodInfo+instance (signature ~ (m [Plugin]), MonadIO m, RegistryK a) => MethodInfo RegistryGetPluginListMethodInfo a signature where+    overloadedMethod _ = registryGetPluginList++-- method Registry::lookup+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Plugin"+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_lookup" gst_registry_lookup :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CString ->                              -- filename : TBasicType TUTF8+    IO (Ptr Plugin)+++registryLookup ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> T.Text                               -- filename+    -> m Plugin                             -- result+registryLookup _obj filename = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filename' <- textToCString filename+    result <- gst_registry_lookup _obj' filename'+    checkUnexpectedReturnNULL "gst_registry_lookup" result+    result' <- (wrapObject Plugin) result+    touchManagedPtr _obj+    freeMem filename'+    return result'++data RegistryLookupMethodInfo+instance (signature ~ (T.Text -> m Plugin), MonadIO m, RegistryK a) => MethodInfo RegistryLookupMethodInfo a signature where+    overloadedMethod _ = registryLookup++-- method Registry::lookup_feature+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PluginFeature"+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_lookup_feature" gst_registry_lookup_feature :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr PluginFeature)+++registryLookupFeature ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> T.Text                               -- name+    -> m PluginFeature                      -- result+registryLookupFeature _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    name' <- textToCString name+    result <- gst_registry_lookup_feature _obj' name'+    checkUnexpectedReturnNULL "gst_registry_lookup_feature" result+    result' <- (wrapObject PluginFeature) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data RegistryLookupFeatureMethodInfo+instance (signature ~ (T.Text -> m PluginFeature), MonadIO m, RegistryK a) => MethodInfo RegistryLookupFeatureMethodInfo a signature where+    overloadedMethod _ = registryLookupFeature++-- method Registry::plugin_filter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "PluginFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "Plugin")+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_plugin_filter" gst_registry_plugin_filter :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    FunPtr PluginFilterC ->                 -- filter : TInterface "Gst" "PluginFilter"+    CInt ->                                 -- first : TBasicType TBoolean+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO (Ptr (GList (Ptr Plugin)))+++registryPluginFilter ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> PluginFilter                         -- filter+    -> Bool                                 -- first+    -> m [Plugin]                           -- result+registryPluginFilter _obj filter first = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    filter' <- mkPluginFilter (pluginFilterWrapper Nothing filter)+    let first' = (fromIntegral . fromEnum) first+    let userData = nullPtr+    result <- gst_registry_plugin_filter _obj' filter' first' userData+    checkUnexpectedReturnNULL "gst_registry_plugin_filter" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject Plugin) result'+    g_list_free result+    safeFreeFunPtr $ castFunPtrToPtr filter'+    touchManagedPtr _obj+    return result''++data RegistryPluginFilterMethodInfo+instance (signature ~ (PluginFilter -> Bool -> m [Plugin]), MonadIO m, RegistryK a) => MethodInfo RegistryPluginFilterMethodInfo a signature where+    overloadedMethod _ = registryPluginFilter++-- method Registry::remove_feature+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_remove_feature" gst_registry_remove_feature :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    Ptr PluginFeature ->                    -- feature : TInterface "Gst" "PluginFeature"+    IO ()+++registryRemoveFeature ::+    (MonadIO m, RegistryK a, PluginFeatureK b) =>+    a                                       -- _obj+    -> b                                    -- feature+    -> m ()                                 -- result+registryRemoveFeature _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let feature' = unsafeManagedPtrCastPtr feature+    gst_registry_remove_feature _obj' feature'+    touchManagedPtr _obj+    touchManagedPtr feature+    return ()++data RegistryRemoveFeatureMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, RegistryK a, PluginFeatureK b) => MethodInfo RegistryRemoveFeatureMethodInfo a signature where+    overloadedMethod _ = registryRemoveFeature++-- method Registry::remove_plugin+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_remove_plugin" gst_registry_remove_plugin :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"+    IO ()+++registryRemovePlugin ::+    (MonadIO m, RegistryK a, PluginK b) =>+    a                                       -- _obj+    -> b                                    -- plugin+    -> m ()                                 -- result+registryRemovePlugin _obj plugin = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let plugin' = unsafeManagedPtrCastPtr plugin+    gst_registry_remove_plugin _obj' plugin'+    touchManagedPtr _obj+    touchManagedPtr plugin+    return ()++data RegistryRemovePluginMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, RegistryK a, PluginK b) => MethodInfo RegistryRemovePluginMethodInfo a signature where+    overloadedMethod _ = registryRemovePlugin++-- method Registry::scan_path+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_scan_path" gst_registry_scan_path :: +    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"+    CString ->                              -- path : TBasicType TUTF8+    IO CInt+++registryScanPath ::+    (MonadIO m, RegistryK a) =>+    a                                       -- _obj+    -> T.Text                               -- path+    -> m Bool                               -- result+registryScanPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    path' <- textToCString path+    result <- gst_registry_scan_path _obj' path'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem path'+    return result'++data RegistryScanPathMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m, RegistryK a) => MethodInfo RegistryScanPathMethodInfo a signature where+    overloadedMethod _ = registryScanPath++-- method Registry::fork_is_enabled+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_fork_is_enabled" gst_registry_fork_is_enabled :: +    IO CInt+++registryForkIsEnabled ::+    (MonadIO m) =>+    m Bool                                  -- result+registryForkIsEnabled  = liftIO $ do+    result <- gst_registry_fork_is_enabled+    let result' = (/= 0) result+    return result'++-- method Registry::fork_set_enabled+-- method type : MemberFunction+-- Args : [Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_fork_set_enabled" gst_registry_fork_set_enabled :: +    CInt ->                                 -- enabled : TBasicType TBoolean+    IO ()+++registryForkSetEnabled ::+    (MonadIO m) =>+    Bool                                    -- enabled+    -> m ()                                 -- result+registryForkSetEnabled enabled = liftIO $ do+    let enabled' = (fromIntegral . fromEnum) enabled+    gst_registry_fork_set_enabled enabled'+    return ()++-- method Registry::get+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Registry"+-- throws : False+-- Skip return : False++foreign import ccall "gst_registry_get" gst_registry_get :: +    IO (Ptr Registry)+++registryGet ::+    (MonadIO m) =>+    m Registry                              -- result+registryGet  = liftIO $ do+    result <- gst_registry_get+    checkUnexpectedReturnNULL "gst_registry_get" result+    result' <- (newObject Registry) result+    return result'++
+ GI/Gst/Objects/Registry.hs-boot view
@@ -0,0 +1,31 @@+module GI.Gst.Objects.Registry 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++newtype Registry = Registry (ForeignPtr Registry)+instance GObject Registry where+class GObject o => RegistryK o+instance (GObject o, IsDescendantOf Registry o) => RegistryK o+data RegistryFeatureAddedSignalInfo+data RegistryPluginAddedSignalInfo+data RegistryAddFeatureMethodInfo+data RegistryAddPluginMethodInfo+data RegistryCheckFeatureVersionMethodInfo+data RegistryFeatureFilterMethodInfo+data RegistryFindFeatureMethodInfo+data RegistryFindPluginMethodInfo+data RegistryGetFeatureListMethodInfo+data RegistryGetFeatureListByPluginMethodInfo+data RegistryGetFeatureListCookieMethodInfo+data RegistryGetPluginListMethodInfo+data RegistryLookupMethodInfo+data RegistryLookupFeatureMethodInfo+data RegistryPluginFilterMethodInfo+data RegistryRemoveFeatureMethodInfo+data RegistryRemovePluginMethodInfo+data RegistryScanPathMethodInfo
+ GI/Gst/Objects/SystemClock.hs view
@@ -0,0 +1,224 @@+++{- |+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.Objects.SystemClock+    ( ++-- * Exported types+    SystemClock(..)                         ,+    SystemClockK                            ,+    toSystemClock                           ,+    noSystemClock                           ,+++ -- * Methods+-- ** systemClockObtain+    systemClockObtain                       ,+++-- ** systemClockSetDefault+    systemClockSetDefault                   ,+++++ -- * Properties+-- ** ClockType+    SystemClockClockTypePropertyInfo        ,+    constructSystemClockClockType           ,+    getSystemClockClockType                 ,+    setSystemClockClockType                 ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype SystemClock = SystemClock (ForeignPtr SystemClock)+foreign import ccall "gst_system_clock_get_type"+    c_gst_system_clock_get_type :: IO GType++type instance ParentTypes SystemClock = SystemClockParentTypes+type SystemClockParentTypes = '[Clock, Object, GObject.Object]++instance GObject SystemClock where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_system_clock_get_type+    ++class GObject o => SystemClockK o+instance (GObject o, IsDescendantOf SystemClock o) => SystemClockK o++toSystemClock :: SystemClockK o => o -> IO SystemClock+toSystemClock = unsafeCastTo SystemClock++noSystemClock :: Maybe SystemClock+noSystemClock = Nothing++type family ResolveSystemClockMethod (t :: Symbol) (o :: *) :: * where+    ResolveSystemClockMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveSystemClockMethod "addObservation" o = ClockAddObservationMethodInfo+    ResolveSystemClockMethod "addObservationUnapplied" o = ClockAddObservationUnappliedMethodInfo+    ResolveSystemClockMethod "adjustUnlocked" o = ClockAdjustUnlockedMethodInfo+    ResolveSystemClockMethod "adjustWithCalibration" o = ClockAdjustWithCalibrationMethodInfo+    ResolveSystemClockMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveSystemClockMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveSystemClockMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveSystemClockMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveSystemClockMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveSystemClockMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveSystemClockMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveSystemClockMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveSystemClockMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveSystemClockMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveSystemClockMethod "isSynced" o = ClockIsSyncedMethodInfo+    ResolveSystemClockMethod "newPeriodicId" o = ClockNewPeriodicIdMethodInfo+    ResolveSystemClockMethod "newSingleShotId" o = ClockNewSingleShotIdMethodInfo+    ResolveSystemClockMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveSystemClockMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveSystemClockMethod "periodicIdReinit" o = ClockPeriodicIdReinitMethodInfo+    ResolveSystemClockMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveSystemClockMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveSystemClockMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveSystemClockMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveSystemClockMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveSystemClockMethod "singleShotIdReinit" o = ClockSingleShotIdReinitMethodInfo+    ResolveSystemClockMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveSystemClockMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveSystemClockMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveSystemClockMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveSystemClockMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveSystemClockMethod "unadjustUnlocked" o = ClockUnadjustUnlockedMethodInfo+    ResolveSystemClockMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveSystemClockMethod "waitForSync" o = ClockWaitForSyncMethodInfo+    ResolveSystemClockMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveSystemClockMethod "getCalibration" o = ClockGetCalibrationMethodInfo+    ResolveSystemClockMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveSystemClockMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveSystemClockMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveSystemClockMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveSystemClockMethod "getInternalTime" o = ClockGetInternalTimeMethodInfo+    ResolveSystemClockMethod "getMaster" o = ClockGetMasterMethodInfo+    ResolveSystemClockMethod "getName" o = ObjectGetNameMethodInfo+    ResolveSystemClockMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveSystemClockMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveSystemClockMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveSystemClockMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveSystemClockMethod "getResolution" o = ClockGetResolutionMethodInfo+    ResolveSystemClockMethod "getTime" o = ClockGetTimeMethodInfo+    ResolveSystemClockMethod "getTimeout" o = ClockGetTimeoutMethodInfo+    ResolveSystemClockMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveSystemClockMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveSystemClockMethod "setCalibration" o = ClockSetCalibrationMethodInfo+    ResolveSystemClockMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveSystemClockMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveSystemClockMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveSystemClockMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveSystemClockMethod "setMaster" o = ClockSetMasterMethodInfo+    ResolveSystemClockMethod "setName" o = ObjectSetNameMethodInfo+    ResolveSystemClockMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveSystemClockMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveSystemClockMethod "setResolution" o = ClockSetResolutionMethodInfo+    ResolveSystemClockMethod "setSynced" o = ClockSetSyncedMethodInfo+    ResolveSystemClockMethod "setTimeout" o = ClockSetTimeoutMethodInfo+    ResolveSystemClockMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveSystemClockMethod t SystemClock, MethodInfo info SystemClock p) => IsLabelProxy t (SystemClock -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveSystemClockMethod t SystemClock, MethodInfo info SystemClock p) => IsLabel t (SystemClock -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++-- VVV Prop "clock-type"+   -- Type: TInterface "Gst" "ClockType"+   -- Flags: [PropertyReadable,PropertyWritable]++getSystemClockClockType :: (MonadIO m, SystemClockK o) => o -> m ClockType+getSystemClockClockType obj = liftIO $ getObjectPropertyEnum obj "clock-type"++setSystemClockClockType :: (MonadIO m, SystemClockK o) => o -> ClockType -> m ()+setSystemClockClockType obj val = liftIO $ setObjectPropertyEnum obj "clock-type" val++constructSystemClockClockType :: ClockType -> IO ([Char], GValue)+constructSystemClockClockType val = constructObjectPropertyEnum "clock-type" val++data SystemClockClockTypePropertyInfo+instance AttrInfo SystemClockClockTypePropertyInfo where+    type AttrAllowedOps SystemClockClockTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]+    type AttrSetTypeConstraint SystemClockClockTypePropertyInfo = (~) ClockType+    type AttrBaseTypeConstraint SystemClockClockTypePropertyInfo = SystemClockK+    type AttrGetType SystemClockClockTypePropertyInfo = ClockType+    type AttrLabel SystemClockClockTypePropertyInfo = "clock-type"+    attrGet _ = getSystemClockClockType+    attrSet _ = setSystemClockClockType+    attrConstruct _ = constructSystemClockClockType++type instance AttributeList SystemClock = SystemClockAttributeList+type SystemClockAttributeList = ('[ '("clockType", SystemClockClockTypePropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("timeout", ClockTimeoutPropertyInfo), '("windowSize", ClockWindowSizePropertyInfo), '("windowThreshold", ClockWindowThresholdPropertyInfo)] :: [(Symbol, *)])++type instance SignalList SystemClock = SystemClockSignalList+type SystemClockSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("synced", ClockSyncedSignalInfo)] :: [(Symbol, *)])++-- method SystemClock::obtain+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Clock"+-- throws : False+-- Skip return : False++foreign import ccall "gst_system_clock_obtain" gst_system_clock_obtain :: +    IO (Ptr Clock)+++systemClockObtain ::+    (MonadIO m) =>+    m Clock                                 -- result+systemClockObtain  = liftIO $ do+    result <- gst_system_clock_obtain+    checkUnexpectedReturnNULL "gst_system_clock_obtain" result+    result' <- (wrapObject Clock) result+    return result'++-- method SystemClock::set_default+-- method type : MemberFunction+-- Args : [Arg {argCName = "new_clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_system_clock_set_default" gst_system_clock_set_default :: +    Ptr Clock ->                            -- new_clock : TInterface "Gst" "Clock"+    IO ()+++systemClockSetDefault ::+    (MonadIO m, ClockK a) =>+    a                                       -- newClock+    -> m ()                                 -- result+systemClockSetDefault newClock = liftIO $ do+    let newClock' = unsafeManagedPtrCastPtr newClock+    gst_system_clock_set_default newClock'+    touchManagedPtr newClock+    return ()++
+ GI/Gst/Objects/SystemClock.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gst.Objects.SystemClock 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++newtype SystemClock = SystemClock (ForeignPtr SystemClock)+instance GObject SystemClock where+class GObject o => SystemClockK o+instance (GObject o, IsDescendantOf SystemClock o) => SystemClockK o+data SystemClockClockTypePropertyInfo
+ GI/Gst/Objects/Task.hs view
@@ -0,0 +1,568 @@+++{- |+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.Objects.Task+    ( ++-- * Exported types+    Task(..)                                ,+    TaskK                                   ,+    toTask                                  ,+    noTask                                  ,+++ -- * Methods+-- ** taskCleanupAll+    taskCleanupAll                          ,+++-- ** taskGetPool+    TaskGetPoolMethodInfo                   ,+    taskGetPool                             ,+++-- ** taskGetState+    TaskGetStateMethodInfo                  ,+    taskGetState                            ,+++-- ** taskJoin+    TaskJoinMethodInfo                      ,+    taskJoin                                ,+++-- ** taskNew+    taskNew                                 ,+++-- ** taskPause+    TaskPauseMethodInfo                     ,+    taskPause                               ,+++-- ** taskSetEnterCallback+    TaskSetEnterCallbackMethodInfo          ,+    taskSetEnterCallback                    ,+++-- ** taskSetLeaveCallback+    TaskSetLeaveCallbackMethodInfo          ,+    taskSetLeaveCallback                    ,+++-- ** taskSetLock+    TaskSetLockMethodInfo                   ,+    taskSetLock                             ,+++-- ** taskSetPool+    TaskSetPoolMethodInfo                   ,+    taskSetPool                             ,+++-- ** taskSetState+    TaskSetStateMethodInfo                  ,+    taskSetState                            ,+++-- ** taskStart+    TaskStartMethodInfo                     ,+    taskStart                               ,+++-- ** taskStop+    TaskStopMethodInfo                      ,+    taskStop                                ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib+import qualified GI.GObject as GObject++newtype Task = Task (ForeignPtr Task)+foreign import ccall "gst_task_get_type"+    c_gst_task_get_type :: IO GType++type instance ParentTypes Task = TaskParentTypes+type TaskParentTypes = '[Object, GObject.Object]++instance GObject Task where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_task_get_type+    ++class GObject o => TaskK o+instance (GObject o, IsDescendantOf Task o) => TaskK o++toTask :: TaskK o => o -> IO Task+toTask = unsafeCastTo Task++noTask :: Maybe Task+noTask = Nothing++type family ResolveTaskMethod (t :: Symbol) (o :: *) :: * where+    ResolveTaskMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveTaskMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveTaskMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveTaskMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveTaskMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveTaskMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveTaskMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveTaskMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveTaskMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveTaskMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveTaskMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveTaskMethod "join" o = TaskJoinMethodInfo+    ResolveTaskMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveTaskMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveTaskMethod "pause" o = TaskPauseMethodInfo+    ResolveTaskMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveTaskMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveTaskMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveTaskMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveTaskMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveTaskMethod "start" o = TaskStartMethodInfo+    ResolveTaskMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveTaskMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveTaskMethod "stop" o = TaskStopMethodInfo+    ResolveTaskMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveTaskMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveTaskMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveTaskMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveTaskMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveTaskMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveTaskMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveTaskMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveTaskMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveTaskMethod "getName" o = ObjectGetNameMethodInfo+    ResolveTaskMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveTaskMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveTaskMethod "getPool" o = TaskGetPoolMethodInfo+    ResolveTaskMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveTaskMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveTaskMethod "getState" o = TaskGetStateMethodInfo+    ResolveTaskMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveTaskMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveTaskMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveTaskMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveTaskMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveTaskMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveTaskMethod "setEnterCallback" o = TaskSetEnterCallbackMethodInfo+    ResolveTaskMethod "setLeaveCallback" o = TaskSetLeaveCallbackMethodInfo+    ResolveTaskMethod "setLock" o = TaskSetLockMethodInfo+    ResolveTaskMethod "setName" o = ObjectSetNameMethodInfo+    ResolveTaskMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveTaskMethod "setPool" o = TaskSetPoolMethodInfo+    ResolveTaskMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveTaskMethod "setState" o = TaskSetStateMethodInfo+    ResolveTaskMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTaskMethod t Task, MethodInfo info Task p) => IsLabelProxy t (Task -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTaskMethod t Task, MethodInfo info Task p) => IsLabel t (Task -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList Task = TaskAttributeList+type TaskAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList Task = TaskSignalList+type TaskSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method Task::new+-- method type : Constructor+-- Args : [Arg {argCName = "func", argType = TInterface "Gst" "TaskFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 1, argDestroy = 2, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Task"+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_new" gst_task_new :: +    FunPtr TaskFunctionC ->                 -- func : TInterface "Gst" "TaskFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO (Ptr Task)+++taskNew ::+    (MonadIO m) =>+    TaskFunction                            -- func+    -> m Task                               -- result+taskNew func = liftIO $ do+    func' <- mkTaskFunction (taskFunctionWrapper Nothing func)+    let userData = castFunPtrToPtr func'+    let notify = safeFreeFunPtrPtr+    result <- gst_task_new func' userData notify+    checkUnexpectedReturnNULL "gst_task_new" result+    result' <- (wrapObject Task) result+    return result'++-- method Task::get_pool+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TaskPool"+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_get_pool" gst_task_get_pool :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    IO (Ptr TaskPool)+++taskGetPool ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> m TaskPool                           -- result+taskGetPool _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_task_get_pool _obj'+    checkUnexpectedReturnNULL "gst_task_get_pool" result+    result' <- (wrapObject TaskPool) result+    touchManagedPtr _obj+    return result'++data TaskGetPoolMethodInfo+instance (signature ~ (m TaskPool), MonadIO m, TaskK a) => MethodInfo TaskGetPoolMethodInfo a signature where+    overloadedMethod _ = taskGetPool++-- method Task::get_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TaskState"+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_get_state" gst_task_get_state :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    IO CUInt+++taskGetState ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> m TaskState                          -- result+taskGetState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_task_get_state _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data TaskGetStateMethodInfo+instance (signature ~ (m TaskState), MonadIO m, TaskK a) => MethodInfo TaskGetStateMethodInfo a signature where+    overloadedMethod _ = taskGetState++-- method Task::join+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_join" gst_task_join :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    IO CInt+++taskJoin ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+taskJoin _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_task_join _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TaskJoinMethodInfo+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskJoinMethodInfo a signature where+    overloadedMethod _ = taskJoin++-- method Task::pause+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_pause" gst_task_pause :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    IO CInt+++taskPause ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+taskPause _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_task_pause _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TaskPauseMethodInfo+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskPauseMethodInfo a signature where+    overloadedMethod _ = taskPause++-- method Task::set_enter_callback+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enter_func", argType = TInterface "Gst" "TaskThreadFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_set_enter_callback" gst_task_set_enter_callback :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    FunPtr TaskThreadFuncC ->               -- enter_func : TInterface "Gst" "TaskThreadFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++taskSetEnterCallback ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> TaskThreadFunc                       -- enterFunc+    -> m ()                                 -- result+taskSetEnterCallback _obj enterFunc = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    enterFunc' <- mkTaskThreadFunc (taskThreadFuncWrapper Nothing enterFunc)+    let userData = castFunPtrToPtr enterFunc'+    let notify = safeFreeFunPtrPtr+    gst_task_set_enter_callback _obj' enterFunc' userData notify+    touchManagedPtr _obj+    return ()++data TaskSetEnterCallbackMethodInfo+instance (signature ~ (TaskThreadFunc -> m ()), MonadIO m, TaskK a) => MethodInfo TaskSetEnterCallbackMethodInfo a signature where+    overloadedMethod _ = taskSetEnterCallback++-- method Task::set_leave_callback+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "leave_func", argType = TInterface "Gst" "TaskThreadFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_set_leave_callback" gst_task_set_leave_callback :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    FunPtr TaskThreadFuncC ->               -- leave_func : TInterface "Gst" "TaskThreadFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO ()+++taskSetLeaveCallback ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> TaskThreadFunc                       -- leaveFunc+    -> m ()                                 -- result+taskSetLeaveCallback _obj leaveFunc = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    leaveFunc' <- mkTaskThreadFunc (taskThreadFuncWrapper Nothing leaveFunc)+    let userData = castFunPtrToPtr leaveFunc'+    let notify = safeFreeFunPtrPtr+    gst_task_set_leave_callback _obj' leaveFunc' userData notify+    touchManagedPtr _obj+    return ()++data TaskSetLeaveCallbackMethodInfo+instance (signature ~ (TaskThreadFunc -> m ()), MonadIO m, TaskK a) => MethodInfo TaskSetLeaveCallbackMethodInfo a signature where+    overloadedMethod _ = taskSetLeaveCallback++-- method Task::set_lock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mutex", argType = TInterface "GLib" "RecMutex", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_set_lock" gst_task_set_lock :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    Ptr GLib.RecMutex ->                    -- mutex : TInterface "GLib" "RecMutex"+    IO ()+++taskSetLock ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> GLib.RecMutex                        -- mutex+    -> m ()                                 -- result+taskSetLock _obj mutex = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let mutex' = unsafeManagedPtrGetPtr mutex+    gst_task_set_lock _obj' mutex'+    touchManagedPtr _obj+    touchManagedPtr mutex+    return ()++data TaskSetLockMethodInfo+instance (signature ~ (GLib.RecMutex -> m ()), MonadIO m, TaskK a) => MethodInfo TaskSetLockMethodInfo a signature where+    overloadedMethod _ = taskSetLock++-- method Task::set_pool+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_set_pool" gst_task_set_pool :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    Ptr TaskPool ->                         -- pool : TInterface "Gst" "TaskPool"+    IO ()+++taskSetPool ::+    (MonadIO m, TaskK a, TaskPoolK b) =>+    a                                       -- _obj+    -> b                                    -- pool+    -> m ()                                 -- result+taskSetPool _obj pool = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let pool' = unsafeManagedPtrCastPtr pool+    gst_task_set_pool _obj' pool'+    touchManagedPtr _obj+    touchManagedPtr pool+    return ()++data TaskSetPoolMethodInfo+instance (signature ~ (b -> m ()), MonadIO m, TaskK a, TaskPoolK b) => MethodInfo TaskSetPoolMethodInfo a signature where+    overloadedMethod _ = taskSetPool++-- method Task::set_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "TaskState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_set_state" gst_task_set_state :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    CUInt ->                                -- state : TInterface "Gst" "TaskState"+    IO CInt+++taskSetState ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> TaskState                            -- state+    -> m Bool                               -- result+taskSetState _obj state = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let state' = (fromIntegral . fromEnum) state+    result <- gst_task_set_state _obj' state'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TaskSetStateMethodInfo+instance (signature ~ (TaskState -> m Bool), MonadIO m, TaskK a) => MethodInfo TaskSetStateMethodInfo a signature where+    overloadedMethod _ = taskSetState++-- method Task::start+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_start" gst_task_start :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    IO CInt+++taskStart ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+taskStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_task_start _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TaskStartMethodInfo+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskStartMethodInfo a signature where+    overloadedMethod _ = taskStart++-- method Task::stop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_stop" gst_task_stop :: +    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"+    IO CInt+++taskStop ::+    (MonadIO m, TaskK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+taskStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_task_stop _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TaskStopMethodInfo+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskStopMethodInfo a signature where+    overloadedMethod _ = taskStop++-- method Task::cleanup_all+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_cleanup_all" gst_task_cleanup_all :: +    IO ()+++taskCleanupAll ::+    (MonadIO m) =>+    m ()                                    -- result+taskCleanupAll  = liftIO $ do+    gst_task_cleanup_all+    return ()++
+ GI/Gst/Objects/Task.hs-boot view
@@ -0,0 +1,24 @@+module GI.Gst.Objects.Task 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++newtype Task = Task (ForeignPtr Task)+instance GObject Task where+class GObject o => TaskK o+instance (GObject o, IsDescendantOf Task o) => TaskK o+data TaskGetPoolMethodInfo+data TaskGetStateMethodInfo+data TaskJoinMethodInfo+data TaskPauseMethodInfo+data TaskSetEnterCallbackMethodInfo+data TaskSetLeaveCallbackMethodInfo+data TaskSetLockMethodInfo+data TaskSetPoolMethodInfo+data TaskSetStateMethodInfo+data TaskStartMethodInfo+data TaskStopMethodInfo
+ GI/Gst/Objects/TaskPool.hs view
@@ -0,0 +1,292 @@+++{- |+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.Objects.TaskPool+    ( ++-- * Exported types+    TaskPool(..)                            ,+    TaskPoolK                               ,+    toTaskPool                              ,+    noTaskPool                              ,+++ -- * Methods+-- ** taskPoolCleanup+    TaskPoolCleanupMethodInfo               ,+    taskPoolCleanup                         ,+++-- ** taskPoolJoin+    TaskPoolJoinMethodInfo                  ,+    taskPoolJoin                            ,+++-- ** taskPoolNew+    taskPoolNew                             ,+++-- ** taskPoolPrepare+    TaskPoolPrepareMethodInfo               ,+    taskPoolPrepare                         ,+++-- ** taskPoolPush+    TaskPoolPushMethodInfo                  ,+    taskPoolPush                            ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype TaskPool = TaskPool (ForeignPtr TaskPool)+foreign import ccall "gst_task_pool_get_type"+    c_gst_task_pool_get_type :: IO GType++type instance ParentTypes TaskPool = TaskPoolParentTypes+type TaskPoolParentTypes = '[Object, GObject.Object]++instance GObject TaskPool where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_task_pool_get_type+    ++class GObject o => TaskPoolK o+instance (GObject o, IsDescendantOf TaskPool o) => TaskPoolK o++toTaskPool :: TaskPoolK o => o -> IO TaskPool+toTaskPool = unsafeCastTo TaskPool++noTaskPool :: Maybe TaskPool+noTaskPool = Nothing++type family ResolveTaskPoolMethod (t :: Symbol) (o :: *) :: * where+    ResolveTaskPoolMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveTaskPoolMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveTaskPoolMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveTaskPoolMethod "cleanup" o = TaskPoolCleanupMethodInfo+    ResolveTaskPoolMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveTaskPoolMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveTaskPoolMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveTaskPoolMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveTaskPoolMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveTaskPoolMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveTaskPoolMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveTaskPoolMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveTaskPoolMethod "join" o = TaskPoolJoinMethodInfo+    ResolveTaskPoolMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveTaskPoolMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveTaskPoolMethod "prepare" o = TaskPoolPrepareMethodInfo+    ResolveTaskPoolMethod "push" o = TaskPoolPushMethodInfo+    ResolveTaskPoolMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveTaskPoolMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveTaskPoolMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveTaskPoolMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveTaskPoolMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveTaskPoolMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveTaskPoolMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveTaskPoolMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveTaskPoolMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveTaskPoolMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveTaskPoolMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveTaskPoolMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveTaskPoolMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveTaskPoolMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveTaskPoolMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveTaskPoolMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveTaskPoolMethod "getName" o = ObjectGetNameMethodInfo+    ResolveTaskPoolMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveTaskPoolMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveTaskPoolMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveTaskPoolMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveTaskPoolMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveTaskPoolMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveTaskPoolMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveTaskPoolMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveTaskPoolMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveTaskPoolMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveTaskPoolMethod "setName" o = ObjectSetNameMethodInfo+    ResolveTaskPoolMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveTaskPoolMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveTaskPoolMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTaskPoolMethod t TaskPool, MethodInfo info TaskPool p) => IsLabelProxy t (TaskPool -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTaskPoolMethod t TaskPool, MethodInfo info TaskPool p) => IsLabel t (TaskPool -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList TaskPool = TaskPoolAttributeList+type TaskPoolAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TaskPool = TaskPoolSignalList+type TaskPoolSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TaskPool::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "TaskPool"+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_pool_new" gst_task_pool_new :: +    IO (Ptr TaskPool)+++taskPoolNew ::+    (MonadIO m) =>+    m TaskPool                              -- result+taskPoolNew  = liftIO $ do+    result <- gst_task_pool_new+    checkUnexpectedReturnNULL "gst_task_pool_new" result+    result' <- (wrapObject TaskPool) result+    return result'++-- method TaskPool::cleanup+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_pool_cleanup" gst_task_pool_cleanup :: +    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"+    IO ()+++taskPoolCleanup ::+    (MonadIO m, TaskPoolK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+taskPoolCleanup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_task_pool_cleanup _obj'+    touchManagedPtr _obj+    return ()++data TaskPoolCleanupMethodInfo+instance (signature ~ (m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolCleanupMethodInfo a signature where+    overloadedMethod _ = taskPoolCleanup++-- method TaskPool::join+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_task_pool_join" gst_task_pool_join :: +    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"+    Ptr () ->                               -- id : TBasicType TVoid+    IO ()+++taskPoolJoin ::+    (MonadIO m, TaskPoolK a) =>+    a                                       -- _obj+    -> Ptr ()                               -- id+    -> m ()                                 -- result+taskPoolJoin _obj id = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    gst_task_pool_join _obj' id+    touchManagedPtr _obj+    return ()++data TaskPoolJoinMethodInfo+instance (signature ~ (Ptr () -> m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolJoinMethodInfo a signature where+    overloadedMethod _ = taskPoolJoin++-- method TaskPool::prepare+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : True+-- Skip return : False++foreign import ccall "gst_task_pool_prepare" gst_task_pool_prepare :: +    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"+    Ptr (Ptr GError) ->                     -- error+    IO ()+++taskPoolPrepare ::+    (MonadIO m, TaskPoolK a) =>+    a                                       -- _obj+    -> m ()                                 -- result+taskPoolPrepare _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    onException (do+        propagateGError $ gst_task_pool_prepare _obj'+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++data TaskPoolPrepareMethodInfo+instance (signature ~ (m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolPrepareMethodInfo a signature where+    overloadedMethod _ = taskPoolPrepare++-- method TaskPool::push+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TaskPoolFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : True+-- Skip return : False++foreign import ccall "gst_task_pool_push" gst_task_pool_push :: +    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"+    FunPtr TaskPoolFunctionC ->             -- func : TInterface "Gst" "TaskPoolFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    Ptr (Ptr GError) ->                     -- error+    IO ()+++taskPoolPush ::+    (MonadIO m, TaskPoolK a) =>+    a                                       -- _obj+    -> TaskPoolFunction                     -- func+    -> m ()                                 -- result+taskPoolPush _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    ptrfunc <- callocMem :: IO (Ptr (FunPtr TaskPoolFunctionC))+    func' <- mkTaskPoolFunction (taskPoolFunctionWrapper (Just ptrfunc) func)+    poke ptrfunc func'+    let userData = nullPtr+    onException (do+        propagateGError $ gst_task_pool_push _obj' func' userData+        touchManagedPtr _obj+        return ()+     ) (do+        return ()+     )++data TaskPoolPushMethodInfo+instance (signature ~ (TaskPoolFunction -> m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolPushMethodInfo a signature where+    overloadedMethod _ = taskPoolPush++
+ GI/Gst/Objects/TaskPool.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gst.Objects.TaskPool 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++newtype TaskPool = TaskPool (ForeignPtr TaskPool)+instance GObject TaskPool where+class GObject o => TaskPoolK o+instance (GObject o, IsDescendantOf TaskPool o) => TaskPoolK o+data TaskPoolCleanupMethodInfo+data TaskPoolJoinMethodInfo+data TaskPoolPrepareMethodInfo+data TaskPoolPushMethodInfo
+ GI/Gst/Objects/TypeFindFactory.hs view
@@ -0,0 +1,290 @@+++{- |+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.Objects.TypeFindFactory+    ( ++-- * Exported types+    TypeFindFactory(..)                     ,+    TypeFindFactoryK                        ,+    toTypeFindFactory                       ,+    noTypeFindFactory                       ,+++ -- * Methods+-- ** typeFindFactoryCallFunction+    TypeFindFactoryCallFunctionMethodInfo   ,+    typeFindFactoryCallFunction             ,+++-- ** typeFindFactoryGetCaps+    TypeFindFactoryGetCapsMethodInfo        ,+    typeFindFactoryGetCaps                  ,+++-- ** typeFindFactoryGetExtensions+    TypeFindFactoryGetExtensionsMethodInfo  ,+    typeFindFactoryGetExtensions            ,+++-- ** typeFindFactoryGetList+    typeFindFactoryGetList                  ,+++-- ** typeFindFactoryHasFunction+    TypeFindFactoryHasFunctionMethodInfo    ,+    typeFindFactoryHasFunction              ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GObject as GObject++newtype TypeFindFactory = TypeFindFactory (ForeignPtr TypeFindFactory)+foreign import ccall "gst_type_find_factory_get_type"+    c_gst_type_find_factory_get_type :: IO GType++type instance ParentTypes TypeFindFactory = TypeFindFactoryParentTypes+type TypeFindFactoryParentTypes = '[PluginFeature, Object, GObject.Object]++instance GObject TypeFindFactory where+    gobjectIsInitiallyUnowned _ = True+    gobjectType _ = c_gst_type_find_factory_get_type+    ++class GObject o => TypeFindFactoryK o+instance (GObject o, IsDescendantOf TypeFindFactory o) => TypeFindFactoryK o++toTypeFindFactory :: TypeFindFactoryK o => o -> IO TypeFindFactory+toTypeFindFactory = unsafeCastTo TypeFindFactory++noTypeFindFactory :: Maybe TypeFindFactory+noTypeFindFactory = Nothing++type family ResolveTypeFindFactoryMethod (t :: Symbol) (o :: *) :: * where+    ResolveTypeFindFactoryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo+    ResolveTypeFindFactoryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo+    ResolveTypeFindFactoryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo+    ResolveTypeFindFactoryMethod "callFunction" o = TypeFindFactoryCallFunctionMethodInfo+    ResolveTypeFindFactoryMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo+    ResolveTypeFindFactoryMethod "defaultError" o = ObjectDefaultErrorMethodInfo+    ResolveTypeFindFactoryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo+    ResolveTypeFindFactoryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo+    ResolveTypeFindFactoryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo+    ResolveTypeFindFactoryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo+    ResolveTypeFindFactoryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo+    ResolveTypeFindFactoryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo+    ResolveTypeFindFactoryMethod "hasFunction" o = TypeFindFactoryHasFunctionMethodInfo+    ResolveTypeFindFactoryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo+    ResolveTypeFindFactoryMethod "load" o = PluginFeatureLoadMethodInfo+    ResolveTypeFindFactoryMethod "notify" o = GObject.ObjectNotifyMethodInfo+    ResolveTypeFindFactoryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo+    ResolveTypeFindFactoryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo+    ResolveTypeFindFactoryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo+    ResolveTypeFindFactoryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo+    ResolveTypeFindFactoryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo+    ResolveTypeFindFactoryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo+    ResolveTypeFindFactoryMethod "stealData" o = GObject.ObjectStealDataMethodInfo+    ResolveTypeFindFactoryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo+    ResolveTypeFindFactoryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo+    ResolveTypeFindFactoryMethod "syncValues" o = ObjectSyncValuesMethodInfo+    ResolveTypeFindFactoryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo+    ResolveTypeFindFactoryMethod "unparent" o = ObjectUnparentMethodInfo+    ResolveTypeFindFactoryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo+    ResolveTypeFindFactoryMethod "getCaps" o = TypeFindFactoryGetCapsMethodInfo+    ResolveTypeFindFactoryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo+    ResolveTypeFindFactoryMethod "getControlRate" o = ObjectGetControlRateMethodInfo+    ResolveTypeFindFactoryMethod "getData" o = GObject.ObjectGetDataMethodInfo+    ResolveTypeFindFactoryMethod "getExtensions" o = TypeFindFactoryGetExtensionsMethodInfo+    ResolveTypeFindFactoryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo+    ResolveTypeFindFactoryMethod "getName" o = ObjectGetNameMethodInfo+    ResolveTypeFindFactoryMethod "getParent" o = ObjectGetParentMethodInfo+    ResolveTypeFindFactoryMethod "getPathString" o = ObjectGetPathStringMethodInfo+    ResolveTypeFindFactoryMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo+    ResolveTypeFindFactoryMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo+    ResolveTypeFindFactoryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo+    ResolveTypeFindFactoryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo+    ResolveTypeFindFactoryMethod "getRank" o = PluginFeatureGetRankMethodInfo+    ResolveTypeFindFactoryMethod "getValue" o = ObjectGetValueMethodInfo+    ResolveTypeFindFactoryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo+    ResolveTypeFindFactoryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo+    ResolveTypeFindFactoryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo+    ResolveTypeFindFactoryMethod "setControlRate" o = ObjectSetControlRateMethodInfo+    ResolveTypeFindFactoryMethod "setData" o = GObject.ObjectSetDataMethodInfo+    ResolveTypeFindFactoryMethod "setName" o = ObjectSetNameMethodInfo+    ResolveTypeFindFactoryMethod "setParent" o = ObjectSetParentMethodInfo+    ResolveTypeFindFactoryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo+    ResolveTypeFindFactoryMethod "setRank" o = PluginFeatureSetRankMethodInfo+    ResolveTypeFindFactoryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTypeFindFactoryMethod t TypeFindFactory, MethodInfo info TypeFindFactory p) => IsLabelProxy t (TypeFindFactory -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTypeFindFactoryMethod t TypeFindFactory, MethodInfo info TypeFindFactory p) => IsLabel t (TypeFindFactory -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++type instance AttributeList TypeFindFactory = TypeFindFactoryAttributeList+type TypeFindFactoryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])++type instance SignalList TypeFindFactory = TypeFindFactorySignalList+type TypeFindFactorySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])++-- method TypeFindFactory::call_function+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "find", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_factory_call_function" gst_type_find_factory_call_function :: +    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"+    Ptr TypeFind ->                         -- find : TInterface "Gst" "TypeFind"+    IO ()+++typeFindFactoryCallFunction ::+    (MonadIO m, TypeFindFactoryK a) =>+    a                                       -- _obj+    -> TypeFind                             -- find+    -> m ()                                 -- result+typeFindFactoryCallFunction _obj find = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    let find' = unsafeManagedPtrGetPtr find+    gst_type_find_factory_call_function _obj' find'+    touchManagedPtr _obj+    touchManagedPtr find+    return ()++data TypeFindFactoryCallFunctionMethodInfo+instance (signature ~ (TypeFind -> m ()), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryCallFunctionMethodInfo a signature where+    overloadedMethod _ = typeFindFactoryCallFunction++-- method TypeFindFactory::get_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_factory_get_caps" gst_type_find_factory_get_caps :: +    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"+    IO (Ptr Caps)+++typeFindFactoryGetCaps ::+    (MonadIO m, TypeFindFactoryK a) =>+    a                                       -- _obj+    -> m Caps                               -- result+typeFindFactoryGetCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_type_find_factory_get_caps _obj'+    checkUnexpectedReturnNULL "gst_type_find_factory_get_caps" result+    result' <- (newBoxed Caps) result+    touchManagedPtr _obj+    return result'++data TypeFindFactoryGetCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryGetCapsMethodInfo a signature where+    overloadedMethod _ = typeFindFactoryGetCaps++-- method TypeFindFactory::get_extensions+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_factory_get_extensions" gst_type_find_factory_get_extensions :: +    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"+    IO (Ptr CString)+++typeFindFactoryGetExtensions ::+    (MonadIO m, TypeFindFactoryK a) =>+    a                                       -- _obj+    -> m [T.Text]                           -- result+typeFindFactoryGetExtensions _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_type_find_factory_get_extensions _obj'+    checkUnexpectedReturnNULL "gst_type_find_factory_get_extensions" result+    result' <- unpackZeroTerminatedUTF8CArray result+    touchManagedPtr _obj+    return result'++data TypeFindFactoryGetExtensionsMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryGetExtensionsMethodInfo a signature where+    overloadedMethod _ = typeFindFactoryGetExtensions++-- method TypeFindFactory::has_function+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_factory_has_function" gst_type_find_factory_has_function :: +    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"+    IO CInt+++typeFindFactoryHasFunction ::+    (MonadIO m, TypeFindFactoryK a) =>+    a                                       -- _obj+    -> m Bool                               -- result+typeFindFactoryHasFunction _obj = liftIO $ do+    let _obj' = unsafeManagedPtrCastPtr _obj+    result <- gst_type_find_factory_has_function _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TypeFindFactoryHasFunctionMethodInfo+instance (signature ~ (m Bool), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryHasFunctionMethodInfo a signature where+    overloadedMethod _ = typeFindFactoryHasFunction++-- method TypeFindFactory::get_list+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "TypeFindFactory")+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_factory_get_list" gst_type_find_factory_get_list :: +    IO (Ptr (GList (Ptr TypeFindFactory)))+++typeFindFactoryGetList ::+    (MonadIO m) =>+    m [TypeFindFactory]                     -- result+typeFindFactoryGetList  = liftIO $ do+    result <- gst_type_find_factory_get_list+    checkUnexpectedReturnNULL "gst_type_find_factory_get_list" result+    result' <- unpackGList result+    result'' <- mapM (wrapObject TypeFindFactory) result'+    g_list_free result+    return result''++
+ GI/Gst/Objects/TypeFindFactory.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gst.Objects.TypeFindFactory 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++newtype TypeFindFactory = TypeFindFactory (ForeignPtr TypeFindFactory)+instance GObject TypeFindFactory where+class GObject o => TypeFindFactoryK o+instance (GObject o, IsDescendantOf TypeFindFactory o) => TypeFindFactoryK o+data TypeFindFactoryCallFunctionMethodInfo+data TypeFindFactoryGetCapsMethodInfo+data TypeFindFactoryGetExtensionsMethodInfo+data TypeFindFactoryHasFunctionMethodInfo
+ GI/Gst/Structs.hs view
@@ -0,0 +1,111 @@+++{- |+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.Structs+    (     module GI.Gst.Structs.AllocationParams  ,+    module GI.Gst.Structs.AtomicQueue       ,+    module GI.Gst.Structs.Buffer            ,+    module GI.Gst.Structs.BufferList        ,+    module GI.Gst.Structs.BufferPoolAcquireParams,+    module GI.Gst.Structs.Caps              ,+    module GI.Gst.Structs.CapsFeatures      ,+    module GI.Gst.Structs.ClockEntry        ,+    module GI.Gst.Structs.Context           ,+    module GI.Gst.Structs.DateTime          ,+    module GI.Gst.Structs.DebugCategory     ,+    module GI.Gst.Structs.DebugMessage      ,+    module GI.Gst.Structs.Event             ,+    module GI.Gst.Structs.FormatDefinition  ,+    module GI.Gst.Structs.Iterator          ,+    module GI.Gst.Structs.MapInfo           ,+    module GI.Gst.Structs.Memory            ,+    module GI.Gst.Structs.Message           ,+    module GI.Gst.Structs.Meta              ,+    module GI.Gst.Structs.MetaInfo          ,+    module GI.Gst.Structs.MetaTransformCopy ,+    module GI.Gst.Structs.MiniObject        ,+    module GI.Gst.Structs.PadProbeInfo      ,+    module GI.Gst.Structs.ParamSpecFraction ,+    module GI.Gst.Structs.ParentBufferMeta  ,+    module GI.Gst.Structs.ParseContext      ,+    module GI.Gst.Structs.PluginDesc        ,+    module GI.Gst.Structs.Poll              ,+    module GI.Gst.Structs.PollFD            ,+    module GI.Gst.Structs.ProtectionMeta    ,+    module GI.Gst.Structs.Query             ,+    module GI.Gst.Structs.Sample            ,+    module GI.Gst.Structs.Segment           ,+    module GI.Gst.Structs.StaticCaps        ,+    module GI.Gst.Structs.StaticPadTemplate ,+    module GI.Gst.Structs.Structure         ,+    module GI.Gst.Structs.TagList           ,+    module GI.Gst.Structs.TimedValue        ,+    module GI.Gst.Structs.Toc               ,+    module GI.Gst.Structs.TocEntry          ,+    module GI.Gst.Structs.TypeFind          ,+    module GI.Gst.Structs.Uri               ,+    module GI.Gst.Structs.ValueTable        ,+++    ) where++import GI.Gst.Structs.AllocationParams+import GI.Gst.Structs.AtomicQueue+import GI.Gst.Structs.Buffer+import GI.Gst.Structs.BufferList+import GI.Gst.Structs.BufferPoolAcquireParams+import GI.Gst.Structs.Caps+import GI.Gst.Structs.CapsFeatures+import GI.Gst.Structs.ClockEntry+import GI.Gst.Structs.Context+import GI.Gst.Structs.DateTime+import GI.Gst.Structs.DebugCategory+import GI.Gst.Structs.DebugMessage+import GI.Gst.Structs.Event+import GI.Gst.Structs.FormatDefinition+import GI.Gst.Structs.Iterator+import GI.Gst.Structs.MapInfo+import GI.Gst.Structs.Memory+import GI.Gst.Structs.Message+import GI.Gst.Structs.Meta+import GI.Gst.Structs.MetaInfo+import GI.Gst.Structs.MetaTransformCopy+import GI.Gst.Structs.MiniObject+import GI.Gst.Structs.PadProbeInfo+import GI.Gst.Structs.ParamSpecFraction+import GI.Gst.Structs.ParentBufferMeta+import GI.Gst.Structs.ParseContext+import GI.Gst.Structs.PluginDesc+import GI.Gst.Structs.Poll+import GI.Gst.Structs.PollFD+import GI.Gst.Structs.ProtectionMeta+import GI.Gst.Structs.Query+import GI.Gst.Structs.Sample+import GI.Gst.Structs.Segment+import GI.Gst.Structs.StaticCaps+import GI.Gst.Structs.StaticPadTemplate+import GI.Gst.Structs.Structure+import GI.Gst.Structs.TagList+import GI.Gst.Structs.TimedValue+import GI.Gst.Structs.Toc+import GI.Gst.Structs.TocEntry+import GI.Gst.Structs.TypeFind+import GI.Gst.Structs.Uri+import GI.Gst.Structs.ValueTable++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 GI.Gst.Callbacks++
+ GI/Gst/Structs/AllocationParams.hs view
@@ -0,0 +1,201 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Parameters to control the allocation of memory+-}++module GI.Gst.Structs.AllocationParams+    ( ++-- * Exported types+    AllocationParams(..)                    ,+    newZeroAllocationParams                 ,+    noAllocationParams                      ,+++ -- * Methods+-- ** allocationParamsCopy+    AllocationParamsCopyMethodInfo          ,+    allocationParamsCopy                    ,+++-- ** allocationParamsFree+    AllocationParamsFreeMethodInfo          ,+    allocationParamsFree                    ,+++-- ** allocationParamsInit+    AllocationParamsInitMethodInfo          ,+    allocationParamsInit                    ,+++++ -- * Properties+-- ** Align+    allocationParamsReadAlign               ,+++-- ** Flags+    allocationParamsReadFlags               ,+++-- ** Padding+    allocationParamsReadPadding             ,+++-- ** Prefix+    allocationParamsReadPrefix              ,+++++    ) 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 GI.Gst.Callbacks++newtype AllocationParams = AllocationParams (ForeignPtr AllocationParams)+foreign import ccall "gst_allocation_params_get_type" c_gst_allocation_params_get_type :: +    IO GType++instance BoxedObject AllocationParams where+    boxedType _ = c_gst_allocation_params_get_type++-- | Construct a `AllocationParams` struct initialized to zero.+newZeroAllocationParams :: MonadIO m => m AllocationParams+newZeroAllocationParams = liftIO $ callocBoxedBytes 64 >>= wrapBoxed AllocationParams++noAllocationParams :: Maybe AllocationParams+noAllocationParams = Nothing++allocationParamsReadFlags :: AllocationParams -> IO [MemoryFlags]+allocationParamsReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = wordToGFlags val+    return val'++allocationParamsReadAlign :: AllocationParams -> IO Word64+allocationParamsReadAlign s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word64+    return val++allocationParamsReadPrefix :: AllocationParams -> IO Word64+allocationParamsReadPrefix s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word64+    return val++allocationParamsReadPadding :: AllocationParams -> IO Word64+allocationParamsReadPadding s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word64+    return val++-- method AllocationParams::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "AllocationParams"+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocation_params_copy" gst_allocation_params_copy :: +    Ptr AllocationParams ->                 -- _obj : TInterface "Gst" "AllocationParams"+    IO (Ptr AllocationParams)+++allocationParamsCopy ::+    (MonadIO m) =>+    AllocationParams                        -- _obj+    -> m AllocationParams                   -- result+allocationParamsCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_allocation_params_copy _obj'+    checkUnexpectedReturnNULL "gst_allocation_params_copy" result+    result' <- (wrapBoxed AllocationParams) result+    touchManagedPtr _obj+    return result'++data AllocationParamsCopyMethodInfo+instance (signature ~ (m AllocationParams), MonadIO m) => MethodInfo AllocationParamsCopyMethodInfo AllocationParams signature where+    overloadedMethod _ = allocationParamsCopy++-- method AllocationParams::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocation_params_free" gst_allocation_params_free :: +    Ptr AllocationParams ->                 -- _obj : TInterface "Gst" "AllocationParams"+    IO ()+++allocationParamsFree ::+    (MonadIO m) =>+    AllocationParams                        -- _obj+    -> m ()                                 -- result+allocationParamsFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_allocation_params_free _obj'+    touchManagedPtr _obj+    return ()++data AllocationParamsFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo AllocationParamsFreeMethodInfo AllocationParams signature where+    overloadedMethod _ = allocationParamsFree++-- method AllocationParams::init+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_allocation_params_init" gst_allocation_params_init :: +    Ptr AllocationParams ->                 -- _obj : TInterface "Gst" "AllocationParams"+    IO ()+++allocationParamsInit ::+    (MonadIO m) =>+    AllocationParams                        -- _obj+    -> m ()                                 -- result+allocationParamsInit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_allocation_params_init _obj'+    touchManagedPtr _obj+    return ()++data AllocationParamsInitMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo AllocationParamsInitMethodInfo AllocationParams signature where+    overloadedMethod _ = allocationParamsInit++type family ResolveAllocationParamsMethod (t :: Symbol) (o :: *) :: * where+    ResolveAllocationParamsMethod "copy" o = AllocationParamsCopyMethodInfo+    ResolveAllocationParamsMethod "free" o = AllocationParamsFreeMethodInfo+    ResolveAllocationParamsMethod "init" o = AllocationParamsInitMethodInfo+    ResolveAllocationParamsMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveAllocationParamsMethod t AllocationParams, MethodInfo info AllocationParams p) => IsLabelProxy t (AllocationParams -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveAllocationParamsMethod t AllocationParams, MethodInfo info AllocationParams p) => IsLabel t (AllocationParams -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/AllocationParams.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gst.Structs.AllocationParams 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++newtype AllocationParams = AllocationParams (ForeignPtr AllocationParams)+instance BoxedObject AllocationParams where+data AllocationParamsCopyMethodInfo+data AllocationParamsFreeMethodInfo+data AllocationParamsInitMethodInfo
+ GI/Gst/Structs/AtomicQueue.hs view
@@ -0,0 +1,283 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The #GstAtomicQueue object implements a queue that can be used from multiple+threads without performing any blocking operations.+-}++module GI.Gst.Structs.AtomicQueue+    ( ++-- * Exported types+    AtomicQueue(..)                         ,+    noAtomicQueue                           ,+++ -- * Methods+-- ** atomicQueueLength+    AtomicQueueLengthMethodInfo             ,+    atomicQueueLength                       ,+++-- ** atomicQueueNew+    atomicQueueNew                          ,+++-- ** atomicQueuePeek+    AtomicQueuePeekMethodInfo               ,+    atomicQueuePeek                         ,+++-- ** atomicQueuePop+    AtomicQueuePopMethodInfo                ,+    atomicQueuePop                          ,+++-- ** atomicQueuePush+    AtomicQueuePushMethodInfo               ,+    atomicQueuePush                         ,+++-- ** atomicQueueRef+    AtomicQueueRefMethodInfo                ,+    atomicQueueRef                          ,+++-- ** atomicQueueUnref+    AtomicQueueUnrefMethodInfo              ,+    atomicQueueUnref                        ,+++++    ) 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 GI.Gst.Callbacks++newtype AtomicQueue = AtomicQueue (ForeignPtr AtomicQueue)+foreign import ccall "gst_atomic_queue_get_type" c_gst_atomic_queue_get_type :: +    IO GType++instance BoxedObject AtomicQueue where+    boxedType _ = c_gst_atomic_queue_get_type++noAtomicQueue :: Maybe AtomicQueue+noAtomicQueue = Nothing++-- method AtomicQueue::new+-- method type : Constructor+-- Args : [Arg {argCName = "initial_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "AtomicQueue"+-- throws : False+-- Skip return : False++foreign import ccall "gst_atomic_queue_new" gst_atomic_queue_new :: +    Word32 ->                               -- initial_size : TBasicType TUInt32+    IO (Ptr AtomicQueue)+++atomicQueueNew ::+    (MonadIO m) =>+    Word32                                  -- initialSize+    -> m AtomicQueue                        -- result+atomicQueueNew initialSize = liftIO $ do+    result <- gst_atomic_queue_new initialSize+    checkUnexpectedReturnNULL "gst_atomic_queue_new" result+    result' <- (wrapBoxed AtomicQueue) result+    return result'++-- method AtomicQueue::length+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_atomic_queue_length" gst_atomic_queue_length :: +    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"+    IO Word32+++atomicQueueLength ::+    (MonadIO m) =>+    AtomicQueue                             -- _obj+    -> m Word32                             -- result+atomicQueueLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_atomic_queue_length _obj'+    touchManagedPtr _obj+    return result++data AtomicQueueLengthMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo AtomicQueueLengthMethodInfo AtomicQueue signature where+    overloadedMethod _ = atomicQueueLength++-- method AtomicQueue::peek+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_atomic_queue_peek" gst_atomic_queue_peek :: +    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"+    IO ()+++atomicQueuePeek ::+    (MonadIO m) =>+    AtomicQueue                             -- _obj+    -> m ()                                 -- result+atomicQueuePeek _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_atomic_queue_peek _obj'+    touchManagedPtr _obj+    return ()++data AtomicQueuePeekMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueuePeekMethodInfo AtomicQueue signature where+    overloadedMethod _ = atomicQueuePeek++-- method AtomicQueue::pop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_atomic_queue_pop" gst_atomic_queue_pop :: +    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"+    IO ()+++atomicQueuePop ::+    (MonadIO m) =>+    AtomicQueue                             -- _obj+    -> m ()                                 -- result+atomicQueuePop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_atomic_queue_pop _obj'+    touchManagedPtr _obj+    return ()++data AtomicQueuePopMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueuePopMethodInfo AtomicQueue signature where+    overloadedMethod _ = atomicQueuePop++-- method AtomicQueue::push+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_atomic_queue_push" gst_atomic_queue_push :: +    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"+    Ptr () ->                               -- data : TBasicType TVoid+    IO ()+++atomicQueuePush ::+    (MonadIO m) =>+    AtomicQueue                             -- _obj+    -> Ptr ()                               -- data_+    -> m ()                                 -- result+atomicQueuePush _obj data_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_atomic_queue_push _obj' data_+    touchManagedPtr _obj+    return ()++data AtomicQueuePushMethodInfo+instance (signature ~ (Ptr () -> m ()), MonadIO m) => MethodInfo AtomicQueuePushMethodInfo AtomicQueue signature where+    overloadedMethod _ = atomicQueuePush++-- method AtomicQueue::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_atomic_queue_ref" gst_atomic_queue_ref :: +    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"+    IO ()+++atomicQueueRef ::+    (MonadIO m) =>+    AtomicQueue                             -- _obj+    -> m ()                                 -- result+atomicQueueRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_atomic_queue_ref _obj'+    touchManagedPtr _obj+    return ()++data AtomicQueueRefMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueueRefMethodInfo AtomicQueue signature where+    overloadedMethod _ = atomicQueueRef++-- method AtomicQueue::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_atomic_queue_unref" gst_atomic_queue_unref :: +    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"+    IO ()+++atomicQueueUnref ::+    (MonadIO m) =>+    AtomicQueue                             -- _obj+    -> m ()                                 -- result+atomicQueueUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_atomic_queue_unref _obj'+    touchManagedPtr _obj+    return ()++data AtomicQueueUnrefMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueueUnrefMethodInfo AtomicQueue signature where+    overloadedMethod _ = atomicQueueUnref++type family ResolveAtomicQueueMethod (t :: Symbol) (o :: *) :: * where+    ResolveAtomicQueueMethod "length" o = AtomicQueueLengthMethodInfo+    ResolveAtomicQueueMethod "peek" o = AtomicQueuePeekMethodInfo+    ResolveAtomicQueueMethod "pop" o = AtomicQueuePopMethodInfo+    ResolveAtomicQueueMethod "push" o = AtomicQueuePushMethodInfo+    ResolveAtomicQueueMethod "ref" o = AtomicQueueRefMethodInfo+    ResolveAtomicQueueMethod "unref" o = AtomicQueueUnrefMethodInfo+    ResolveAtomicQueueMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveAtomicQueueMethod t AtomicQueue, MethodInfo info AtomicQueue p) => IsLabelProxy t (AtomicQueue -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveAtomicQueueMethod t AtomicQueue, MethodInfo info AtomicQueue p) => IsLabel t (AtomicQueue -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/AtomicQueue.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gst.Structs.AtomicQueue 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++newtype AtomicQueue = AtomicQueue (ForeignPtr AtomicQueue)+instance BoxedObject AtomicQueue where+data AtomicQueueLengthMethodInfo+data AtomicQueuePeekMethodInfo+data AtomicQueuePopMethodInfo+data AtomicQueuePushMethodInfo+data AtomicQueueRefMethodInfo+data AtomicQueueUnrefMethodInfo
+ GI/Gst/Structs/Buffer.hs view
@@ -0,0 +1,2061 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Buffers are the basic unit of data transfer in GStreamer. They contain the+timing and offset along with other arbitrary metadata that is associated+with the #GstMemory blocks that the buffer contains.++Buffers are usually created with gst_buffer_new(). After a buffer has been+created one will typically allocate memory for it and add it to the buffer.+The following example creates a buffer that can hold a given video frame+with a given width, height and bits per plane.+|[+  GstBuffer *buffer;+  GstMemory *memory;+  gint size, width, height, bpp;+  ...+  size = width * height * bpp;+  buffer = gst_buffer_new ();+  memory = gst_allocator_alloc (NULL, size, NULL);+  gst_buffer_insert_memory (buffer, -1, memory);+  ...+]|++Alternatively, use gst_buffer_new_allocate() to create a buffer with+preallocated data of a given size.++Buffers can contain a list of #GstMemory objects. You can retrieve how many+memory objects with gst_buffer_n_memory() and you can get a pointer+to memory with gst_buffer_peek_memory()++A buffer will usually have timestamps, and a duration, but neither of these+are guaranteed (they may be set to #GST_CLOCK_TIME_NONE). Whenever a+meaningful value can be given for these, they should be set. The timestamps+and duration are measured in nanoseconds (they are #GstClockTime values).++The buffer DTS refers to the timestamp when the buffer should be decoded and+is usually monotonically increasing. The buffer PTS refers to the timestamp when+the buffer content should be presented to the user and is not always+monotonically increasing.++A buffer can also have one or both of a start and an end offset. These are+media-type specific. For video buffers, the start offset will generally be+the frame number. For audio buffers, it will be the number of samples+produced so far. For compressed data, it could be the byte offset in a+source or destination file. Likewise, the end offset will be the offset of+the end of the buffer. These can only be meaningfully interpreted if you+know the media type of the buffer (the preceding CAPS event). Either or both+can be set to #GST_BUFFER_OFFSET_NONE.++gst_buffer_ref() is used to increase the refcount of a buffer. This must be+done when you want to keep a handle to the buffer after pushing it to the+next element. The buffer refcount determines the writability of the buffer, a+buffer is only writable when the refcount is exactly 1, i.e. when the caller+has the only reference to the buffer.++To efficiently create a smaller buffer out of an existing one, you can+use gst_buffer_copy_region(). This method tries to share the memory objects+between the two buffers.++If a plug-in wants to modify the buffer data or metadata in-place, it should+first obtain a buffer that is safe to modify by using+gst_buffer_make_writable().  This function is optimized so that a copy will+only be made when it is necessary.++Several flags of the buffer can be set and unset with the+GST_BUFFER_FLAG_SET() and GST_BUFFER_FLAG_UNSET() macros. Use+GST_BUFFER_FLAG_IS_SET() to test if a certain #GstBufferFlags flag is set.++Buffers can be efficiently merged into a larger buffer with+gst_buffer_append(). Copying of memory will only be done when absolutely+needed.++Arbitrary extra metadata can be set on a buffer with gst_buffer_add_meta().+Metadata can be retrieved with gst_buffer_get_meta(). See also #GstMeta++An element should either unref the buffer or push it out on a src pad+using gst_pad_push() (see #GstPad).++Buffers are usually freed by unreffing them with gst_buffer_unref(). When+the refcount drops to 0, any memory and metadata pointed to by the buffer is+unreffed as well. Buffers allocated from a #GstBufferPool will be returned to+the pool when the refcount drops to 0.++The #GstParentBufferMeta is a meta which can be attached to a #GstBuffer+to hold a reference to another buffer that is only released when the child+#GstBuffer is released.++Typically, #GstParentBufferMeta is used when the child buffer is directly+using the #GstMemory of the parent buffer, and wants to prevent the parent+buffer from being returned to a buffer pool until the #GstMemory is available+for re-use. (Since 1.6)+-}++module GI.Gst.Structs.Buffer+    ( ++-- * Exported types+    Buffer(..)                              ,+    newZeroBuffer                           ,+    noBuffer                                ,+++ -- * Methods+-- ** bufferAddMeta+    BufferAddMetaMethodInfo                 ,+    bufferAddMeta                           ,+++-- ** bufferAddParentBufferMeta+    BufferAddParentBufferMetaMethodInfo     ,+    bufferAddParentBufferMeta               ,+++-- ** bufferAddProtectionMeta+    BufferAddProtectionMetaMethodInfo       ,+    bufferAddProtectionMeta                 ,+++-- ** bufferAppend+    BufferAppendMethodInfo                  ,+    bufferAppend                            ,+++-- ** bufferAppendMemory+    BufferAppendMemoryMethodInfo            ,+    bufferAppendMemory                      ,+++-- ** bufferAppendRegion+    BufferAppendRegionMethodInfo            ,+    bufferAppendRegion                      ,+++-- ** bufferCopyDeep+    BufferCopyDeepMethodInfo                ,+    bufferCopyDeep                          ,+++-- ** bufferCopyInto+    BufferCopyIntoMethodInfo                ,+    bufferCopyInto                          ,+++-- ** bufferCopyRegion+    BufferCopyRegionMethodInfo              ,+    bufferCopyRegion                        ,+++-- ** bufferExtract+    BufferExtractMethodInfo                 ,+    bufferExtract                           ,+++-- ** bufferExtractDup+    BufferExtractDupMethodInfo              ,+    bufferExtractDup                        ,+++-- ** bufferFill+    BufferFillMethodInfo                    ,+    bufferFill                              ,+++-- ** bufferFindMemory+    BufferFindMemoryMethodInfo              ,+    bufferFindMemory                        ,+++-- ** bufferForeachMeta+    BufferForeachMetaMethodInfo             ,+    bufferForeachMeta                       ,+++-- ** bufferGetAllMemory+    BufferGetAllMemoryMethodInfo            ,+    bufferGetAllMemory                      ,+++-- ** bufferGetMaxMemory+    bufferGetMaxMemory                      ,+++-- ** bufferGetMemory+    BufferGetMemoryMethodInfo               ,+    bufferGetMemory                         ,+++-- ** bufferGetMemoryRange+    BufferGetMemoryRangeMethodInfo          ,+    bufferGetMemoryRange                    ,+++-- ** bufferGetMeta+    BufferGetMetaMethodInfo                 ,+    bufferGetMeta                           ,+++-- ** bufferGetSize+    BufferGetSizeMethodInfo                 ,+    bufferGetSize                           ,+++-- ** bufferGetSizes+    BufferGetSizesMethodInfo                ,+    bufferGetSizes                          ,+++-- ** bufferGetSizesRange+    BufferGetSizesRangeMethodInfo           ,+    bufferGetSizesRange                     ,+++-- ** bufferInsertMemory+    BufferInsertMemoryMethodInfo            ,+    bufferInsertMemory                      ,+++-- ** bufferIsAllMemoryWritable+    BufferIsAllMemoryWritableMethodInfo     ,+    bufferIsAllMemoryWritable               ,+++-- ** bufferIsMemoryRangeWritable+    BufferIsMemoryRangeWritableMethodInfo   ,+    bufferIsMemoryRangeWritable             ,+++-- ** bufferIterateMeta+    BufferIterateMetaMethodInfo             ,+    bufferIterateMeta                       ,+++-- ** bufferMap+    BufferMapMethodInfo                     ,+    bufferMap                               ,+++-- ** bufferMapRange+    BufferMapRangeMethodInfo                ,+    bufferMapRange                          ,+++-- ** bufferMemcmp+    BufferMemcmpMethodInfo                  ,+    bufferMemcmp                            ,+++-- ** bufferMemset+    BufferMemsetMethodInfo                  ,+    bufferMemset                            ,+++-- ** bufferNMemory+    BufferNMemoryMethodInfo                 ,+    bufferNMemory                           ,+++-- ** bufferNew+    bufferNew                               ,+++-- ** bufferNewAllocate+    bufferNewAllocate                       ,+++-- ** bufferNewWrapped+    bufferNewWrapped                        ,+++-- ** bufferNewWrappedFull+    bufferNewWrappedFull                    ,+++-- ** bufferPeekMemory+    BufferPeekMemoryMethodInfo              ,+    bufferPeekMemory                        ,+++-- ** bufferPrependMemory+    BufferPrependMemoryMethodInfo           ,+    bufferPrependMemory                     ,+++-- ** bufferRemoveAllMemory+    BufferRemoveAllMemoryMethodInfo         ,+    bufferRemoveAllMemory                   ,+++-- ** bufferRemoveMemory+    BufferRemoveMemoryMethodInfo            ,+    bufferRemoveMemory                      ,+++-- ** bufferRemoveMemoryRange+    BufferRemoveMemoryRangeMethodInfo       ,+    bufferRemoveMemoryRange                 ,+++-- ** bufferRemoveMeta+    BufferRemoveMetaMethodInfo              ,+    bufferRemoveMeta                        ,+++-- ** bufferReplaceAllMemory+    BufferReplaceAllMemoryMethodInfo        ,+    bufferReplaceAllMemory                  ,+++-- ** bufferReplaceMemory+    BufferReplaceMemoryMethodInfo           ,+    bufferReplaceMemory                     ,+++-- ** bufferReplaceMemoryRange+    BufferReplaceMemoryRangeMethodInfo      ,+    bufferReplaceMemoryRange                ,+++-- ** bufferResize+    BufferResizeMethodInfo                  ,+    bufferResize                            ,+++-- ** bufferResizeRange+    BufferResizeRangeMethodInfo             ,+    bufferResizeRange                       ,+++-- ** bufferSetSize+    BufferSetSizeMethodInfo                 ,+    bufferSetSize                           ,+++-- ** bufferUnmap+    BufferUnmapMethodInfo                   ,+    bufferUnmap                             ,+++++ -- * Properties+-- ** Dts+    bufferReadDts                           ,+++-- ** Duration+    bufferReadDuration                      ,+++-- ** MiniObject+    bufferReadMiniObject                    ,+++-- ** Offset+    bufferReadOffset                        ,+++-- ** OffsetEnd+    bufferReadOffsetEnd                     ,+++-- ** Pool+    bufferReadPool                          ,+++-- ** Pts+    bufferReadPts                           ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype Buffer = Buffer (ForeignPtr Buffer)+foreign import ccall "gst_buffer_get_type" c_gst_buffer_get_type :: +    IO GType++instance BoxedObject Buffer where+    boxedType _ = c_gst_buffer_get_type++-- | Construct a `Buffer` struct initialized to zero.+newZeroBuffer :: MonadIO m => m Buffer+newZeroBuffer = liftIO $ callocBoxedBytes 112 >>= wrapBoxed Buffer++noBuffer :: Maybe Buffer+noBuffer = Nothing++bufferReadMiniObject :: Buffer -> IO MiniObject+bufferReadMiniObject s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)+    val' <- (newPtr 64 MiniObject) val+    return val'++bufferReadPool :: Buffer -> IO BufferPool+bufferReadPool s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO (Ptr BufferPool)+    val' <- (newObject BufferPool) val+    return val'++bufferReadPts :: Buffer -> IO Word64+bufferReadPts s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO Word64+    return val++bufferReadDts :: Buffer -> IO Word64+bufferReadDts s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 80) :: IO Word64+    return val++bufferReadDuration :: Buffer -> IO Word64+bufferReadDuration s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 88) :: IO Word64+    return val++bufferReadOffset :: Buffer -> IO Word64+bufferReadOffset s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 96) :: IO Word64+    return val++bufferReadOffsetEnd :: Buffer -> IO Word64+bufferReadOffsetEnd s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 104) :: IO Word64+    return val++-- method Buffer::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_new" gst_buffer_new :: +    IO (Ptr Buffer)+++bufferNew ::+    (MonadIO m) =>+    m Buffer                                -- result+bufferNew  = liftIO $ do+    result <- gst_buffer_new+    checkUnexpectedReturnNULL "gst_buffer_new" result+    result' <- (wrapBoxed Buffer) result+    return result'++-- method Buffer::new_allocate+-- method type : Constructor+-- Args : [Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_new_allocate" gst_buffer_new_allocate :: +    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"+    IO (Ptr Buffer)+++bufferNewAllocate ::+    (MonadIO m, AllocatorK a) =>+    Maybe (a)                               -- allocator+    -> Word64                               -- size+    -> Maybe (AllocationParams)             -- params+    -> m Buffer                             -- result+bufferNewAllocate allocator size params = liftIO $ do+    maybeAllocator <- case allocator of+        Nothing -> return nullPtr+        Just jAllocator -> do+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator+            return jAllocator'+    maybeParams <- case params of+        Nothing -> return nullPtr+        Just jParams -> do+            let jParams' = unsafeManagedPtrGetPtr jParams+            return jParams'+    result <- gst_buffer_new_allocate maybeAllocator size maybeParams+    checkUnexpectedReturnNULL "gst_buffer_new_allocate" result+    result' <- (wrapBoxed Buffer) result+    whenJust allocator touchManagedPtr+    whenJust params touchManagedPtr+    return result'++-- method Buffer::new_wrapped+-- method type : Constructor+-- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_new_wrapped" gst_buffer_new_wrapped :: +    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    IO (Ptr Buffer)+++bufferNewWrapped ::+    (MonadIO m) =>+    ByteString                              -- data_+    -> m Buffer                             -- result+bufferNewWrapped data_ = liftIO $ do+    let size = fromIntegral $ B.length data_+    data_' <- packByteString data_+    result <- gst_buffer_new_wrapped data_' size+    checkUnexpectedReturnNULL "gst_buffer_new_wrapped" result+    result' <- (wrapBoxed Buffer) result+    return result'++-- method Buffer::new_wrapped_full+-- method type : Constructor+-- Args : [Arg {argCName = "flags", argType = TInterface "Gst" "MemoryFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 4 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_new_wrapped_full" gst_buffer_new_wrapped_full :: +    CUInt ->                                -- flags : TInterface "Gst" "MemoryFlags"+    Ptr Word8 ->                            -- data : TCArray False (-1) 4 (TBasicType TUInt8)+    Word64 ->                               -- maxsize : TBasicType TUInt64+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO (Ptr Buffer)+++bufferNewWrappedFull ::+    (MonadIO m) =>+    [MemoryFlags]                           -- flags+    -> ByteString                           -- data_+    -> Word64                               -- maxsize+    -> Word64                               -- offset+    -> Maybe (GLib.DestroyNotify)           -- notify+    -> m Buffer                             -- result+bufferNewWrappedFull flags data_ maxsize offset notify = liftIO $ do+    let size = fromIntegral $ B.length data_+    let flags' = gflagsToWord flags+    data_' <- packByteString data_+    ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    maybeNotify <- case notify of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jNotify -> do+            jNotify' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrnotify) jNotify)+            poke ptrnotify jNotify'+            return jNotify'+    let userData = nullPtr+    result <- gst_buffer_new_wrapped_full flags' data_' maxsize offset size userData maybeNotify+    checkUnexpectedReturnNULL "gst_buffer_new_wrapped_full" result+    result' <- (wrapBoxed Buffer) result+    freeMem data_'+    return result'++-- method Buffer::add_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MetaInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Meta"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_meta" gst_buffer_add_meta :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr MetaInfo ->                         -- info : TInterface "Gst" "MetaInfo"+    Ptr () ->                               -- params : TBasicType TVoid+    IO (Ptr Meta)+++bufferAddMeta ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> MetaInfo                             -- info+    -> Ptr ()                               -- params+    -> m Meta                               -- result+bufferAddMeta _obj info params = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let info' = unsafeManagedPtrGetPtr info+    result <- gst_buffer_add_meta _obj' info' params+    checkUnexpectedReturnNULL "gst_buffer_add_meta" result+    result' <- (newPtr 16 Meta) result+    touchManagedPtr _obj+    touchManagedPtr info+    return result'++data BufferAddMetaMethodInfo+instance (signature ~ (MetaInfo -> Ptr () -> m Meta), MonadIO m) => MethodInfo BufferAddMetaMethodInfo Buffer signature where+    overloadedMethod _ = bufferAddMeta++-- method Buffer::add_parent_buffer_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "ParentBufferMeta"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_parent_buffer_meta" gst_buffer_add_parent_buffer_meta :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Buffer ->                           -- ref : TInterface "Gst" "Buffer"+    IO (Ptr ParentBufferMeta)+++bufferAddParentBufferMeta ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Buffer                               -- ref+    -> m ParentBufferMeta                   -- result+bufferAddParentBufferMeta _obj ref = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let ref' = unsafeManagedPtrGetPtr ref+    result <- gst_buffer_add_parent_buffer_meta _obj' ref'+    checkUnexpectedReturnNULL "gst_buffer_add_parent_buffer_meta" result+    result' <- (newPtr 24 ParentBufferMeta) result+    touchManagedPtr _obj+    touchManagedPtr ref+    return result'++data BufferAddParentBufferMetaMethodInfo+instance (signature ~ (Buffer -> m ParentBufferMeta), MonadIO m) => MethodInfo BufferAddParentBufferMetaMethodInfo Buffer signature where+    overloadedMethod _ = bufferAddParentBufferMeta++-- method Buffer::add_protection_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "ProtectionMeta"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_add_protection_meta" gst_buffer_add_protection_meta :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Structure ->                        -- info : TInterface "Gst" "Structure"+    IO (Ptr ProtectionMeta)+++bufferAddProtectionMeta ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Structure                            -- info+    -> m ProtectionMeta                     -- result+bufferAddProtectionMeta _obj info = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    info' <- copyBoxed info+    result <- gst_buffer_add_protection_meta _obj' info'+    checkUnexpectedReturnNULL "gst_buffer_add_protection_meta" result+    result' <- (newPtr 24 ProtectionMeta) result+    touchManagedPtr _obj+    touchManagedPtr info+    return result'++data BufferAddProtectionMetaMethodInfo+instance (signature ~ (Structure -> m ProtectionMeta), MonadIO m) => MethodInfo BufferAddProtectionMetaMethodInfo Buffer signature where+    overloadedMethod _ = bufferAddProtectionMeta++-- method Buffer::append+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf2", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_append" gst_buffer_append :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Buffer ->                           -- buf2 : TInterface "Gst" "Buffer"+    IO (Ptr Buffer)+++bufferAppend ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Buffer                               -- buf2+    -> m Buffer                             -- result+bufferAppend _obj buf2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    buf2' <- copyBoxed buf2+    result <- gst_buffer_append _obj' buf2'+    checkUnexpectedReturnNULL "gst_buffer_append" result+    result' <- (wrapBoxed Buffer) result+    touchManagedPtr _obj+    touchManagedPtr buf2+    return result'++data BufferAppendMethodInfo+instance (signature ~ (Buffer -> m Buffer), MonadIO m) => MethodInfo BufferAppendMethodInfo Buffer signature where+    overloadedMethod _ = bufferAppend++-- method Buffer::append_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_append_memory" gst_buffer_append_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"+    IO ()+++bufferAppendMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Memory                               -- mem+    -> m ()                                 -- result+bufferAppendMemory _obj mem = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mem' <- copyBoxed mem+    gst_buffer_append_memory _obj' mem'+    touchManagedPtr _obj+    touchManagedPtr mem+    return ()++data BufferAppendMemoryMethodInfo+instance (signature ~ (Memory -> m ()), MonadIO m) => MethodInfo BufferAppendMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferAppendMemory++-- method Buffer::append_region+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf2", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_append_region" gst_buffer_append_region :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Buffer ->                           -- buf2 : TInterface "Gst" "Buffer"+    Int64 ->                                -- offset : TBasicType TInt64+    Int64 ->                                -- size : TBasicType TInt64+    IO (Ptr Buffer)+++bufferAppendRegion ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Buffer                               -- buf2+    -> Int64                                -- offset+    -> Int64                                -- size+    -> m Buffer                             -- result+bufferAppendRegion _obj buf2 offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    buf2' <- copyBoxed buf2+    result <- gst_buffer_append_region _obj' buf2' offset size+    checkUnexpectedReturnNULL "gst_buffer_append_region" result+    result' <- (wrapBoxed Buffer) result+    touchManagedPtr _obj+    touchManagedPtr buf2+    return result'++data BufferAppendRegionMethodInfo+instance (signature ~ (Buffer -> Int64 -> Int64 -> m Buffer), MonadIO m) => MethodInfo BufferAppendRegionMethodInfo Buffer signature where+    overloadedMethod _ = bufferAppendRegion++-- method Buffer::copy_deep+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_copy_deep" gst_buffer_copy_deep :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    IO (Ptr Buffer)+++bufferCopyDeep ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> m Buffer                             -- result+bufferCopyDeep _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_copy_deep _obj'+    checkUnexpectedReturnNULL "gst_buffer_copy_deep" result+    result' <- (wrapBoxed Buffer) result+    touchManagedPtr _obj+    return result'++data BufferCopyDeepMethodInfo+instance (signature ~ (m Buffer), MonadIO m) => MethodInfo BufferCopyDeepMethodInfo Buffer signature where+    overloadedMethod _ = bufferCopyDeep++-- method Buffer::copy_into+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "BufferCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_copy_into" gst_buffer_copy_into :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Buffer ->                           -- src : TInterface "Gst" "Buffer"+    CUInt ->                                -- flags : TInterface "Gst" "BufferCopyFlags"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- size : TBasicType TUInt64+    IO CInt+++bufferCopyInto ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Buffer                               -- src+    -> [BufferCopyFlags]                    -- flags+    -> Word64                               -- offset+    -> Word64                               -- size+    -> m Bool                               -- result+bufferCopyInto _obj src flags offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let src' = unsafeManagedPtrGetPtr src+    let flags' = gflagsToWord flags+    result <- gst_buffer_copy_into _obj' src' flags' offset size+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr src+    return result'++data BufferCopyIntoMethodInfo+instance (signature ~ (Buffer -> [BufferCopyFlags] -> Word64 -> Word64 -> m Bool), MonadIO m) => MethodInfo BufferCopyIntoMethodInfo Buffer signature where+    overloadedMethod _ = bufferCopyInto++-- method Buffer::copy_region+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "BufferCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_copy_region" gst_buffer_copy_region :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    CUInt ->                                -- flags : TInterface "Gst" "BufferCopyFlags"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- size : TBasicType TUInt64+    IO (Ptr Buffer)+++bufferCopyRegion ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> [BufferCopyFlags]                    -- flags+    -> Word64                               -- offset+    -> Word64                               -- size+    -> m Buffer                             -- result+bufferCopyRegion _obj flags offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = gflagsToWord flags+    result <- gst_buffer_copy_region _obj' flags' offset size+    checkUnexpectedReturnNULL "gst_buffer_copy_region" result+    result' <- (wrapBoxed Buffer) result+    touchManagedPtr _obj+    return result'++data BufferCopyRegionMethodInfo+instance (signature ~ ([BufferCopyFlags] -> Word64 -> Word64 -> m Buffer), MonadIO m) => MethodInfo BufferCopyRegionMethodInfo Buffer signature where+    overloadedMethod _ = bufferCopyRegion++-- method Buffer::extract+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_extract" gst_buffer_extract :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word64 ->                               -- offset : TBasicType TUInt64+    Ptr () ->                               -- dest : TBasicType TVoid+    Word64 ->                               -- size : TBasicType TUInt64+    IO Word64+++bufferExtract ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word64                               -- offset+    -> Ptr ()                               -- dest+    -> Word64                               -- size+    -> m Word64                             -- result+bufferExtract _obj offset dest size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_extract _obj' offset dest size+    touchManagedPtr _obj+    return result++data BufferExtractMethodInfo+instance (signature ~ (Word64 -> Ptr () -> Word64 -> m Word64), MonadIO m) => MethodInfo BufferExtractMethodInfo Buffer signature where+    overloadedMethod _ = bufferExtract++-- method Buffer::extract_dup+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TCArray False (-1) 4 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : [Arg {argCName = "dest_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_extract_dup" gst_buffer_extract_dup :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr (Ptr Word8) ->                      -- dest : TCArray False (-1) 4 (TBasicType TUInt8)+    Ptr Word64 ->                           -- dest_size : TBasicType TUInt64+    IO ()+++bufferExtractDup ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word64                               -- offset+    -> Word64                               -- size+    -> m (ByteString)                       -- result+bufferExtractDup _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    dest <- allocMem :: IO (Ptr (Ptr Word8))+    destSize <- allocMem :: IO (Ptr Word64)+    gst_buffer_extract_dup _obj' offset size dest destSize+    destSize' <- peek destSize+    dest' <- peek dest+    dest'' <- (unpackByteStringWithLength destSize') dest'+    freeMem dest'+    touchManagedPtr _obj+    freeMem dest+    freeMem destSize+    return dest''++data BufferExtractDupMethodInfo+instance (signature ~ (Word64 -> Word64 -> m (ByteString)), MonadIO m) => MethodInfo BufferExtractDupMethodInfo Buffer signature where+    overloadedMethod _ = bufferExtractDup++-- method Buffer::fill+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_fill" gst_buffer_fill :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word64 ->                               -- offset : TBasicType TUInt64+    Ptr Word8 ->                            -- src : TCArray False (-1) 3 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    IO Word64+++bufferFill ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word64                               -- offset+    -> ByteString                           -- src+    -> m Word64                             -- result+bufferFill _obj offset src = liftIO $ do+    let size = fromIntegral $ B.length src+    let _obj' = unsafeManagedPtrGetPtr _obj+    src' <- packByteString src+    result <- gst_buffer_fill _obj' offset src' size+    touchManagedPtr _obj+    freeMem src'+    return result++data BufferFillMethodInfo+instance (signature ~ (Word64 -> ByteString -> m Word64), MonadIO m) => MethodInfo BufferFillMethodInfo Buffer signature where+    overloadedMethod _ = bufferFill++-- method Buffer::find_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "skip", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_find_memory" gst_buffer_find_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr Word32 ->                           -- idx : TBasicType TUInt32+    Ptr Word32 ->                           -- length : TBasicType TUInt32+    Ptr Word64 ->                           -- skip : TBasicType TUInt64+    IO CInt+++bufferFindMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word64                               -- offset+    -> Word64                               -- size+    -> m (Bool,Word32,Word32,Word64)        -- result+bufferFindMemory _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    idx <- allocMem :: IO (Ptr Word32)+    length_ <- allocMem :: IO (Ptr Word32)+    skip <- allocMem :: IO (Ptr Word64)+    result <- gst_buffer_find_memory _obj' offset size idx length_ skip+    let result' = (/= 0) result+    idx' <- peek idx+    length_' <- peek length_+    skip' <- peek skip+    touchManagedPtr _obj+    freeMem idx+    freeMem length_+    freeMem skip+    return (result', idx', length_', skip')++data BufferFindMemoryMethodInfo+instance (signature ~ (Word64 -> Word64 -> m (Bool,Word32,Word32,Word64)), MonadIO m) => MethodInfo BufferFindMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferFindMemory++-- method Buffer::foreach_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BufferForeachMetaFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_foreach_meta" gst_buffer_foreach_meta :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    FunPtr BufferForeachMetaFuncC ->        -- func : TInterface "Gst" "BufferForeachMetaFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++bufferForeachMeta ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> BufferForeachMetaFunc                -- func+    -> m Bool                               -- result+bufferForeachMeta _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkBufferForeachMetaFunc (bufferForeachMetaFuncWrapper Nothing func)+    let userData = nullPtr+    result <- gst_buffer_foreach_meta _obj' func' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return result'++data BufferForeachMetaMethodInfo+instance (signature ~ (BufferForeachMetaFunc -> m Bool), MonadIO m) => MethodInfo BufferForeachMetaMethodInfo Buffer signature where+    overloadedMethod _ = bufferForeachMeta++-- method Buffer::get_all_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_all_memory" gst_buffer_get_all_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    IO (Ptr Memory)+++bufferGetAllMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> m Memory                             -- result+bufferGetAllMemory _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_get_all_memory _obj'+    checkUnexpectedReturnNULL "gst_buffer_get_all_memory" result+    result' <- (wrapBoxed Memory) result+    touchManagedPtr _obj+    return result'++data BufferGetAllMemoryMethodInfo+instance (signature ~ (m Memory), MonadIO m) => MethodInfo BufferGetAllMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferGetAllMemory++-- method Buffer::get_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_memory" gst_buffer_get_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    IO (Ptr Memory)+++bufferGetMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> m Memory                             -- result+bufferGetMemory _obj idx = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_get_memory _obj' idx+    checkUnexpectedReturnNULL "gst_buffer_get_memory" result+    result' <- (wrapBoxed Memory) result+    touchManagedPtr _obj+    return result'++data BufferGetMemoryMethodInfo+instance (signature ~ (Word32 -> m Memory), MonadIO m) => MethodInfo BufferGetMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferGetMemory++-- method Buffer::get_memory_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_memory_range" gst_buffer_get_memory_range :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Int32 ->                                -- length : TBasicType TInt32+    IO (Ptr Memory)+++bufferGetMemoryRange ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Int32                                -- length_+    -> m Memory                             -- result+bufferGetMemoryRange _obj idx length_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_get_memory_range _obj' idx length_+    checkUnexpectedReturnNULL "gst_buffer_get_memory_range" result+    result' <- (wrapBoxed Memory) result+    touchManagedPtr _obj+    return result'++data BufferGetMemoryRangeMethodInfo+instance (signature ~ (Word32 -> Int32 -> m Memory), MonadIO m) => MethodInfo BufferGetMemoryRangeMethodInfo Buffer signature where+    overloadedMethod _ = bufferGetMemoryRange++-- method Buffer::get_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Meta"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_meta" gst_buffer_get_meta :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    CGType ->                               -- api : TBasicType TGType+    IO (Ptr Meta)+++bufferGetMeta ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> GType                                -- api+    -> m Meta                               -- result+bufferGetMeta _obj api = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let api' = gtypeToCGType api+    result <- gst_buffer_get_meta _obj' api'+    checkUnexpectedReturnNULL "gst_buffer_get_meta" result+    result' <- (newPtr 16 Meta) result+    touchManagedPtr _obj+    return result'++data BufferGetMetaMethodInfo+instance (signature ~ (GType -> m Meta), MonadIO m) => MethodInfo BufferGetMetaMethodInfo Buffer signature where+    overloadedMethod _ = bufferGetMeta++-- method Buffer::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_size" gst_buffer_get_size :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    IO Word64+++bufferGetSize ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> m Word64                             -- result+bufferGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_get_size _obj'+    touchManagedPtr _obj+    return result++data BufferGetSizeMethodInfo+instance (signature ~ (m Word64), MonadIO m) => MethodInfo BufferGetSizeMethodInfo Buffer signature where+    overloadedMethod _ = bufferGetSize++-- method Buffer::get_sizes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_sizes" gst_buffer_get_sizes :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Word64 ->                           -- offset : TBasicType TUInt64+    Ptr Word64 ->                           -- maxsize : TBasicType TUInt64+    IO Word64+++bufferGetSizes ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> m (Word64,Word64,Word64)             -- result+bufferGetSizes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    offset <- allocMem :: IO (Ptr Word64)+    maxsize <- allocMem :: IO (Ptr Word64)+    result <- gst_buffer_get_sizes _obj' offset maxsize+    offset' <- peek offset+    maxsize' <- peek maxsize+    touchManagedPtr _obj+    freeMem offset+    freeMem maxsize+    return (result, offset', maxsize')++data BufferGetSizesMethodInfo+instance (signature ~ (m (Word64,Word64,Word64)), MonadIO m) => MethodInfo BufferGetSizesMethodInfo Buffer signature where+    overloadedMethod _ = bufferGetSizes++-- method Buffer::get_sizes_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_sizes_range" gst_buffer_get_sizes_range :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Int32 ->                                -- length : TBasicType TInt32+    Ptr Word64 ->                           -- offset : TBasicType TUInt64+    Ptr Word64 ->                           -- maxsize : TBasicType TUInt64+    IO Word64+++bufferGetSizesRange ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Int32                                -- length_+    -> m (Word64,Word64,Word64)             -- result+bufferGetSizesRange _obj idx length_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    offset <- allocMem :: IO (Ptr Word64)+    maxsize <- allocMem :: IO (Ptr Word64)+    result <- gst_buffer_get_sizes_range _obj' idx length_ offset maxsize+    offset' <- peek offset+    maxsize' <- peek maxsize+    touchManagedPtr _obj+    freeMem offset+    freeMem maxsize+    return (result, offset', maxsize')++data BufferGetSizesRangeMethodInfo+instance (signature ~ (Word32 -> Int32 -> m (Word64,Word64,Word64)), MonadIO m) => MethodInfo BufferGetSizesRangeMethodInfo Buffer signature where+    overloadedMethod _ = bufferGetSizesRange++-- method Buffer::insert_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_insert_memory" gst_buffer_insert_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Int32 ->                                -- idx : TBasicType TInt32+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"+    IO ()+++bufferInsertMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Int32                                -- idx+    -> Memory                               -- mem+    -> m ()                                 -- result+bufferInsertMemory _obj idx mem = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mem' <- copyBoxed mem+    gst_buffer_insert_memory _obj' idx mem'+    touchManagedPtr _obj+    touchManagedPtr mem+    return ()++data BufferInsertMemoryMethodInfo+instance (signature ~ (Int32 -> Memory -> m ()), MonadIO m) => MethodInfo BufferInsertMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferInsertMemory++-- method Buffer::is_all_memory_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_is_all_memory_writable" gst_buffer_is_all_memory_writable :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    IO CInt+++bufferIsAllMemoryWritable ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> m Bool                               -- result+bufferIsAllMemoryWritable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_is_all_memory_writable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BufferIsAllMemoryWritableMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo BufferIsAllMemoryWritableMethodInfo Buffer signature where+    overloadedMethod _ = bufferIsAllMemoryWritable++-- method Buffer::is_memory_range_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_is_memory_range_writable" gst_buffer_is_memory_range_writable :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Int32 ->                                -- length : TBasicType TInt32+    IO CInt+++bufferIsMemoryRangeWritable ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Int32                                -- length_+    -> m Bool                               -- result+bufferIsMemoryRangeWritable _obj idx length_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_is_memory_range_writable _obj' idx length_+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BufferIsMemoryRangeWritableMethodInfo+instance (signature ~ (Word32 -> Int32 -> m Bool), MonadIO m) => MethodInfo BufferIsMemoryRangeWritableMethodInfo Buffer signature where+    overloadedMethod _ = bufferIsMemoryRangeWritable++-- method Buffer::iterate_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Meta"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_iterate_meta" gst_buffer_iterate_meta :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr () ->                               -- state : TBasicType TVoid+    IO (Ptr Meta)+++bufferIterateMeta ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Ptr ()                               -- state+    -> m Meta                               -- result+bufferIterateMeta _obj state = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_iterate_meta _obj' state+    checkUnexpectedReturnNULL "gst_buffer_iterate_meta" result+    result' <- (newPtr 16 Meta) result+    touchManagedPtr _obj+    return result'++data BufferIterateMetaMethodInfo+instance (signature ~ (Ptr () -> m Meta), MonadIO m) => MethodInfo BufferIterateMetaMethodInfo Buffer signature where+    overloadedMethod _ = bufferIterateMeta++-- method Buffer::map+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_map" gst_buffer_map :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"+    IO CInt+++bufferMap ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> [MapFlags]                           -- flags+    -> m (Bool,MapInfo)                     -- result+bufferMap _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    info <- callocBytes 104 :: IO (Ptr MapInfo)+    let flags' = gflagsToWord flags+    result <- gst_buffer_map _obj' info flags'+    let result' = (/= 0) result+    info' <- (wrapPtr MapInfo) info+    touchManagedPtr _obj+    return (result', info')++data BufferMapMethodInfo+instance (signature ~ ([MapFlags] -> m (Bool,MapInfo)), MonadIO m) => MethodInfo BufferMapMethodInfo Buffer signature where+    overloadedMethod _ = bufferMap++-- method Buffer::map_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_map_range" gst_buffer_map_range :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Int32 ->                                -- length : TBasicType TInt32+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"+    IO CInt+++bufferMapRange ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Int32                                -- length_+    -> [MapFlags]                           -- flags+    -> m (Bool,MapInfo)                     -- result+bufferMapRange _obj idx length_ flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    info <- callocBytes 104 :: IO (Ptr MapInfo)+    let flags' = gflagsToWord flags+    result <- gst_buffer_map_range _obj' idx length_ info flags'+    let result' = (/= 0) result+    info' <- (wrapPtr MapInfo) info+    touchManagedPtr _obj+    return (result', info')++data BufferMapRangeMethodInfo+instance (signature ~ (Word32 -> Int32 -> [MapFlags] -> m (Bool,MapInfo)), MonadIO m) => MethodInfo BufferMapRangeMethodInfo Buffer signature where+    overloadedMethod _ = bufferMapRange++-- method Buffer::memcmp+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_memcmp" gst_buffer_memcmp :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word64 ->                               -- offset : TBasicType TUInt64+    Ptr Word8 ->                            -- mem : TCArray False (-1) 3 (TBasicType TUInt8)+    Word64 ->                               -- size : TBasicType TUInt64+    IO Int32+++bufferMemcmp ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word64                               -- offset+    -> ByteString                           -- mem+    -> m Int32                              -- result+bufferMemcmp _obj offset mem = liftIO $ do+    let size = fromIntegral $ B.length mem+    let _obj' = unsafeManagedPtrGetPtr _obj+    mem' <- packByteString mem+    result <- gst_buffer_memcmp _obj' offset mem' size+    touchManagedPtr _obj+    freeMem mem'+    return result++data BufferMemcmpMethodInfo+instance (signature ~ (Word64 -> ByteString -> m Int32), MonadIO m) => MethodInfo BufferMemcmpMethodInfo Buffer signature where+    overloadedMethod _ = bufferMemcmp++-- method Buffer::memset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_memset" gst_buffer_memset :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word8 ->                                -- val : TBasicType TUInt8+    Word64 ->                               -- size : TBasicType TUInt64+    IO Word64+++bufferMemset ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word64                               -- offset+    -> Word8                                -- val+    -> Word64                               -- size+    -> m Word64                             -- result+bufferMemset _obj offset val size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_memset _obj' offset val size+    touchManagedPtr _obj+    return result++data BufferMemsetMethodInfo+instance (signature ~ (Word64 -> Word8 -> Word64 -> m Word64), MonadIO m) => MethodInfo BufferMemsetMethodInfo Buffer signature where+    overloadedMethod _ = bufferMemset++-- method Buffer::n_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_n_memory" gst_buffer_n_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    IO Word32+++bufferNMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> m Word32                             -- result+bufferNMemory _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_n_memory _obj'+    touchManagedPtr _obj+    return result++data BufferNMemoryMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo BufferNMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferNMemory++-- method Buffer::peek_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_peek_memory" gst_buffer_peek_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    IO (Ptr Memory)+++bufferPeekMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> m Memory                             -- result+bufferPeekMemory _obj idx = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_peek_memory _obj' idx+    checkUnexpectedReturnNULL "gst_buffer_peek_memory" result+    result' <- (newBoxed Memory) result+    touchManagedPtr _obj+    return result'++data BufferPeekMemoryMethodInfo+instance (signature ~ (Word32 -> m Memory), MonadIO m) => MethodInfo BufferPeekMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferPeekMemory++-- method Buffer::prepend_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_prepend_memory" gst_buffer_prepend_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"+    IO ()+++bufferPrependMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Memory                               -- mem+    -> m ()                                 -- result+bufferPrependMemory _obj mem = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mem' <- copyBoxed mem+    gst_buffer_prepend_memory _obj' mem'+    touchManagedPtr _obj+    touchManagedPtr mem+    return ()++data BufferPrependMemoryMethodInfo+instance (signature ~ (Memory -> m ()), MonadIO m) => MethodInfo BufferPrependMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferPrependMemory++-- method Buffer::remove_all_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_remove_all_memory" gst_buffer_remove_all_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    IO ()+++bufferRemoveAllMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> m ()                                 -- result+bufferRemoveAllMemory _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_buffer_remove_all_memory _obj'+    touchManagedPtr _obj+    return ()++data BufferRemoveAllMemoryMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo BufferRemoveAllMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferRemoveAllMemory++-- method Buffer::remove_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_remove_memory" gst_buffer_remove_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    IO ()+++bufferRemoveMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> m ()                                 -- result+bufferRemoveMemory _obj idx = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_buffer_remove_memory _obj' idx+    touchManagedPtr _obj+    return ()++data BufferRemoveMemoryMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo BufferRemoveMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferRemoveMemory++-- method Buffer::remove_memory_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_remove_memory_range" gst_buffer_remove_memory_range :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Int32 ->                                -- length : TBasicType TInt32+    IO ()+++bufferRemoveMemoryRange ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Int32                                -- length_+    -> m ()                                 -- result+bufferRemoveMemoryRange _obj idx length_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_buffer_remove_memory_range _obj' idx length_+    touchManagedPtr _obj+    return ()++data BufferRemoveMemoryRangeMethodInfo+instance (signature ~ (Word32 -> Int32 -> m ()), MonadIO m) => MethodInfo BufferRemoveMemoryRangeMethodInfo Buffer signature where+    overloadedMethod _ = bufferRemoveMemoryRange++-- method Buffer::remove_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "meta", argType = TInterface "Gst" "Meta", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_remove_meta" gst_buffer_remove_meta :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Meta ->                             -- meta : TInterface "Gst" "Meta"+    IO CInt+++bufferRemoveMeta ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Meta                                 -- meta+    -> m Bool                               -- result+bufferRemoveMeta _obj meta = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let meta' = unsafeManagedPtrGetPtr meta+    result <- gst_buffer_remove_meta _obj' meta'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr meta+    return result'++data BufferRemoveMetaMethodInfo+instance (signature ~ (Meta -> m Bool), MonadIO m) => MethodInfo BufferRemoveMetaMethodInfo Buffer signature where+    overloadedMethod _ = bufferRemoveMeta++-- method Buffer::replace_all_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_replace_all_memory" gst_buffer_replace_all_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"+    IO ()+++bufferReplaceAllMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Memory                               -- mem+    -> m ()                                 -- result+bufferReplaceAllMemory _obj mem = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mem' <- copyBoxed mem+    gst_buffer_replace_all_memory _obj' mem'+    touchManagedPtr _obj+    touchManagedPtr mem+    return ()++data BufferReplaceAllMemoryMethodInfo+instance (signature ~ (Memory -> m ()), MonadIO m) => MethodInfo BufferReplaceAllMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferReplaceAllMemory++-- method Buffer::replace_memory+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_replace_memory" gst_buffer_replace_memory :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"+    IO ()+++bufferReplaceMemory ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Memory                               -- mem+    -> m ()                                 -- result+bufferReplaceMemory _obj idx mem = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mem' <- copyBoxed mem+    gst_buffer_replace_memory _obj' idx mem'+    touchManagedPtr _obj+    touchManagedPtr mem+    return ()++data BufferReplaceMemoryMethodInfo+instance (signature ~ (Word32 -> Memory -> m ()), MonadIO m) => MethodInfo BufferReplaceMemoryMethodInfo Buffer signature where+    overloadedMethod _ = bufferReplaceMemory++-- method Buffer::replace_memory_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_replace_memory_range" gst_buffer_replace_memory_range :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Int32 ->                                -- length : TBasicType TInt32+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"+    IO ()+++bufferReplaceMemoryRange ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Int32                                -- length_+    -> Memory                               -- mem+    -> m ()                                 -- result+bufferReplaceMemoryRange _obj idx length_ mem = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mem' <- copyBoxed mem+    gst_buffer_replace_memory_range _obj' idx length_ mem'+    touchManagedPtr _obj+    touchManagedPtr mem+    return ()++data BufferReplaceMemoryRangeMethodInfo+instance (signature ~ (Word32 -> Int32 -> Memory -> m ()), MonadIO m) => MethodInfo BufferReplaceMemoryRangeMethodInfo Buffer signature where+    overloadedMethod _ = bufferReplaceMemoryRange++-- method Buffer::resize+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_resize" gst_buffer_resize :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Int64 ->                                -- offset : TBasicType TInt64+    Int64 ->                                -- size : TBasicType TInt64+    IO ()+++bufferResize ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Int64                                -- offset+    -> Int64                                -- size+    -> m ()                                 -- result+bufferResize _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_buffer_resize _obj' offset size+    touchManagedPtr _obj+    return ()++data BufferResizeMethodInfo+instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo BufferResizeMethodInfo Buffer signature where+    overloadedMethod _ = bufferResize++-- method Buffer::resize_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_resize_range" gst_buffer_resize_range :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Word32 ->                               -- idx : TBasicType TUInt32+    Int32 ->                                -- length : TBasicType TInt32+    Int64 ->                                -- offset : TBasicType TInt64+    Int64 ->                                -- size : TBasicType TInt64+    IO CInt+++bufferResizeRange ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Word32                               -- idx+    -> Int32                                -- length_+    -> Int64                                -- offset+    -> Int64                                -- size+    -> m Bool                               -- result+bufferResizeRange _obj idx length_ offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_resize_range _obj' idx length_ offset size+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data BufferResizeRangeMethodInfo+instance (signature ~ (Word32 -> Int32 -> Int64 -> Int64 -> m Bool), MonadIO m) => MethodInfo BufferResizeRangeMethodInfo Buffer signature where+    overloadedMethod _ = bufferResizeRange++-- method Buffer::set_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_set_size" gst_buffer_set_size :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Int64 ->                                -- size : TBasicType TInt64+    IO ()+++bufferSetSize ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> Int64                                -- size+    -> m ()                                 -- result+bufferSetSize _obj size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_buffer_set_size _obj' size+    touchManagedPtr _obj+    return ()++data BufferSetSizeMethodInfo+instance (signature ~ (Int64 -> m ()), MonadIO m) => MethodInfo BufferSetSizeMethodInfo Buffer signature where+    overloadedMethod _ = bufferSetSize++-- method Buffer::unmap+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_unmap" gst_buffer_unmap :: +    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"+    IO ()+++bufferUnmap ::+    (MonadIO m) =>+    Buffer                                  -- _obj+    -> MapInfo                              -- info+    -> m ()                                 -- result+bufferUnmap _obj info = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let info' = unsafeManagedPtrGetPtr info+    gst_buffer_unmap _obj' info'+    touchManagedPtr _obj+    touchManagedPtr info+    return ()++data BufferUnmapMethodInfo+instance (signature ~ (MapInfo -> m ()), MonadIO m) => MethodInfo BufferUnmapMethodInfo Buffer signature where+    overloadedMethod _ = bufferUnmap++-- method Buffer::get_max_memory+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_get_max_memory" gst_buffer_get_max_memory :: +    IO Word32+++bufferGetMaxMemory ::+    (MonadIO m) =>+    m Word32                                -- result+bufferGetMaxMemory  = liftIO $ do+    result <- gst_buffer_get_max_memory+    return result++type family ResolveBufferMethod (t :: Symbol) (o :: *) :: * where+    ResolveBufferMethod "addMeta" o = BufferAddMetaMethodInfo+    ResolveBufferMethod "addParentBufferMeta" o = BufferAddParentBufferMetaMethodInfo+    ResolveBufferMethod "addProtectionMeta" o = BufferAddProtectionMetaMethodInfo+    ResolveBufferMethod "append" o = BufferAppendMethodInfo+    ResolveBufferMethod "appendMemory" o = BufferAppendMemoryMethodInfo+    ResolveBufferMethod "appendRegion" o = BufferAppendRegionMethodInfo+    ResolveBufferMethod "copyDeep" o = BufferCopyDeepMethodInfo+    ResolveBufferMethod "copyInto" o = BufferCopyIntoMethodInfo+    ResolveBufferMethod "copyRegion" o = BufferCopyRegionMethodInfo+    ResolveBufferMethod "extract" o = BufferExtractMethodInfo+    ResolveBufferMethod "extractDup" o = BufferExtractDupMethodInfo+    ResolveBufferMethod "fill" o = BufferFillMethodInfo+    ResolveBufferMethod "findMemory" o = BufferFindMemoryMethodInfo+    ResolveBufferMethod "foreachMeta" o = BufferForeachMetaMethodInfo+    ResolveBufferMethod "insertMemory" o = BufferInsertMemoryMethodInfo+    ResolveBufferMethod "isAllMemoryWritable" o = BufferIsAllMemoryWritableMethodInfo+    ResolveBufferMethod "isMemoryRangeWritable" o = BufferIsMemoryRangeWritableMethodInfo+    ResolveBufferMethod "iterateMeta" o = BufferIterateMetaMethodInfo+    ResolveBufferMethod "map" o = BufferMapMethodInfo+    ResolveBufferMethod "mapRange" o = BufferMapRangeMethodInfo+    ResolveBufferMethod "memcmp" o = BufferMemcmpMethodInfo+    ResolveBufferMethod "memset" o = BufferMemsetMethodInfo+    ResolveBufferMethod "nMemory" o = BufferNMemoryMethodInfo+    ResolveBufferMethod "peekMemory" o = BufferPeekMemoryMethodInfo+    ResolveBufferMethod "prependMemory" o = BufferPrependMemoryMethodInfo+    ResolveBufferMethod "removeAllMemory" o = BufferRemoveAllMemoryMethodInfo+    ResolveBufferMethod "removeMemory" o = BufferRemoveMemoryMethodInfo+    ResolveBufferMethod "removeMemoryRange" o = BufferRemoveMemoryRangeMethodInfo+    ResolveBufferMethod "removeMeta" o = BufferRemoveMetaMethodInfo+    ResolveBufferMethod "replaceAllMemory" o = BufferReplaceAllMemoryMethodInfo+    ResolveBufferMethod "replaceMemory" o = BufferReplaceMemoryMethodInfo+    ResolveBufferMethod "replaceMemoryRange" o = BufferReplaceMemoryRangeMethodInfo+    ResolveBufferMethod "resize" o = BufferResizeMethodInfo+    ResolveBufferMethod "resizeRange" o = BufferResizeRangeMethodInfo+    ResolveBufferMethod "unmap" o = BufferUnmapMethodInfo+    ResolveBufferMethod "getAllMemory" o = BufferGetAllMemoryMethodInfo+    ResolveBufferMethod "getMemory" o = BufferGetMemoryMethodInfo+    ResolveBufferMethod "getMemoryRange" o = BufferGetMemoryRangeMethodInfo+    ResolveBufferMethod "getMeta" o = BufferGetMetaMethodInfo+    ResolveBufferMethod "getSize" o = BufferGetSizeMethodInfo+    ResolveBufferMethod "getSizes" o = BufferGetSizesMethodInfo+    ResolveBufferMethod "getSizesRange" o = BufferGetSizesRangeMethodInfo+    ResolveBufferMethod "setSize" o = BufferSetSizeMethodInfo+    ResolveBufferMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveBufferMethod t Buffer, MethodInfo info Buffer p) => IsLabelProxy t (Buffer -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveBufferMethod t Buffer, MethodInfo info Buffer p) => IsLabel t (Buffer -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Buffer.hs-boot view
@@ -0,0 +1,54 @@+module GI.Gst.Structs.Buffer 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++newtype Buffer = Buffer (ForeignPtr Buffer)+instance BoxedObject Buffer where+data BufferAddMetaMethodInfo+data BufferAddParentBufferMetaMethodInfo+data BufferAddProtectionMetaMethodInfo+data BufferAppendMethodInfo+data BufferAppendMemoryMethodInfo+data BufferAppendRegionMethodInfo+data BufferCopyDeepMethodInfo+data BufferCopyIntoMethodInfo+data BufferCopyRegionMethodInfo+data BufferExtractMethodInfo+data BufferExtractDupMethodInfo+data BufferFillMethodInfo+data BufferFindMemoryMethodInfo+data BufferForeachMetaMethodInfo+data BufferGetAllMemoryMethodInfo+data BufferGetMemoryMethodInfo+data BufferGetMemoryRangeMethodInfo+data BufferGetMetaMethodInfo+data BufferGetSizeMethodInfo+data BufferGetSizesMethodInfo+data BufferGetSizesRangeMethodInfo+data BufferInsertMemoryMethodInfo+data BufferIsAllMemoryWritableMethodInfo+data BufferIsMemoryRangeWritableMethodInfo+data BufferIterateMetaMethodInfo+data BufferMapMethodInfo+data BufferMapRangeMethodInfo+data BufferMemcmpMethodInfo+data BufferMemsetMethodInfo+data BufferNMemoryMethodInfo+data BufferPeekMemoryMethodInfo+data BufferPrependMemoryMethodInfo+data BufferRemoveAllMemoryMethodInfo+data BufferRemoveMemoryMethodInfo+data BufferRemoveMemoryRangeMethodInfo+data BufferRemoveMetaMethodInfo+data BufferReplaceAllMemoryMethodInfo+data BufferReplaceMemoryMethodInfo+data BufferReplaceMemoryRangeMethodInfo+data BufferResizeMethodInfo+data BufferResizeRangeMethodInfo+data BufferSetSizeMethodInfo+data BufferUnmapMethodInfo
+ GI/Gst/Structs/BufferList.hs view
@@ -0,0 +1,335 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Buffer lists are an object containing a list of buffers.++Buffer lists are created with gst_buffer_list_new() and filled with data+using a gst_buffer_list_insert().++Buffer lists can be pushed on a srcpad with gst_pad_push_list(). This is+interesting when multiple buffers need to be pushed in one go because it+can reduce the amount of overhead for pushing each buffer individually.+-}++module GI.Gst.Structs.BufferList+    ( ++-- * Exported types+    BufferList(..)                          ,+    noBufferList                            ,+++ -- * Methods+-- ** bufferListCopyDeep+    BufferListCopyDeepMethodInfo            ,+    bufferListCopyDeep                      ,+++-- ** bufferListForeach+    BufferListForeachMethodInfo             ,+    bufferListForeach                       ,+++-- ** bufferListGet+    BufferListGetMethodInfo                 ,+    bufferListGet                           ,+++-- ** bufferListInsert+    BufferListInsertMethodInfo              ,+    bufferListInsert                        ,+++-- ** bufferListLength+    BufferListLengthMethodInfo              ,+    bufferListLength                        ,+++-- ** bufferListNew+    bufferListNew                           ,+++-- ** bufferListNewSized+    bufferListNewSized                      ,+++-- ** bufferListRemove+    BufferListRemoveMethodInfo              ,+    bufferListRemove                        ,+++++    ) 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 GI.Gst.Callbacks++newtype BufferList = BufferList (ForeignPtr BufferList)+foreign import ccall "gst_buffer_list_get_type" c_gst_buffer_list_get_type :: +    IO GType++instance BoxedObject BufferList where+    boxedType _ = c_gst_buffer_list_get_type++noBufferList :: Maybe BufferList+noBufferList = Nothing++-- method BufferList::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "BufferList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_new" gst_buffer_list_new :: +    IO (Ptr BufferList)+++bufferListNew ::+    (MonadIO m) =>+    m BufferList                            -- result+bufferListNew  = liftIO $ do+    result <- gst_buffer_list_new+    checkUnexpectedReturnNULL "gst_buffer_list_new" result+    result' <- (wrapBoxed BufferList) result+    return result'++-- method BufferList::new_sized+-- method type : Constructor+-- Args : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "BufferList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_new_sized" gst_buffer_list_new_sized :: +    Word32 ->                               -- size : TBasicType TUInt32+    IO (Ptr BufferList)+++bufferListNewSized ::+    (MonadIO m) =>+    Word32                                  -- size+    -> m BufferList                         -- result+bufferListNewSized size = liftIO $ do+    result <- gst_buffer_list_new_sized size+    checkUnexpectedReturnNULL "gst_buffer_list_new_sized" result+    result' <- (wrapBoxed BufferList) result+    return result'++-- method BufferList::copy_deep+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "BufferList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_copy_deep" gst_buffer_list_copy_deep :: +    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"+    IO (Ptr BufferList)+++bufferListCopyDeep ::+    (MonadIO m) =>+    BufferList                              -- _obj+    -> m BufferList                         -- result+bufferListCopyDeep _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_list_copy_deep _obj'+    checkUnexpectedReturnNULL "gst_buffer_list_copy_deep" result+    result' <- (wrapBoxed BufferList) result+    touchManagedPtr _obj+    return result'++data BufferListCopyDeepMethodInfo+instance (signature ~ (m BufferList), MonadIO m) => MethodInfo BufferListCopyDeepMethodInfo BufferList signature where+    overloadedMethod _ = bufferListCopyDeep++-- method BufferList::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BufferListFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_foreach" gst_buffer_list_foreach :: +    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"+    FunPtr BufferListFuncC ->               -- func : TInterface "Gst" "BufferListFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++bufferListForeach ::+    (MonadIO m) =>+    BufferList                              -- _obj+    -> BufferListFunc                       -- func+    -> m Bool                               -- result+bufferListForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkBufferListFunc (bufferListFuncWrapper Nothing func)+    let userData = nullPtr+    result <- gst_buffer_list_foreach _obj' func' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return result'++data BufferListForeachMethodInfo+instance (signature ~ (BufferListFunc -> m Bool), MonadIO m) => MethodInfo BufferListForeachMethodInfo BufferList signature where+    overloadedMethod _ = bufferListForeach++-- method BufferList::get+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_get" gst_buffer_list_get :: +    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"+    Word32 ->                               -- idx : TBasicType TUInt32+    IO (Ptr Buffer)+++bufferListGet ::+    (MonadIO m) =>+    BufferList                              -- _obj+    -> Word32                               -- idx+    -> m Buffer                             -- result+bufferListGet _obj idx = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_list_get _obj' idx+    checkUnexpectedReturnNULL "gst_buffer_list_get" result+    result' <- (newBoxed Buffer) result+    touchManagedPtr _obj+    return result'++data BufferListGetMethodInfo+instance (signature ~ (Word32 -> m Buffer), MonadIO m) => MethodInfo BufferListGetMethodInfo BufferList signature where+    overloadedMethod _ = bufferListGet++-- method BufferList::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_insert" gst_buffer_list_insert :: +    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"+    Int32 ->                                -- idx : TBasicType TInt32+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    IO ()+++bufferListInsert ::+    (MonadIO m) =>+    BufferList                              -- _obj+    -> Int32                                -- idx+    -> Buffer                               -- buffer+    -> m ()                                 -- result+bufferListInsert _obj idx buffer = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    buffer' <- copyBoxed buffer+    gst_buffer_list_insert _obj' idx buffer'+    touchManagedPtr _obj+    touchManagedPtr buffer+    return ()++data BufferListInsertMethodInfo+instance (signature ~ (Int32 -> Buffer -> m ()), MonadIO m) => MethodInfo BufferListInsertMethodInfo BufferList signature where+    overloadedMethod _ = bufferListInsert++-- method BufferList::length+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_length" gst_buffer_list_length :: +    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"+    IO Word32+++bufferListLength ::+    (MonadIO m) =>+    BufferList                              -- _obj+    -> m Word32                             -- result+bufferListLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_buffer_list_length _obj'+    touchManagedPtr _obj+    return result++data BufferListLengthMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo BufferListLengthMethodInfo BufferList signature where+    overloadedMethod _ = bufferListLength++-- method BufferList::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_buffer_list_remove" gst_buffer_list_remove :: +    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"+    Word32 ->                               -- idx : TBasicType TUInt32+    Word32 ->                               -- length : TBasicType TUInt32+    IO ()+++bufferListRemove ::+    (MonadIO m) =>+    BufferList                              -- _obj+    -> Word32                               -- idx+    -> Word32                               -- length_+    -> m ()                                 -- result+bufferListRemove _obj idx length_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_buffer_list_remove _obj' idx length_+    touchManagedPtr _obj+    return ()++data BufferListRemoveMethodInfo+instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo BufferListRemoveMethodInfo BufferList signature where+    overloadedMethod _ = bufferListRemove++type family ResolveBufferListMethod (t :: Symbol) (o :: *) :: * where+    ResolveBufferListMethod "copyDeep" o = BufferListCopyDeepMethodInfo+    ResolveBufferListMethod "foreach" o = BufferListForeachMethodInfo+    ResolveBufferListMethod "get" o = BufferListGetMethodInfo+    ResolveBufferListMethod "insert" o = BufferListInsertMethodInfo+    ResolveBufferListMethod "length" o = BufferListLengthMethodInfo+    ResolveBufferListMethod "remove" o = BufferListRemoveMethodInfo+    ResolveBufferListMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveBufferListMethod t BufferList, MethodInfo info BufferList p) => IsLabelProxy t (BufferList -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveBufferListMethod t BufferList, MethodInfo info BufferList p) => IsLabel t (BufferList -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/BufferList.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gst.Structs.BufferList 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++newtype BufferList = BufferList (ForeignPtr BufferList)+instance BoxedObject BufferList where+data BufferListCopyDeepMethodInfo+data BufferListForeachMethodInfo+data BufferListGetMethodInfo+data BufferListInsertMethodInfo+data BufferListLengthMethodInfo+data BufferListRemoveMethodInfo
+ GI/Gst/Structs/BufferPoolAcquireParams.hs view
@@ -0,0 +1,97 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Parameters passed to the gst_buffer_pool_acquire_buffer() function to control the+allocation of the buffer.++The default implementation ignores the @start and @stop members but other+implementations can use this extra information to decide what buffer to+return.+-}++module GI.Gst.Structs.BufferPoolAcquireParams+    ( ++-- * Exported types+    BufferPoolAcquireParams(..)             ,+    newZeroBufferPoolAcquireParams          ,+    noBufferPoolAcquireParams               ,+++ -- * Properties+-- ** Flags+    bufferPoolAcquireParamsReadFlags        ,+++-- ** Format+    bufferPoolAcquireParamsReadFormat       ,+++-- ** Start+    bufferPoolAcquireParamsReadStart        ,+++-- ** Stop+    bufferPoolAcquireParamsReadStop         ,+++++    ) 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 GI.Gst.Callbacks++newtype BufferPoolAcquireParams = BufferPoolAcquireParams (ForeignPtr BufferPoolAcquireParams)+-- | Construct a `BufferPoolAcquireParams` struct initialized to zero.+newZeroBufferPoolAcquireParams :: MonadIO m => m BufferPoolAcquireParams+newZeroBufferPoolAcquireParams = liftIO $ callocBytes 64 >>= wrapPtr BufferPoolAcquireParams++noBufferPoolAcquireParams :: Maybe BufferPoolAcquireParams+noBufferPoolAcquireParams = Nothing++bufferPoolAcquireParamsReadFormat :: BufferPoolAcquireParams -> IO Format+bufferPoolAcquireParamsReadFormat s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++bufferPoolAcquireParamsReadStart :: BufferPoolAcquireParams -> IO Int64+bufferPoolAcquireParamsReadStart s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Int64+    return val++bufferPoolAcquireParamsReadStop :: BufferPoolAcquireParams -> IO Int64+bufferPoolAcquireParamsReadStop s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Int64+    return val++bufferPoolAcquireParamsReadFlags :: BufferPoolAcquireParams -> IO [BufferPoolAcquireFlags]+bufferPoolAcquireParamsReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CUInt+    let val' = wordToGFlags val+    return val'++type family ResolveBufferPoolAcquireParamsMethod (t :: Symbol) (o :: *) :: * where+    ResolveBufferPoolAcquireParamsMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveBufferPoolAcquireParamsMethod t BufferPoolAcquireParams, MethodInfo info BufferPoolAcquireParams p) => IsLabelProxy t (BufferPoolAcquireParams -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveBufferPoolAcquireParamsMethod t BufferPoolAcquireParams, MethodInfo info BufferPoolAcquireParams p) => IsLabel t (BufferPoolAcquireParams -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/BufferPoolAcquireParams.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.BufferPoolAcquireParams 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++newtype BufferPoolAcquireParams = BufferPoolAcquireParams (ForeignPtr BufferPoolAcquireParams)
+ GI/Gst/Structs/Caps.hs view
@@ -0,0 +1,1587 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Caps (capabilities) are lightweight refcounted objects describing media types.+They are composed of an array of #GstStructure.++Caps are exposed on #GstPadTemplate to describe all possible types a+given pad can handle. They are also stored in the #GstRegistry along with+a description of the #GstElement.++Caps are exposed on the element pads using the gst_pad_query_caps() pad+function. This function describes the possible types that the pad can+handle or produce at runtime.++A #GstCaps can be constructed with the following code fragment:+|[+  GstCaps *caps = gst_caps_new_simple ("video/x-raw",+     "format", G_TYPE_STRING, "I420",+     "framerate", GST_TYPE_FRACTION, 25, 1,+     "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1,+     "width", G_TYPE_INT, 320,+     "height", G_TYPE_INT, 240,+     NULL);+]|++A #GstCaps is fixed when it has no properties with ranges or lists. Use+gst_caps_is_fixed() to test for fixed caps. Fixed caps can be used in a+caps event to notify downstream elements of the current media type.++Various methods exist to work with the media types such as subtracting+or intersecting.++Be aware that the current #GstCaps / #GstStructure serialization into string+has limited support for nested #GstCaps / #GstStructure fields. It can only+support one level of nesting. Using more levels will lead to unexpected+behavior when using serialization features, such as gst_caps_to_string() or+gst_value_serialize() and their counterparts.+-}++module GI.Gst.Structs.Caps+    ( ++-- * Exported types+    Caps(..)                                ,+    newZeroCaps                             ,+    noCaps                                  ,+++ -- * Methods+-- ** capsAppend+    CapsAppendMethodInfo                    ,+    capsAppend                              ,+++-- ** capsAppendStructure+    CapsAppendStructureMethodInfo           ,+    capsAppendStructure                     ,+++-- ** capsAppendStructureFull+    CapsAppendStructureFullMethodInfo       ,+    capsAppendStructureFull                 ,+++-- ** capsCanIntersect+    CapsCanIntersectMethodInfo              ,+    capsCanIntersect                        ,+++-- ** capsCopyNth+    CapsCopyNthMethodInfo                   ,+    capsCopyNth                             ,+++-- ** capsFilterAndMapInPlace+    CapsFilterAndMapInPlaceMethodInfo       ,+    capsFilterAndMapInPlace                 ,+++-- ** capsFixate+    CapsFixateMethodInfo                    ,+    capsFixate                              ,+++-- ** capsForeach+    CapsForeachMethodInfo                   ,+    capsForeach                             ,+++-- ** capsFromString+    capsFromString                          ,+++-- ** capsGetFeatures+    CapsGetFeaturesMethodInfo               ,+    capsGetFeatures                         ,+++-- ** capsGetSize+    CapsGetSizeMethodInfo                   ,+    capsGetSize                             ,+++-- ** capsGetStructure+    CapsGetStructureMethodInfo              ,+    capsGetStructure                        ,+++-- ** capsIntersect+    CapsIntersectMethodInfo                 ,+    capsIntersect                           ,+++-- ** capsIntersectFull+    CapsIntersectFullMethodInfo             ,+    capsIntersectFull                       ,+++-- ** capsIsAlwaysCompatible+    CapsIsAlwaysCompatibleMethodInfo        ,+    capsIsAlwaysCompatible                  ,+++-- ** capsIsAny+    CapsIsAnyMethodInfo                     ,+    capsIsAny                               ,+++-- ** capsIsEmpty+    CapsIsEmptyMethodInfo                   ,+    capsIsEmpty                             ,+++-- ** capsIsEqual+    CapsIsEqualMethodInfo                   ,+    capsIsEqual                             ,+++-- ** capsIsEqualFixed+    CapsIsEqualFixedMethodInfo              ,+    capsIsEqualFixed                        ,+++-- ** capsIsFixed+    CapsIsFixedMethodInfo                   ,+    capsIsFixed                             ,+++-- ** capsIsStrictlyEqual+    CapsIsStrictlyEqualMethodInfo           ,+    capsIsStrictlyEqual                     ,+++-- ** capsIsSubset+    CapsIsSubsetMethodInfo                  ,+    capsIsSubset                            ,+++-- ** capsIsSubsetStructure+    CapsIsSubsetStructureMethodInfo         ,+    capsIsSubsetStructure                   ,+++-- ** capsIsSubsetStructureFull+    CapsIsSubsetStructureFullMethodInfo     ,+    capsIsSubsetStructureFull               ,+++-- ** capsMapInPlace+    CapsMapInPlaceMethodInfo                ,+    capsMapInPlace                          ,+++-- ** capsMerge+    CapsMergeMethodInfo                     ,+    capsMerge                               ,+++-- ** capsMergeStructure+    CapsMergeStructureMethodInfo            ,+    capsMergeStructure                      ,+++-- ** capsMergeStructureFull+    CapsMergeStructureFullMethodInfo        ,+    capsMergeStructureFull                  ,+++-- ** capsNewAny+    capsNewAny                              ,+++-- ** capsNewEmpty+    capsNewEmpty                            ,+++-- ** capsNewEmptySimple+    capsNewEmptySimple                      ,+++-- ** capsNormalize+    CapsNormalizeMethodInfo                 ,+    capsNormalize                           ,+++-- ** capsRemoveStructure+    CapsRemoveStructureMethodInfo           ,+    capsRemoveStructure                     ,+++-- ** capsSetFeatures+    CapsSetFeaturesMethodInfo               ,+    capsSetFeatures                         ,+++-- ** capsSetValue+    CapsSetValueMethodInfo                  ,+    capsSetValue                            ,+++-- ** capsSimplify+    CapsSimplifyMethodInfo                  ,+    capsSimplify                            ,+++-- ** capsStealStructure+    CapsStealStructureMethodInfo            ,+    capsStealStructure                      ,+++-- ** capsSubtract+    CapsSubtractMethodInfo                  ,+    capsSubtract                            ,+++-- ** capsToString+    CapsToStringMethodInfo                  ,+    capsToString                            ,+++-- ** capsTruncate+    CapsTruncateMethodInfo                  ,+    capsTruncate                            ,+++++ -- * Properties+-- ** MiniObject+    capsReadMiniObject                      ,+++++    ) 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 GI.Gst.Callbacks++newtype Caps = Caps (ForeignPtr Caps)+foreign import ccall "gst_caps_get_type" c_gst_caps_get_type :: +    IO GType++instance BoxedObject Caps where+    boxedType _ = c_gst_caps_get_type++-- | Construct a `Caps` struct initialized to zero.+newZeroCaps :: MonadIO m => m Caps+newZeroCaps = liftIO $ callocBoxedBytes 64 >>= wrapBoxed Caps++noCaps :: Maybe Caps+noCaps = Nothing++capsReadMiniObject :: Caps -> IO MiniObject+capsReadMiniObject s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)+    val' <- (newPtr 64 MiniObject) val+    return val'++-- method Caps::new_any+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_new_any" gst_caps_new_any :: +    IO (Ptr Caps)+++capsNewAny ::+    (MonadIO m) =>+    m Caps                                  -- result+capsNewAny  = liftIO $ do+    result <- gst_caps_new_any+    checkUnexpectedReturnNULL "gst_caps_new_any" result+    result' <- (wrapBoxed Caps) result+    return result'++-- method Caps::new_empty+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_new_empty" gst_caps_new_empty :: +    IO (Ptr Caps)+++capsNewEmpty ::+    (MonadIO m) =>+    m Caps                                  -- result+capsNewEmpty  = liftIO $ do+    result <- gst_caps_new_empty+    checkUnexpectedReturnNULL "gst_caps_new_empty" result+    result' <- (wrapBoxed Caps) result+    return result'++-- method Caps::new_empty_simple+-- method type : Constructor+-- Args : [Arg {argCName = "media_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_new_empty_simple" gst_caps_new_empty_simple :: +    CString ->                              -- media_type : TBasicType TUTF8+    IO (Ptr Caps)+++capsNewEmptySimple ::+    (MonadIO m) =>+    T.Text                                  -- mediaType+    -> m Caps                               -- result+capsNewEmptySimple mediaType = liftIO $ do+    mediaType' <- textToCString mediaType+    result <- gst_caps_new_empty_simple mediaType'+    checkUnexpectedReturnNULL "gst_caps_new_empty_simple" result+    result' <- (wrapBoxed Caps) result+    freeMem mediaType'+    return result'++-- method Caps::append+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_append" gst_caps_append :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO ()+++capsAppend ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m ()                                 -- result+capsAppend _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    caps2' <- copyBoxed caps2+    gst_caps_append _obj' caps2'+    touchManagedPtr _obj+    touchManagedPtr caps2+    return ()++data CapsAppendMethodInfo+instance (signature ~ (Caps -> m ()), MonadIO m) => MethodInfo CapsAppendMethodInfo Caps signature where+    overloadedMethod _ = capsAppend++-- method Caps::append_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_append_structure" gst_caps_append_structure :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO ()+++capsAppendStructure ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Structure                            -- structure+    -> m ()                                 -- result+capsAppendStructure _obj structure = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    structure' <- copyBoxed structure+    gst_caps_append_structure _obj' structure'+    touchManagedPtr _obj+    touchManagedPtr structure+    return ()++data CapsAppendStructureMethodInfo+instance (signature ~ (Structure -> m ()), MonadIO m) => MethodInfo CapsAppendStructureMethodInfo Caps signature where+    overloadedMethod _ = capsAppendStructure++-- method Caps::append_structure_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_append_structure_full" gst_caps_append_structure_full :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"+    IO ()+++capsAppendStructureFull ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Structure                            -- structure+    -> Maybe (CapsFeatures)                 -- features+    -> m ()                                 -- result+capsAppendStructureFull _obj structure features = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    structure' <- copyBoxed structure+    maybeFeatures <- case features of+        Nothing -> return nullPtr+        Just jFeatures -> do+            jFeatures' <- copyBoxed jFeatures+            return jFeatures'+    gst_caps_append_structure_full _obj' structure' maybeFeatures+    touchManagedPtr _obj+    touchManagedPtr structure+    whenJust features touchManagedPtr+    return ()++data CapsAppendStructureFullMethodInfo+instance (signature ~ (Structure -> Maybe (CapsFeatures) -> m ()), MonadIO m) => MethodInfo CapsAppendStructureFullMethodInfo Caps signature where+    overloadedMethod _ = capsAppendStructureFull++-- method Caps::can_intersect+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_can_intersect" gst_caps_can_intersect :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO CInt+++capsCanIntersect ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m Bool                               -- result+capsCanIntersect _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps2' = unsafeManagedPtrGetPtr caps2+    result <- gst_caps_can_intersect _obj' caps2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsCanIntersectMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsCanIntersectMethodInfo Caps signature where+    overloadedMethod _ = capsCanIntersect++-- method Caps::copy_nth+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nth", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_copy_nth" gst_caps_copy_nth :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Word32 ->                               -- nth : TBasicType TUInt32+    IO (Ptr Caps)+++capsCopyNth ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Word32                               -- nth+    -> m Caps                               -- result+capsCopyNth _obj nth = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_copy_nth _obj' nth+    checkUnexpectedReturnNULL "gst_caps_copy_nth" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data CapsCopyNthMethodInfo+instance (signature ~ (Word32 -> m Caps), MonadIO m) => MethodInfo CapsCopyNthMethodInfo Caps signature where+    overloadedMethod _ = capsCopyNth++-- method Caps::filter_and_map_in_place+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "CapsFilterMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_filter_and_map_in_place" gst_caps_filter_and_map_in_place :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    FunPtr CapsFilterMapFuncC ->            -- func : TInterface "Gst" "CapsFilterMapFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++capsFilterAndMapInPlace ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> CapsFilterMapFunc                    -- func+    -> m ()                                 -- result+capsFilterAndMapInPlace _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkCapsFilterMapFunc (capsFilterMapFuncWrapper Nothing func)+    let userData = nullPtr+    gst_caps_filter_and_map_in_place _obj' func' userData+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++data CapsFilterAndMapInPlaceMethodInfo+instance (signature ~ (CapsFilterMapFunc -> m ()), MonadIO m) => MethodInfo CapsFilterAndMapInPlaceMethodInfo Caps signature where+    overloadedMethod _ = capsFilterAndMapInPlace++-- method Caps::fixate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_fixate" gst_caps_fixate :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++capsFixate ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Caps                               -- result+capsFixate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_fixate _obj'+    checkUnexpectedReturnNULL "gst_caps_fixate" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data CapsFixateMethodInfo+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsFixateMethodInfo Caps signature where+    overloadedMethod _ = capsFixate++-- method Caps::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "CapsForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_foreach" gst_caps_foreach :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    FunPtr CapsForeachFuncC ->              -- func : TInterface "Gst" "CapsForeachFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++capsForeach ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> CapsForeachFunc                      -- func+    -> m Bool                               -- result+capsForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkCapsForeachFunc (capsForeachFuncWrapper Nothing func)+    let userData = nullPtr+    result <- gst_caps_foreach _obj' func' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return result'++data CapsForeachMethodInfo+instance (signature ~ (CapsForeachFunc -> m Bool), MonadIO m) => MethodInfo CapsForeachMethodInfo Caps signature where+    overloadedMethod _ = capsForeach++-- method Caps::get_features+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "CapsFeatures"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_get_features" gst_caps_get_features :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Word32 ->                               -- index : TBasicType TUInt32+    IO (Ptr CapsFeatures)+++capsGetFeatures ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Word32                               -- index+    -> m CapsFeatures                       -- result+capsGetFeatures _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_get_features _obj' index+    checkUnexpectedReturnNULL "gst_caps_get_features" result+    result' <- (newBoxed CapsFeatures) result+    touchManagedPtr _obj+    return result'++data CapsGetFeaturesMethodInfo+instance (signature ~ (Word32 -> m CapsFeatures), MonadIO m) => MethodInfo CapsGetFeaturesMethodInfo Caps signature where+    overloadedMethod _ = capsGetFeatures++-- method Caps::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_get_size" gst_caps_get_size :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO Word32+++capsGetSize ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Word32                             -- result+capsGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_get_size _obj'+    touchManagedPtr _obj+    return result++data CapsGetSizeMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo CapsGetSizeMethodInfo Caps signature where+    overloadedMethod _ = capsGetSize++-- method Caps::get_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_get_structure" gst_caps_get_structure :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Word32 ->                               -- index : TBasicType TUInt32+    IO (Ptr Structure)+++capsGetStructure ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Word32                               -- index+    -> m Structure                          -- result+capsGetStructure _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_get_structure _obj' index+    checkUnexpectedReturnNULL "gst_caps_get_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data CapsGetStructureMethodInfo+instance (signature ~ (Word32 -> m Structure), MonadIO m) => MethodInfo CapsGetStructureMethodInfo Caps signature where+    overloadedMethod _ = capsGetStructure++-- method Caps::intersect+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_intersect" gst_caps_intersect :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++capsIntersect ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m Caps                               -- result+capsIntersect _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps2' = unsafeManagedPtrGetPtr caps2+    result <- gst_caps_intersect _obj' caps2'+    checkUnexpectedReturnNULL "gst_caps_intersect" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsIntersectMethodInfo+instance (signature ~ (Caps -> m Caps), MonadIO m) => MethodInfo CapsIntersectMethodInfo Caps signature where+    overloadedMethod _ = capsIntersect++-- method Caps::intersect_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "CapsIntersectMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_intersect_full" gst_caps_intersect_full :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    CUInt ->                                -- mode : TInterface "Gst" "CapsIntersectMode"+    IO (Ptr Caps)+++capsIntersectFull ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> CapsIntersectMode                    -- mode+    -> m Caps                               -- result+capsIntersectFull _obj caps2 mode = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps2' = unsafeManagedPtrGetPtr caps2+    let mode' = (fromIntegral . fromEnum) mode+    result <- gst_caps_intersect_full _obj' caps2' mode'+    checkUnexpectedReturnNULL "gst_caps_intersect_full" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsIntersectFullMethodInfo+instance (signature ~ (Caps -> CapsIntersectMode -> m Caps), MonadIO m) => MethodInfo CapsIntersectFullMethodInfo Caps signature where+    overloadedMethod _ = capsIntersectFull++-- method Caps::is_always_compatible+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_always_compatible" gst_caps_is_always_compatible :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO CInt+++capsIsAlwaysCompatible ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m Bool                               -- result+capsIsAlwaysCompatible _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps2' = unsafeManagedPtrGetPtr caps2+    result <- gst_caps_is_always_compatible _obj' caps2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsIsAlwaysCompatibleMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsAlwaysCompatibleMethodInfo Caps signature where+    overloadedMethod _ = capsIsAlwaysCompatible++-- method Caps::is_any+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_any" gst_caps_is_any :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO CInt+++capsIsAny ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Bool                               -- result+capsIsAny _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_is_any _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data CapsIsAnyMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsIsAnyMethodInfo Caps signature where+    overloadedMethod _ = capsIsAny++-- method Caps::is_empty+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_empty" gst_caps_is_empty :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO CInt+++capsIsEmpty ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Bool                               -- result+capsIsEmpty _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_is_empty _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data CapsIsEmptyMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsIsEmptyMethodInfo Caps signature where+    overloadedMethod _ = capsIsEmpty++-- method Caps::is_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_equal" gst_caps_is_equal :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO CInt+++capsIsEqual ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m Bool                               -- result+capsIsEqual _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps2' = unsafeManagedPtrGetPtr caps2+    result <- gst_caps_is_equal _obj' caps2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsIsEqualMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsEqualMethodInfo Caps signature where+    overloadedMethod _ = capsIsEqual++-- method Caps::is_equal_fixed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_equal_fixed" gst_caps_is_equal_fixed :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO CInt+++capsIsEqualFixed ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m Bool                               -- result+capsIsEqualFixed _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps2' = unsafeManagedPtrGetPtr caps2+    result <- gst_caps_is_equal_fixed _obj' caps2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsIsEqualFixedMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsEqualFixedMethodInfo Caps signature where+    overloadedMethod _ = capsIsEqualFixed++-- method Caps::is_fixed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_fixed" gst_caps_is_fixed :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO CInt+++capsIsFixed ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Bool                               -- result+capsIsFixed _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_is_fixed _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data CapsIsFixedMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsIsFixedMethodInfo Caps signature where+    overloadedMethod _ = capsIsFixed++-- method Caps::is_strictly_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_strictly_equal" gst_caps_is_strictly_equal :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO CInt+++capsIsStrictlyEqual ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m Bool                               -- result+capsIsStrictlyEqual _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps2' = unsafeManagedPtrGetPtr caps2+    result <- gst_caps_is_strictly_equal _obj' caps2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsIsStrictlyEqualMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsStrictlyEqualMethodInfo Caps signature where+    overloadedMethod _ = capsIsStrictlyEqual++-- method Caps::is_subset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "superset", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_subset" gst_caps_is_subset :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- superset : TInterface "Gst" "Caps"+    IO CInt+++capsIsSubset ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- superset+    -> m Bool                               -- result+capsIsSubset _obj superset = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let superset' = unsafeManagedPtrGetPtr superset+    result <- gst_caps_is_subset _obj' superset'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr superset+    return result'++data CapsIsSubsetMethodInfo+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsSubsetMethodInfo Caps signature where+    overloadedMethod _ = capsIsSubset++-- method Caps::is_subset_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_subset_structure" gst_caps_is_subset_structure :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO CInt+++capsIsSubsetStructure ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Structure                            -- structure+    -> m Bool                               -- result+capsIsSubsetStructure _obj structure = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let structure' = unsafeManagedPtrGetPtr structure+    result <- gst_caps_is_subset_structure _obj' structure'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr structure+    return result'++data CapsIsSubsetStructureMethodInfo+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo CapsIsSubsetStructureMethodInfo Caps signature where+    overloadedMethod _ = capsIsSubsetStructure++-- method Caps::is_subset_structure_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_is_subset_structure_full" gst_caps_is_subset_structure_full :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"+    IO CInt+++capsIsSubsetStructureFull ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Structure                            -- structure+    -> Maybe (CapsFeatures)                 -- features+    -> m Bool                               -- result+capsIsSubsetStructureFull _obj structure features = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let structure' = unsafeManagedPtrGetPtr structure+    maybeFeatures <- case features of+        Nothing -> return nullPtr+        Just jFeatures -> do+            let jFeatures' = unsafeManagedPtrGetPtr jFeatures+            return jFeatures'+    result <- gst_caps_is_subset_structure_full _obj' structure' maybeFeatures+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr structure+    whenJust features touchManagedPtr+    return result'++data CapsIsSubsetStructureFullMethodInfo+instance (signature ~ (Structure -> Maybe (CapsFeatures) -> m Bool), MonadIO m) => MethodInfo CapsIsSubsetStructureFullMethodInfo Caps signature where+    overloadedMethod _ = capsIsSubsetStructureFull++-- method Caps::map_in_place+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "CapsMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_map_in_place" gst_caps_map_in_place :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    FunPtr CapsMapFuncC ->                  -- func : TInterface "Gst" "CapsMapFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++capsMapInPlace ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> CapsMapFunc                          -- func+    -> m Bool                               -- result+capsMapInPlace _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkCapsMapFunc (capsMapFuncWrapper Nothing func)+    let userData = nullPtr+    result <- gst_caps_map_in_place _obj' func' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return result'++data CapsMapInPlaceMethodInfo+instance (signature ~ (CapsMapFunc -> m Bool), MonadIO m) => MethodInfo CapsMapInPlaceMethodInfo Caps signature where+    overloadedMethod _ = capsMapInPlace++-- method Caps::merge+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_merge" gst_caps_merge :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++capsMerge ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- caps2+    -> m Caps                               -- result+capsMerge _obj caps2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    caps2' <- copyBoxed caps2+    result <- gst_caps_merge _obj' caps2'+    checkUnexpectedReturnNULL "gst_caps_merge" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    touchManagedPtr caps2+    return result'++data CapsMergeMethodInfo+instance (signature ~ (Caps -> m Caps), MonadIO m) => MethodInfo CapsMergeMethodInfo Caps signature where+    overloadedMethod _ = capsMerge++-- method Caps::merge_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_merge_structure" gst_caps_merge_structure :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO (Ptr Caps)+++capsMergeStructure ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Structure                            -- structure+    -> m Caps                               -- result+capsMergeStructure _obj structure = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    structure' <- copyBoxed structure+    result <- gst_caps_merge_structure _obj' structure'+    checkUnexpectedReturnNULL "gst_caps_merge_structure" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    touchManagedPtr structure+    return result'++data CapsMergeStructureMethodInfo+instance (signature ~ (Structure -> m Caps), MonadIO m) => MethodInfo CapsMergeStructureMethodInfo Caps signature where+    overloadedMethod _ = capsMergeStructure++-- method Caps::merge_structure_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_merge_structure_full" gst_caps_merge_structure_full :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"+    IO (Ptr Caps)+++capsMergeStructureFull ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Structure                            -- structure+    -> Maybe (CapsFeatures)                 -- features+    -> m Caps                               -- result+capsMergeStructureFull _obj structure features = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    structure' <- copyBoxed structure+    maybeFeatures <- case features of+        Nothing -> return nullPtr+        Just jFeatures -> do+            jFeatures' <- copyBoxed jFeatures+            return jFeatures'+    result <- gst_caps_merge_structure_full _obj' structure' maybeFeatures+    checkUnexpectedReturnNULL "gst_caps_merge_structure_full" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    touchManagedPtr structure+    whenJust features touchManagedPtr+    return result'++data CapsMergeStructureFullMethodInfo+instance (signature ~ (Structure -> Maybe (CapsFeatures) -> m Caps), MonadIO m) => MethodInfo CapsMergeStructureFullMethodInfo Caps signature where+    overloadedMethod _ = capsMergeStructureFull++-- method Caps::normalize+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_normalize" gst_caps_normalize :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++capsNormalize ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Caps                               -- result+capsNormalize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_normalize _obj'+    checkUnexpectedReturnNULL "gst_caps_normalize" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data CapsNormalizeMethodInfo+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsNormalizeMethodInfo Caps signature where+    overloadedMethod _ = capsNormalize++-- method Caps::remove_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_remove_structure" gst_caps_remove_structure :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Word32 ->                               -- idx : TBasicType TUInt32+    IO ()+++capsRemoveStructure ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Word32                               -- idx+    -> m ()                                 -- result+capsRemoveStructure _obj idx = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_caps_remove_structure _obj' idx+    touchManagedPtr _obj+    return ()++data CapsRemoveStructureMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo CapsRemoveStructureMethodInfo Caps signature where+    overloadedMethod _ = capsRemoveStructure++-- method Caps::set_features+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_set_features" gst_caps_set_features :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"+    IO ()+++capsSetFeatures ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Word32                               -- index+    -> Maybe (CapsFeatures)                 -- features+    -> m ()                                 -- result+capsSetFeatures _obj index features = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeFeatures <- case features of+        Nothing -> return nullPtr+        Just jFeatures -> do+            jFeatures' <- copyBoxed jFeatures+            return jFeatures'+    gst_caps_set_features _obj' index maybeFeatures+    touchManagedPtr _obj+    whenJust features touchManagedPtr+    return ()++data CapsSetFeaturesMethodInfo+instance (signature ~ (Word32 -> Maybe (CapsFeatures) -> m ()), MonadIO m) => MethodInfo CapsSetFeaturesMethodInfo Caps signature where+    overloadedMethod _ = capsSetFeatures++-- method Caps::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_set_value" gst_caps_set_value :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    CString ->                              -- field : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++capsSetValue ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> T.Text                               -- field+    -> GValue                               -- value+    -> m ()                                 -- result+capsSetValue _obj field value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    field' <- textToCString field+    let value' = unsafeManagedPtrGetPtr value+    gst_caps_set_value _obj' field' value'+    touchManagedPtr _obj+    touchManagedPtr value+    freeMem field'+    return ()++data CapsSetValueMethodInfo+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => MethodInfo CapsSetValueMethodInfo Caps signature where+    overloadedMethod _ = capsSetValue++-- method Caps::simplify+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_simplify" gst_caps_simplify :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++capsSimplify ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Caps                               -- result+capsSimplify _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_simplify _obj'+    checkUnexpectedReturnNULL "gst_caps_simplify" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data CapsSimplifyMethodInfo+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsSimplifyMethodInfo Caps signature where+    overloadedMethod _ = capsSimplify++-- method Caps::steal_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_steal_structure" gst_caps_steal_structure :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Word32 ->                               -- index : TBasicType TUInt32+    IO (Ptr Structure)+++capsStealStructure ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Word32                               -- index+    -> m Structure                          -- result+capsStealStructure _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_steal_structure _obj' index+    checkUnexpectedReturnNULL "gst_caps_steal_structure" result+    result' <- (wrapBoxed Structure) result+    touchManagedPtr _obj+    return result'++data CapsStealStructureMethodInfo+instance (signature ~ (Word32 -> m Structure), MonadIO m) => MethodInfo CapsStealStructureMethodInfo Caps signature where+    overloadedMethod _ = capsStealStructure++-- method Caps::subtract+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_subtract" gst_caps_subtract :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    Ptr Caps ->                             -- subtrahend : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++capsSubtract ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> Caps                                 -- subtrahend+    -> m Caps                               -- result+capsSubtract _obj subtrahend = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend+    result <- gst_caps_subtract _obj' subtrahend'+    checkUnexpectedReturnNULL "gst_caps_subtract" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    touchManagedPtr subtrahend+    return result'++data CapsSubtractMethodInfo+instance (signature ~ (Caps -> m Caps), MonadIO m) => MethodInfo CapsSubtractMethodInfo Caps signature where+    overloadedMethod _ = capsSubtract++-- method Caps::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_to_string" gst_caps_to_string :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO CString+++capsToString ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m T.Text                             -- result+capsToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_to_string _obj'+    checkUnexpectedReturnNULL "gst_caps_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data CapsToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo CapsToStringMethodInfo Caps signature where+    overloadedMethod _ = capsToString++-- method Caps::truncate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_truncate" gst_caps_truncate :: +    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"+    IO (Ptr Caps)+++capsTruncate ::+    (MonadIO m) =>+    Caps                                    -- _obj+    -> m Caps                               -- result+capsTruncate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_truncate _obj'+    checkUnexpectedReturnNULL "gst_caps_truncate" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data CapsTruncateMethodInfo+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsTruncateMethodInfo Caps signature where+    overloadedMethod _ = capsTruncate++-- method Caps::from_string+-- method type : MemberFunction+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_from_string" gst_caps_from_string :: +    CString ->                              -- string : TBasicType TUTF8+    IO (Ptr Caps)+++capsFromString ::+    (MonadIO m) =>+    T.Text                                  -- string+    -> m Caps                               -- result+capsFromString string = liftIO $ do+    string' <- textToCString string+    result <- gst_caps_from_string string'+    checkUnexpectedReturnNULL "gst_caps_from_string" result+    result' <- (wrapBoxed Caps) result+    freeMem string'+    return result'++type family ResolveCapsMethod (t :: Symbol) (o :: *) :: * where+    ResolveCapsMethod "append" o = CapsAppendMethodInfo+    ResolveCapsMethod "appendStructure" o = CapsAppendStructureMethodInfo+    ResolveCapsMethod "appendStructureFull" o = CapsAppendStructureFullMethodInfo+    ResolveCapsMethod "canIntersect" o = CapsCanIntersectMethodInfo+    ResolveCapsMethod "copyNth" o = CapsCopyNthMethodInfo+    ResolveCapsMethod "filterAndMapInPlace" o = CapsFilterAndMapInPlaceMethodInfo+    ResolveCapsMethod "fixate" o = CapsFixateMethodInfo+    ResolveCapsMethod "foreach" o = CapsForeachMethodInfo+    ResolveCapsMethod "intersect" o = CapsIntersectMethodInfo+    ResolveCapsMethod "intersectFull" o = CapsIntersectFullMethodInfo+    ResolveCapsMethod "isAlwaysCompatible" o = CapsIsAlwaysCompatibleMethodInfo+    ResolveCapsMethod "isAny" o = CapsIsAnyMethodInfo+    ResolveCapsMethod "isEmpty" o = CapsIsEmptyMethodInfo+    ResolveCapsMethod "isEqual" o = CapsIsEqualMethodInfo+    ResolveCapsMethod "isEqualFixed" o = CapsIsEqualFixedMethodInfo+    ResolveCapsMethod "isFixed" o = CapsIsFixedMethodInfo+    ResolveCapsMethod "isStrictlyEqual" o = CapsIsStrictlyEqualMethodInfo+    ResolveCapsMethod "isSubset" o = CapsIsSubsetMethodInfo+    ResolveCapsMethod "isSubsetStructure" o = CapsIsSubsetStructureMethodInfo+    ResolveCapsMethod "isSubsetStructureFull" o = CapsIsSubsetStructureFullMethodInfo+    ResolveCapsMethod "mapInPlace" o = CapsMapInPlaceMethodInfo+    ResolveCapsMethod "merge" o = CapsMergeMethodInfo+    ResolveCapsMethod "mergeStructure" o = CapsMergeStructureMethodInfo+    ResolveCapsMethod "mergeStructureFull" o = CapsMergeStructureFullMethodInfo+    ResolveCapsMethod "normalize" o = CapsNormalizeMethodInfo+    ResolveCapsMethod "removeStructure" o = CapsRemoveStructureMethodInfo+    ResolveCapsMethod "simplify" o = CapsSimplifyMethodInfo+    ResolveCapsMethod "stealStructure" o = CapsStealStructureMethodInfo+    ResolveCapsMethod "subtract" o = CapsSubtractMethodInfo+    ResolveCapsMethod "toString" o = CapsToStringMethodInfo+    ResolveCapsMethod "truncate" o = CapsTruncateMethodInfo+    ResolveCapsMethod "getFeatures" o = CapsGetFeaturesMethodInfo+    ResolveCapsMethod "getSize" o = CapsGetSizeMethodInfo+    ResolveCapsMethod "getStructure" o = CapsGetStructureMethodInfo+    ResolveCapsMethod "setFeatures" o = CapsSetFeaturesMethodInfo+    ResolveCapsMethod "setValue" o = CapsSetValueMethodInfo+    ResolveCapsMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveCapsMethod t Caps, MethodInfo info Caps p) => IsLabelProxy t (Caps -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveCapsMethod t Caps, MethodInfo info Caps p) => IsLabel t (Caps -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Caps.hs-boot view
@@ -0,0 +1,47 @@+module GI.Gst.Structs.Caps 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++newtype Caps = Caps (ForeignPtr Caps)+instance BoxedObject Caps where+data CapsAppendMethodInfo+data CapsAppendStructureMethodInfo+data CapsAppendStructureFullMethodInfo+data CapsCanIntersectMethodInfo+data CapsCopyNthMethodInfo+data CapsFilterAndMapInPlaceMethodInfo+data CapsFixateMethodInfo+data CapsForeachMethodInfo+data CapsGetFeaturesMethodInfo+data CapsGetSizeMethodInfo+data CapsGetStructureMethodInfo+data CapsIntersectMethodInfo+data CapsIntersectFullMethodInfo+data CapsIsAlwaysCompatibleMethodInfo+data CapsIsAnyMethodInfo+data CapsIsEmptyMethodInfo+data CapsIsEqualMethodInfo+data CapsIsEqualFixedMethodInfo+data CapsIsFixedMethodInfo+data CapsIsStrictlyEqualMethodInfo+data CapsIsSubsetMethodInfo+data CapsIsSubsetStructureMethodInfo+data CapsIsSubsetStructureFullMethodInfo+data CapsMapInPlaceMethodInfo+data CapsMergeMethodInfo+data CapsMergeStructureMethodInfo+data CapsMergeStructureFullMethodInfo+data CapsNormalizeMethodInfo+data CapsRemoveStructureMethodInfo+data CapsSetFeaturesMethodInfo+data CapsSetValueMethodInfo+data CapsSimplifyMethodInfo+data CapsStealStructureMethodInfo+data CapsSubtractMethodInfo+data CapsToStringMethodInfo+data CapsTruncateMethodInfo
+ GI/Gst/Structs/CapsFeatures.hs view
@@ -0,0 +1,686 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GstCapsFeatures can optionally be set on a #GstCaps to add requirements+for additional features for a specific #GstStructure. Caps structures with+the same name but with a non-equal set of caps features are not compatible.+If a pad supports multiple sets of features it has to add multiple equal+structures with different feature sets to the caps.++Empty #GstCapsFeatures are equivalent with the #GstCapsFeatures that only+contain #GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY. ANY #GstCapsFeatures as+created by gst_caps_features_new_any() are equal to any other #GstCapsFeatures+and can be used to specify that any #GstCapsFeatures would be supported, e.g.+for elements that don't touch buffer memory. #GstCaps with ANY #GstCapsFeatures+are considered non-fixed and during negotiation some #GstCapsFeatures have+to be selected.++Examples for caps features would be the requirement of a specific #GstMemory+types or the requirement of having a specific #GstMeta on the buffer. Features+are given as a string of the format "memory:GstMemoryTypeName" or+"meta:GstMetaAPIName".+-}++module GI.Gst.Structs.CapsFeatures+    ( ++-- * Exported types+    CapsFeatures(..)                        ,+    noCapsFeatures                          ,+++ -- * Methods+-- ** capsFeaturesAdd+    CapsFeaturesAddMethodInfo               ,+    capsFeaturesAdd                         ,+++-- ** capsFeaturesAddId+    CapsFeaturesAddIdMethodInfo             ,+    capsFeaturesAddId                       ,+++-- ** capsFeaturesContains+    CapsFeaturesContainsMethodInfo          ,+    capsFeaturesContains                    ,+++-- ** capsFeaturesContainsId+    CapsFeaturesContainsIdMethodInfo        ,+    capsFeaturesContainsId                  ,+++-- ** capsFeaturesCopy+    CapsFeaturesCopyMethodInfo              ,+    capsFeaturesCopy                        ,+++-- ** capsFeaturesFree+    CapsFeaturesFreeMethodInfo              ,+    capsFeaturesFree                        ,+++-- ** capsFeaturesFromString+    capsFeaturesFromString                  ,+++-- ** capsFeaturesGetNth+    CapsFeaturesGetNthMethodInfo            ,+    capsFeaturesGetNth                      ,+++-- ** capsFeaturesGetNthId+    CapsFeaturesGetNthIdMethodInfo          ,+    capsFeaturesGetNthId                    ,+++-- ** capsFeaturesGetSize+    CapsFeaturesGetSizeMethodInfo           ,+    capsFeaturesGetSize                     ,+++-- ** capsFeaturesIsAny+    CapsFeaturesIsAnyMethodInfo             ,+    capsFeaturesIsAny                       ,+++-- ** capsFeaturesIsEqual+    CapsFeaturesIsEqualMethodInfo           ,+    capsFeaturesIsEqual                     ,+++-- ** capsFeaturesNewAny+    capsFeaturesNewAny                      ,+++-- ** capsFeaturesNewEmpty+    capsFeaturesNewEmpty                    ,+++-- ** capsFeaturesRemove+    CapsFeaturesRemoveMethodInfo            ,+    capsFeaturesRemove                      ,+++-- ** capsFeaturesRemoveId+    CapsFeaturesRemoveIdMethodInfo          ,+    capsFeaturesRemoveId                    ,+++-- ** capsFeaturesSetParentRefcount+    CapsFeaturesSetParentRefcountMethodInfo ,+    capsFeaturesSetParentRefcount           ,+++-- ** capsFeaturesToString+    CapsFeaturesToStringMethodInfo          ,+    capsFeaturesToString                    ,+++++    ) 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 GI.Gst.Callbacks++newtype CapsFeatures = CapsFeatures (ForeignPtr CapsFeatures)+foreign import ccall "gst_caps_features_get_type" c_gst_caps_features_get_type :: +    IO GType++instance BoxedObject CapsFeatures where+    boxedType _ = c_gst_caps_features_get_type++noCapsFeatures :: Maybe CapsFeatures+noCapsFeatures = Nothing++-- method CapsFeatures::new_any+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "CapsFeatures"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_new_any" gst_caps_features_new_any :: +    IO (Ptr CapsFeatures)+++capsFeaturesNewAny ::+    (MonadIO m) =>+    m CapsFeatures                          -- result+capsFeaturesNewAny  = liftIO $ do+    result <- gst_caps_features_new_any+    checkUnexpectedReturnNULL "gst_caps_features_new_any" result+    result' <- (wrapBoxed CapsFeatures) result+    return result'++-- method CapsFeatures::new_empty+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "CapsFeatures"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_new_empty" gst_caps_features_new_empty :: +    IO (Ptr CapsFeatures)+++capsFeaturesNewEmpty ::+    (MonadIO m) =>+    m CapsFeatures                          -- result+capsFeaturesNewEmpty  = liftIO $ do+    result <- gst_caps_features_new_empty+    checkUnexpectedReturnNULL "gst_caps_features_new_empty" result+    result' <- (wrapBoxed CapsFeatures) result+    return result'++-- method CapsFeatures::add+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_add" gst_caps_features_add :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    CString ->                              -- feature : TBasicType TUTF8+    IO ()+++capsFeaturesAdd ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> T.Text                               -- feature+    -> m ()                                 -- result+capsFeaturesAdd _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    feature' <- textToCString feature+    gst_caps_features_add _obj' feature'+    touchManagedPtr _obj+    freeMem feature'+    return ()++data CapsFeaturesAddMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo CapsFeaturesAddMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesAdd++-- method CapsFeatures::add_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_add_id" gst_caps_features_add_id :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    Word32 ->                               -- feature : TBasicType TUInt32+    IO ()+++capsFeaturesAddId ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> Word32                               -- feature+    -> m ()                                 -- result+capsFeaturesAddId _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_caps_features_add_id _obj' feature+    touchManagedPtr _obj+    return ()++data CapsFeaturesAddIdMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo CapsFeaturesAddIdMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesAddId++-- method CapsFeatures::contains+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_contains" gst_caps_features_contains :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    CString ->                              -- feature : TBasicType TUTF8+    IO CInt+++capsFeaturesContains ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> T.Text                               -- feature+    -> m Bool                               -- result+capsFeaturesContains _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    feature' <- textToCString feature+    result <- gst_caps_features_contains _obj' feature'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem feature'+    return result'++data CapsFeaturesContainsMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo CapsFeaturesContainsMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesContains++-- method CapsFeatures::contains_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_contains_id" gst_caps_features_contains_id :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    Word32 ->                               -- feature : TBasicType TUInt32+    IO CInt+++capsFeaturesContainsId ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> Word32                               -- feature+    -> m Bool                               -- result+capsFeaturesContainsId _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_contains_id _obj' feature+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data CapsFeaturesContainsIdMethodInfo+instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo CapsFeaturesContainsIdMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesContainsId++-- method CapsFeatures::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "CapsFeatures"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_copy" gst_caps_features_copy :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    IO (Ptr CapsFeatures)+++capsFeaturesCopy ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> m CapsFeatures                       -- result+capsFeaturesCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_copy _obj'+    checkUnexpectedReturnNULL "gst_caps_features_copy" result+    result' <- (wrapBoxed CapsFeatures) result+    touchManagedPtr _obj+    return result'++data CapsFeaturesCopyMethodInfo+instance (signature ~ (m CapsFeatures), MonadIO m) => MethodInfo CapsFeaturesCopyMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesCopy++-- method CapsFeatures::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_free" gst_caps_features_free :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    IO ()+++capsFeaturesFree ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> m ()                                 -- result+capsFeaturesFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_caps_features_free _obj'+    touchManagedPtr _obj+    return ()++data CapsFeaturesFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo CapsFeaturesFreeMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesFree++-- method CapsFeatures::get_nth+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_get_nth" gst_caps_features_get_nth :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    Word32 ->                               -- i : TBasicType TUInt32+    IO CString+++capsFeaturesGetNth ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> Word32                               -- i+    -> m T.Text                             -- result+capsFeaturesGetNth _obj i = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_get_nth _obj' i+    checkUnexpectedReturnNULL "gst_caps_features_get_nth" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data CapsFeaturesGetNthMethodInfo+instance (signature ~ (Word32 -> m T.Text), MonadIO m) => MethodInfo CapsFeaturesGetNthMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesGetNth++-- method CapsFeatures::get_nth_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_get_nth_id" gst_caps_features_get_nth_id :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    Word32 ->                               -- i : TBasicType TUInt32+    IO Word32+++capsFeaturesGetNthId ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> Word32                               -- i+    -> m Word32                             -- result+capsFeaturesGetNthId _obj i = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_get_nth_id _obj' i+    touchManagedPtr _obj+    return result++data CapsFeaturesGetNthIdMethodInfo+instance (signature ~ (Word32 -> m Word32), MonadIO m) => MethodInfo CapsFeaturesGetNthIdMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesGetNthId++-- method CapsFeatures::get_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_get_size" gst_caps_features_get_size :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    IO Word32+++capsFeaturesGetSize ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> m Word32                             -- result+capsFeaturesGetSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_get_size _obj'+    touchManagedPtr _obj+    return result++data CapsFeaturesGetSizeMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo CapsFeaturesGetSizeMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesGetSize++-- method CapsFeatures::is_any+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_is_any" gst_caps_features_is_any :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    IO CInt+++capsFeaturesIsAny ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> m Bool                               -- result+capsFeaturesIsAny _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_is_any _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data CapsFeaturesIsAnyMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsFeaturesIsAnyMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesIsAny++-- method CapsFeatures::is_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features2", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_is_equal" gst_caps_features_is_equal :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    Ptr CapsFeatures ->                     -- features2 : TInterface "Gst" "CapsFeatures"+    IO CInt+++capsFeaturesIsEqual ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> CapsFeatures                         -- features2+    -> m Bool                               -- result+capsFeaturesIsEqual _obj features2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let features2' = unsafeManagedPtrGetPtr features2+    result <- gst_caps_features_is_equal _obj' features2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr features2+    return result'++data CapsFeaturesIsEqualMethodInfo+instance (signature ~ (CapsFeatures -> m Bool), MonadIO m) => MethodInfo CapsFeaturesIsEqualMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesIsEqual++-- method CapsFeatures::remove+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_remove" gst_caps_features_remove :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    CString ->                              -- feature : TBasicType TUTF8+    IO ()+++capsFeaturesRemove ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> T.Text                               -- feature+    -> m ()                                 -- result+capsFeaturesRemove _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    feature' <- textToCString feature+    gst_caps_features_remove _obj' feature'+    touchManagedPtr _obj+    freeMem feature'+    return ()++data CapsFeaturesRemoveMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo CapsFeaturesRemoveMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesRemove++-- method CapsFeatures::remove_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_remove_id" gst_caps_features_remove_id :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    Word32 ->                               -- feature : TBasicType TUInt32+    IO ()+++capsFeaturesRemoveId ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> Word32                               -- feature+    -> m ()                                 -- result+capsFeaturesRemoveId _obj feature = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_caps_features_remove_id _obj' feature+    touchManagedPtr _obj+    return ()++data CapsFeaturesRemoveIdMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo CapsFeaturesRemoveIdMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesRemoveId++-- method CapsFeatures::set_parent_refcount+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refcount", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_set_parent_refcount" gst_caps_features_set_parent_refcount :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    Int32 ->                                -- refcount : TBasicType TInt32+    IO CInt+++capsFeaturesSetParentRefcount ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> Int32                                -- refcount+    -> m Bool                               -- result+capsFeaturesSetParentRefcount _obj refcount = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_set_parent_refcount _obj' refcount+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data CapsFeaturesSetParentRefcountMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo CapsFeaturesSetParentRefcountMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesSetParentRefcount++-- method CapsFeatures::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_to_string" gst_caps_features_to_string :: +    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"+    IO CString+++capsFeaturesToString ::+    (MonadIO m) =>+    CapsFeatures                            -- _obj+    -> m T.Text                             -- result+capsFeaturesToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_caps_features_to_string _obj'+    checkUnexpectedReturnNULL "gst_caps_features_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data CapsFeaturesToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo CapsFeaturesToStringMethodInfo CapsFeatures signature where+    overloadedMethod _ = capsFeaturesToString++-- method CapsFeatures::from_string+-- method type : MemberFunction+-- Args : [Arg {argCName = "features", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "CapsFeatures"+-- throws : False+-- Skip return : False++foreign import ccall "gst_caps_features_from_string" gst_caps_features_from_string :: +    CString ->                              -- features : TBasicType TUTF8+    IO (Ptr CapsFeatures)+++capsFeaturesFromString ::+    (MonadIO m) =>+    T.Text                                  -- features+    -> m CapsFeatures                       -- result+capsFeaturesFromString features = liftIO $ do+    features' <- textToCString features+    result <- gst_caps_features_from_string features'+    checkUnexpectedReturnNULL "gst_caps_features_from_string" result+    result' <- (wrapBoxed CapsFeatures) result+    freeMem features'+    return result'++type family ResolveCapsFeaturesMethod (t :: Symbol) (o :: *) :: * where+    ResolveCapsFeaturesMethod "add" o = CapsFeaturesAddMethodInfo+    ResolveCapsFeaturesMethod "addId" o = CapsFeaturesAddIdMethodInfo+    ResolveCapsFeaturesMethod "contains" o = CapsFeaturesContainsMethodInfo+    ResolveCapsFeaturesMethod "containsId" o = CapsFeaturesContainsIdMethodInfo+    ResolveCapsFeaturesMethod "copy" o = CapsFeaturesCopyMethodInfo+    ResolveCapsFeaturesMethod "free" o = CapsFeaturesFreeMethodInfo+    ResolveCapsFeaturesMethod "isAny" o = CapsFeaturesIsAnyMethodInfo+    ResolveCapsFeaturesMethod "isEqual" o = CapsFeaturesIsEqualMethodInfo+    ResolveCapsFeaturesMethod "remove" o = CapsFeaturesRemoveMethodInfo+    ResolveCapsFeaturesMethod "removeId" o = CapsFeaturesRemoveIdMethodInfo+    ResolveCapsFeaturesMethod "toString" o = CapsFeaturesToStringMethodInfo+    ResolveCapsFeaturesMethod "getNth" o = CapsFeaturesGetNthMethodInfo+    ResolveCapsFeaturesMethod "getNthId" o = CapsFeaturesGetNthIdMethodInfo+    ResolveCapsFeaturesMethod "getSize" o = CapsFeaturesGetSizeMethodInfo+    ResolveCapsFeaturesMethod "setParentRefcount" o = CapsFeaturesSetParentRefcountMethodInfo+    ResolveCapsFeaturesMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveCapsFeaturesMethod t CapsFeatures, MethodInfo info CapsFeatures p) => IsLabelProxy t (CapsFeatures -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveCapsFeaturesMethod t CapsFeatures, MethodInfo info CapsFeatures p) => IsLabel t (CapsFeatures -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/CapsFeatures.hs-boot view
@@ -0,0 +1,26 @@+module GI.Gst.Structs.CapsFeatures 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++newtype CapsFeatures = CapsFeatures (ForeignPtr CapsFeatures)+instance BoxedObject CapsFeatures where+data CapsFeaturesAddMethodInfo+data CapsFeaturesAddIdMethodInfo+data CapsFeaturesContainsMethodInfo+data CapsFeaturesContainsIdMethodInfo+data CapsFeaturesCopyMethodInfo+data CapsFeaturesFreeMethodInfo+data CapsFeaturesGetNthMethodInfo+data CapsFeaturesGetNthIdMethodInfo+data CapsFeaturesGetSizeMethodInfo+data CapsFeaturesIsAnyMethodInfo+data CapsFeaturesIsEqualMethodInfo+data CapsFeaturesRemoveMethodInfo+data CapsFeaturesRemoveIdMethodInfo+data CapsFeaturesSetParentRefcountMethodInfo+data CapsFeaturesToStringMethodInfo
+ GI/Gst/Structs/ClockEntry.hs view
@@ -0,0 +1,147 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++All pending timeouts or periodic notifies are converted into+an entry.+Note that GstClockEntry should be treated as an opaque structure. It must+not be extended or allocated using a custom allocator.+-}++module GI.Gst.Structs.ClockEntry+    ( ++-- * Exported types+    ClockEntry(..)                          ,+    newZeroClockEntry                       ,+    noClockEntry                            ,+++ -- * Properties+-- ** Clock+    clockEntryReadClock                     ,+++-- ** Interval+    clockEntryReadInterval                  ,+++-- ** Refcount+    clockEntryReadRefcount                  ,+++-- ** Status+    clockEntryReadStatus                    ,+++-- ** Time+    clockEntryReadTime                      ,+++-- ** Type+    clockEntryReadType                      ,+++-- ** Unscheduled+    clockEntryReadUnscheduled               ,+++-- ** UserData+    clockEntryReadUserData                  ,+++-- ** WokenUp+    clockEntryReadWokenUp                   ,+++++    ) 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 GI.Gst.Callbacks++newtype ClockEntry = ClockEntry (ForeignPtr ClockEntry)+-- | Construct a `ClockEntry` struct initialized to zero.+newZeroClockEntry :: MonadIO m => m ClockEntry+newZeroClockEntry = liftIO $ callocBytes 112 >>= wrapPtr ClockEntry++noClockEntry :: Maybe ClockEntry+noClockEntry = Nothing++clockEntryReadRefcount :: ClockEntry -> IO Int32+clockEntryReadRefcount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++clockEntryReadClock :: ClockEntry -> IO Clock+clockEntryReadClock s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Clock)+    val' <- (newObject Clock) val+    return val'++clockEntryReadType :: ClockEntry -> IO ClockEntryType+clockEntryReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++clockEntryReadTime :: ClockEntry -> IO Word64+clockEntryReadTime s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word64+    return val++clockEntryReadInterval :: ClockEntry -> IO Word64+clockEntryReadInterval s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word64+    return val++clockEntryReadStatus :: ClockEntry -> IO ClockReturn+clockEntryReadStatus s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++-- XXX Skipped getter for "ClockEntry:func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++clockEntryReadUserData :: ClockEntry -> IO (Ptr ())+clockEntryReadUserData s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO (Ptr ())+    return val++-- XXX Skipped getter for "ClockEntry:destroy_data" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++clockEntryReadUnscheduled :: ClockEntry -> IO Bool+clockEntryReadUnscheduled s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO CInt+    let val' = (/= 0) val+    return val'++clockEntryReadWokenUp :: ClockEntry -> IO Bool+clockEntryReadWokenUp s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 76) :: IO CInt+    let val' = (/= 0) val+    return val'++type family ResolveClockEntryMethod (t :: Symbol) (o :: *) :: * where+    ResolveClockEntryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveClockEntryMethod t ClockEntry, MethodInfo info ClockEntry p) => IsLabelProxy t (ClockEntry -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveClockEntryMethod t ClockEntry, MethodInfo info ClockEntry p) => IsLabel t (ClockEntry -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/ClockEntry.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.ClockEntry 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++newtype ClockEntry = ClockEntry (ForeignPtr ClockEntry)
+ GI/Gst/Structs/Context.hs view
@@ -0,0 +1,285 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GstContext is a container object used to store contexts like a device+context, a display server connection and similar concepts that should+be shared between multiple elements.++Applications can set a context on a complete pipeline by using+gst_element_set_context(), which will then be propagated to all+child elements. Elements can handle these in #GstElementClass.set_context()+and merge them with the context information they already have.++When an element needs a context it will do the following actions in this+order until one step succeeds:+1. Check if the element already has a context+2. Query downstream with GST_QUERY_CONTEXT for the context+3. Query upstream with GST_QUERY_CONTEXT for the context+4. Post a GST_MESSAGE_NEED_CONTEXT message on the bus with the required+   context types and afterwards check if a usable context was set now+5. Create a context by itself and post a GST_MESSAGE_HAVE_CONTEXT message+   on the bus.++Bins will catch GST_MESSAGE_NEED_CONTEXT messages and will set any previously+known context on the element that asks for it if possible. Otherwise the+application should provide one if it can.+-}++module GI.Gst.Structs.Context+    ( ++-- * Exported types+    Context(..)                             ,+    noContext                               ,+++ -- * Methods+-- ** contextGetContextType+    ContextGetContextTypeMethodInfo         ,+    contextGetContextType                   ,+++-- ** contextGetStructure+    ContextGetStructureMethodInfo           ,+    contextGetStructure                     ,+++-- ** contextHasContextType+    ContextHasContextTypeMethodInfo         ,+    contextHasContextType                   ,+++-- ** contextIsPersistent+    ContextIsPersistentMethodInfo           ,+    contextIsPersistent                     ,+++-- ** contextNew+    contextNew                              ,+++-- ** contextWritableStructure+    ContextWritableStructureMethodInfo      ,+    contextWritableStructure                ,+++++    ) 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 GI.Gst.Callbacks++newtype Context = Context (ForeignPtr Context)+foreign import ccall "gst_context_get_type" c_gst_context_get_type :: +    IO GType++instance BoxedObject Context where+    boxedType _ = c_gst_context_get_type++noContext :: Maybe Context+noContext = Nothing++-- method Context::new+-- method type : Constructor+-- Args : [Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "persistent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Context"+-- throws : False+-- Skip return : False++foreign import ccall "gst_context_new" gst_context_new :: +    CString ->                              -- context_type : TBasicType TUTF8+    CInt ->                                 -- persistent : TBasicType TBoolean+    IO (Ptr Context)+++contextNew ::+    (MonadIO m) =>+    T.Text                                  -- contextType+    -> Bool                                 -- persistent+    -> m Context                            -- result+contextNew contextType persistent = liftIO $ do+    contextType' <- textToCString contextType+    let persistent' = (fromIntegral . fromEnum) persistent+    result <- gst_context_new contextType' persistent'+    checkUnexpectedReturnNULL "gst_context_new" result+    result' <- (wrapBoxed Context) result+    freeMem contextType'+    return result'++-- method Context::get_context_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_context_get_context_type" gst_context_get_context_type :: +    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"+    IO CString+++contextGetContextType ::+    (MonadIO m) =>+    Context                                 -- _obj+    -> m T.Text                             -- result+contextGetContextType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_context_get_context_type _obj'+    checkUnexpectedReturnNULL "gst_context_get_context_type" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data ContextGetContextTypeMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo ContextGetContextTypeMethodInfo Context signature where+    overloadedMethod _ = contextGetContextType++-- method Context::get_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_context_get_structure" gst_context_get_structure :: +    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"+    IO (Ptr Structure)+++contextGetStructure ::+    (MonadIO m) =>+    Context                                 -- _obj+    -> m Structure                          -- result+contextGetStructure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_context_get_structure _obj'+    checkUnexpectedReturnNULL "gst_context_get_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data ContextGetStructureMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo ContextGetStructureMethodInfo Context signature where+    overloadedMethod _ = contextGetStructure++-- method Context::has_context_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_context_has_context_type" gst_context_has_context_type :: +    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"+    CString ->                              -- context_type : TBasicType TUTF8+    IO CInt+++contextHasContextType ::+    (MonadIO m) =>+    Context                                 -- _obj+    -> T.Text                               -- contextType+    -> m Bool                               -- result+contextHasContextType _obj contextType = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    contextType' <- textToCString contextType+    result <- gst_context_has_context_type _obj' contextType'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem contextType'+    return result'++data ContextHasContextTypeMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo ContextHasContextTypeMethodInfo Context signature where+    overloadedMethod _ = contextHasContextType++-- method Context::is_persistent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_context_is_persistent" gst_context_is_persistent :: +    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"+    IO CInt+++contextIsPersistent ::+    (MonadIO m) =>+    Context                                 -- _obj+    -> m Bool                               -- result+contextIsPersistent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_context_is_persistent _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data ContextIsPersistentMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo ContextIsPersistentMethodInfo Context signature where+    overloadedMethod _ = contextIsPersistent++-- method Context::writable_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_context_writable_structure" gst_context_writable_structure :: +    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"+    IO (Ptr Structure)+++contextWritableStructure ::+    (MonadIO m) =>+    Context                                 -- _obj+    -> m Structure                          -- result+contextWritableStructure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_context_writable_structure _obj'+    checkUnexpectedReturnNULL "gst_context_writable_structure" result+    result' <- (wrapBoxed Structure) result+    touchManagedPtr _obj+    return result'++data ContextWritableStructureMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo ContextWritableStructureMethodInfo Context signature where+    overloadedMethod _ = contextWritableStructure++type family ResolveContextMethod (t :: Symbol) (o :: *) :: * where+    ResolveContextMethod "hasContextType" o = ContextHasContextTypeMethodInfo+    ResolveContextMethod "isPersistent" o = ContextIsPersistentMethodInfo+    ResolveContextMethod "writableStructure" o = ContextWritableStructureMethodInfo+    ResolveContextMethod "getContextType" o = ContextGetContextTypeMethodInfo+    ResolveContextMethod "getStructure" o = ContextGetStructureMethodInfo+    ResolveContextMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveContextMethod t Context, MethodInfo info Context p) => IsLabelProxy t (Context -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveContextMethod t Context, MethodInfo info Context p) => IsLabel t (Context -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Context.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gst.Structs.Context 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++newtype Context = Context (ForeignPtr Context)+instance BoxedObject Context where+data ContextGetContextTypeMethodInfo+data ContextGetStructureMethodInfo+data ContextHasContextTypeMethodInfo+data ContextIsPersistentMethodInfo+data ContextWritableStructureMethodInfo
+ GI/Gst/Structs/DateTime.hs view
@@ -0,0 +1,963 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Struct to store date, time and timezone information altogether.+#GstDateTime is refcounted and immutable.++Date information is handled using the proleptic Gregorian calendar.++Provides basic creation functions and accessor functions to its fields.+-}++module GI.Gst.Structs.DateTime+    ( ++-- * Exported types+    DateTime(..)                            ,+    noDateTime                              ,+++ -- * Methods+-- ** dateTimeGetDay+    DateTimeGetDayMethodInfo                ,+    dateTimeGetDay                          ,+++-- ** dateTimeGetHour+    DateTimeGetHourMethodInfo               ,+    dateTimeGetHour                         ,+++-- ** dateTimeGetMicrosecond+    DateTimeGetMicrosecondMethodInfo        ,+    dateTimeGetMicrosecond                  ,+++-- ** dateTimeGetMinute+    DateTimeGetMinuteMethodInfo             ,+    dateTimeGetMinute                       ,+++-- ** dateTimeGetMonth+    DateTimeGetMonthMethodInfo              ,+    dateTimeGetMonth                        ,+++-- ** dateTimeGetSecond+    DateTimeGetSecondMethodInfo             ,+    dateTimeGetSecond                       ,+++-- ** dateTimeGetTimeZoneOffset+    DateTimeGetTimeZoneOffsetMethodInfo     ,+    dateTimeGetTimeZoneOffset               ,+++-- ** dateTimeGetYear+    DateTimeGetYearMethodInfo               ,+    dateTimeGetYear                         ,+++-- ** dateTimeHasDay+    DateTimeHasDayMethodInfo                ,+    dateTimeHasDay                          ,+++-- ** dateTimeHasMonth+    DateTimeHasMonthMethodInfo              ,+    dateTimeHasMonth                        ,+++-- ** dateTimeHasSecond+    DateTimeHasSecondMethodInfo             ,+    dateTimeHasSecond                       ,+++-- ** dateTimeHasTime+    DateTimeHasTimeMethodInfo               ,+    dateTimeHasTime                         ,+++-- ** dateTimeHasYear+    DateTimeHasYearMethodInfo               ,+    dateTimeHasYear                         ,+++-- ** dateTimeNew+    dateTimeNew                             ,+++-- ** dateTimeNewFromGDateTime+    dateTimeNewFromGDateTime                ,+++-- ** dateTimeNewFromIso8601String+    dateTimeNewFromIso8601String            ,+++-- ** dateTimeNewFromUnixEpochLocalTime+    dateTimeNewFromUnixEpochLocalTime       ,+++-- ** dateTimeNewFromUnixEpochUtc+    dateTimeNewFromUnixEpochUtc             ,+++-- ** dateTimeNewLocalTime+    dateTimeNewLocalTime                    ,+++-- ** dateTimeNewNowLocalTime+    dateTimeNewNowLocalTime                 ,+++-- ** dateTimeNewNowUtc+    dateTimeNewNowUtc                       ,+++-- ** dateTimeNewY+    dateTimeNewY                            ,+++-- ** dateTimeNewYm+    dateTimeNewYm                           ,+++-- ** dateTimeNewYmd+    dateTimeNewYmd                          ,+++-- ** dateTimeRef+    DateTimeRefMethodInfo                   ,+    dateTimeRef                             ,+++-- ** dateTimeToGDateTime+    DateTimeToGDateTimeMethodInfo           ,+    dateTimeToGDateTime                     ,+++-- ** dateTimeToIso8601String+    DateTimeToIso8601StringMethodInfo       ,+    dateTimeToIso8601String                 ,+++-- ** dateTimeUnref+    DateTimeUnrefMethodInfo                 ,+    dateTimeUnref                           ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype DateTime = DateTime (ForeignPtr DateTime)+foreign import ccall "gst_date_time_get_type" c_gst_date_time_get_type :: +    IO GType++instance BoxedObject DateTime where+    boxedType _ = c_gst_date_time_get_type++noDateTime :: Maybe DateTime+noDateTime = Nothing++-- method DateTime::new+-- method type : Constructor+-- Args : [Arg {argCName = "tzoffset", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "day", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hour", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minute", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new" gst_date_time_new :: +    CFloat ->                               -- tzoffset : TBasicType TFloat+    Int32 ->                                -- year : TBasicType TInt32+    Int32 ->                                -- month : TBasicType TInt32+    Int32 ->                                -- day : TBasicType TInt32+    Int32 ->                                -- hour : TBasicType TInt32+    Int32 ->                                -- minute : TBasicType TInt32+    CDouble ->                              -- seconds : TBasicType TDouble+    IO (Ptr DateTime)+++dateTimeNew ::+    (MonadIO m) =>+    Float                                   -- tzoffset+    -> Int32                                -- year+    -> Int32                                -- month+    -> Int32                                -- day+    -> Int32                                -- hour+    -> Int32                                -- minute+    -> Double                               -- seconds+    -> m DateTime                           -- result+dateTimeNew tzoffset year month day hour minute seconds = liftIO $ do+    let tzoffset' = realToFrac tzoffset+    let seconds' = realToFrac seconds+    result <- gst_date_time_new tzoffset' year month day hour minute seconds'+    checkUnexpectedReturnNULL "gst_date_time_new" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_from_g_date_time+-- method type : Constructor+-- Args : [Arg {argCName = "dt", argType = TInterface "GLib" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_from_g_date_time" gst_date_time_new_from_g_date_time :: +    Ptr GLib.DateTime ->                    -- dt : TInterface "GLib" "DateTime"+    IO (Ptr DateTime)+++dateTimeNewFromGDateTime ::+    (MonadIO m) =>+    GLib.DateTime                           -- dt+    -> m DateTime                           -- result+dateTimeNewFromGDateTime dt = liftIO $ do+    dt' <- copyBoxed dt+    result <- gst_date_time_new_from_g_date_time dt'+    checkUnexpectedReturnNULL "gst_date_time_new_from_g_date_time" result+    result' <- (wrapBoxed DateTime) result+    touchManagedPtr dt+    return result'++-- method DateTime::new_from_iso8601_string+-- method type : Constructor+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_from_iso8601_string" gst_date_time_new_from_iso8601_string :: +    CString ->                              -- string : TBasicType TUTF8+    IO (Ptr DateTime)+++dateTimeNewFromIso8601String ::+    (MonadIO m) =>+    T.Text                                  -- string+    -> m DateTime                           -- result+dateTimeNewFromIso8601String string = liftIO $ do+    string' <- textToCString string+    result <- gst_date_time_new_from_iso8601_string string'+    checkUnexpectedReturnNULL "gst_date_time_new_from_iso8601_string" result+    result' <- (wrapBoxed DateTime) result+    freeMem string'+    return result'++-- method DateTime::new_from_unix_epoch_local_time+-- method type : Constructor+-- Args : [Arg {argCName = "secs", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_from_unix_epoch_local_time" gst_date_time_new_from_unix_epoch_local_time :: +    Int64 ->                                -- secs : TBasicType TInt64+    IO (Ptr DateTime)+++dateTimeNewFromUnixEpochLocalTime ::+    (MonadIO m) =>+    Int64                                   -- secs+    -> m DateTime                           -- result+dateTimeNewFromUnixEpochLocalTime secs = liftIO $ do+    result <- gst_date_time_new_from_unix_epoch_local_time secs+    checkUnexpectedReturnNULL "gst_date_time_new_from_unix_epoch_local_time" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_from_unix_epoch_utc+-- method type : Constructor+-- Args : [Arg {argCName = "secs", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_from_unix_epoch_utc" gst_date_time_new_from_unix_epoch_utc :: +    Int64 ->                                -- secs : TBasicType TInt64+    IO (Ptr DateTime)+++dateTimeNewFromUnixEpochUtc ::+    (MonadIO m) =>+    Int64                                   -- secs+    -> m DateTime                           -- result+dateTimeNewFromUnixEpochUtc secs = liftIO $ do+    result <- gst_date_time_new_from_unix_epoch_utc secs+    checkUnexpectedReturnNULL "gst_date_time_new_from_unix_epoch_utc" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_local_time+-- method type : Constructor+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "day", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hour", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minute", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_local_time" gst_date_time_new_local_time :: +    Int32 ->                                -- year : TBasicType TInt32+    Int32 ->                                -- month : TBasicType TInt32+    Int32 ->                                -- day : TBasicType TInt32+    Int32 ->                                -- hour : TBasicType TInt32+    Int32 ->                                -- minute : TBasicType TInt32+    CDouble ->                              -- seconds : TBasicType TDouble+    IO (Ptr DateTime)+++dateTimeNewLocalTime ::+    (MonadIO m) =>+    Int32                                   -- year+    -> Int32                                -- month+    -> Int32                                -- day+    -> Int32                                -- hour+    -> Int32                                -- minute+    -> Double                               -- seconds+    -> m DateTime                           -- result+dateTimeNewLocalTime year month day hour minute seconds = liftIO $ do+    let seconds' = realToFrac seconds+    result <- gst_date_time_new_local_time year month day hour minute seconds'+    checkUnexpectedReturnNULL "gst_date_time_new_local_time" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_now_local_time+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_now_local_time" gst_date_time_new_now_local_time :: +    IO (Ptr DateTime)+++dateTimeNewNowLocalTime ::+    (MonadIO m) =>+    m DateTime                              -- result+dateTimeNewNowLocalTime  = liftIO $ do+    result <- gst_date_time_new_now_local_time+    checkUnexpectedReturnNULL "gst_date_time_new_now_local_time" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_now_utc+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_now_utc" gst_date_time_new_now_utc :: +    IO (Ptr DateTime)+++dateTimeNewNowUtc ::+    (MonadIO m) =>+    m DateTime                              -- result+dateTimeNewNowUtc  = liftIO $ do+    result <- gst_date_time_new_now_utc+    checkUnexpectedReturnNULL "gst_date_time_new_now_utc" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_y+-- method type : Constructor+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_y" gst_date_time_new_y :: +    Int32 ->                                -- year : TBasicType TInt32+    IO (Ptr DateTime)+++dateTimeNewY ::+    (MonadIO m) =>+    Int32                                   -- year+    -> m DateTime                           -- result+dateTimeNewY year = liftIO $ do+    result <- gst_date_time_new_y year+    checkUnexpectedReturnNULL "gst_date_time_new_y" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_ym+-- method type : Constructor+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_ym" gst_date_time_new_ym :: +    Int32 ->                                -- year : TBasicType TInt32+    Int32 ->                                -- month : TBasicType TInt32+    IO (Ptr DateTime)+++dateTimeNewYm ::+    (MonadIO m) =>+    Int32                                   -- year+    -> Int32                                -- month+    -> m DateTime                           -- result+dateTimeNewYm year month = liftIO $ do+    result <- gst_date_time_new_ym year month+    checkUnexpectedReturnNULL "gst_date_time_new_ym" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::new_ymd+-- method type : Constructor+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "day", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_new_ymd" gst_date_time_new_ymd :: +    Int32 ->                                -- year : TBasicType TInt32+    Int32 ->                                -- month : TBasicType TInt32+    Int32 ->                                -- day : TBasicType TInt32+    IO (Ptr DateTime)+++dateTimeNewYmd ::+    (MonadIO m) =>+    Int32                                   -- year+    -> Int32                                -- month+    -> Int32                                -- day+    -> m DateTime                           -- result+dateTimeNewYmd year month day = liftIO $ do+    result <- gst_date_time_new_ymd year month day+    checkUnexpectedReturnNULL "gst_date_time_new_ymd" result+    result' <- (wrapBoxed DateTime) result+    return result'++-- method DateTime::get_day+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_day" gst_date_time_get_day :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO Int32+++dateTimeGetDay ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Int32                              -- result+dateTimeGetDay _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_day _obj'+    touchManagedPtr _obj+    return result++data DateTimeGetDayMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetDayMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetDay++-- method DateTime::get_hour+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_hour" gst_date_time_get_hour :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO Int32+++dateTimeGetHour ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Int32                              -- result+dateTimeGetHour _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_hour _obj'+    touchManagedPtr _obj+    return result++data DateTimeGetHourMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetHourMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetHour++-- method DateTime::get_microsecond+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_microsecond" gst_date_time_get_microsecond :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO Int32+++dateTimeGetMicrosecond ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Int32                              -- result+dateTimeGetMicrosecond _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_microsecond _obj'+    touchManagedPtr _obj+    return result++data DateTimeGetMicrosecondMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetMicrosecondMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetMicrosecond++-- method DateTime::get_minute+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_minute" gst_date_time_get_minute :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO Int32+++dateTimeGetMinute ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Int32                              -- result+dateTimeGetMinute _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_minute _obj'+    touchManagedPtr _obj+    return result++data DateTimeGetMinuteMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetMinuteMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetMinute++-- method DateTime::get_month+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_month" gst_date_time_get_month :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO Int32+++dateTimeGetMonth ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Int32                              -- result+dateTimeGetMonth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_month _obj'+    touchManagedPtr _obj+    return result++data DateTimeGetMonthMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetMonthMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetMonth++-- method DateTime::get_second+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_second" gst_date_time_get_second :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO Int32+++dateTimeGetSecond ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Int32                              -- result+dateTimeGetSecond _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_second _obj'+    touchManagedPtr _obj+    return result++data DateTimeGetSecondMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetSecondMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetSecond++-- method DateTime::get_time_zone_offset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TFloat+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_time_zone_offset" gst_date_time_get_time_zone_offset :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO CFloat+++dateTimeGetTimeZoneOffset ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Float                              -- result+dateTimeGetTimeZoneOffset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_time_zone_offset _obj'+    let result' = realToFrac result+    touchManagedPtr _obj+    return result'++data DateTimeGetTimeZoneOffsetMethodInfo+instance (signature ~ (m Float), MonadIO m) => MethodInfo DateTimeGetTimeZoneOffsetMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetTimeZoneOffset++-- method DateTime::get_year+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_get_year" gst_date_time_get_year :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO Int32+++dateTimeGetYear ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Int32                              -- result+dateTimeGetYear _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_get_year _obj'+    touchManagedPtr _obj+    return result++data DateTimeGetYearMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetYearMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeGetYear++-- method DateTime::has_day+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_has_day" gst_date_time_has_day :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO CInt+++dateTimeHasDay ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Bool                               -- result+dateTimeHasDay _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_has_day _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DateTimeHasDayMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasDayMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeHasDay++-- method DateTime::has_month+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_has_month" gst_date_time_has_month :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO CInt+++dateTimeHasMonth ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Bool                               -- result+dateTimeHasMonth _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_has_month _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DateTimeHasMonthMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasMonthMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeHasMonth++-- method DateTime::has_second+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_has_second" gst_date_time_has_second :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO CInt+++dateTimeHasSecond ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Bool                               -- result+dateTimeHasSecond _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_has_second _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DateTimeHasSecondMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasSecondMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeHasSecond++-- method DateTime::has_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_has_time" gst_date_time_has_time :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO CInt+++dateTimeHasTime ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Bool                               -- result+dateTimeHasTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_has_time _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DateTimeHasTimeMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasTimeMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeHasTime++-- method DateTime::has_year+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_has_year" gst_date_time_has_year :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO CInt+++dateTimeHasYear ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m Bool                               -- result+dateTimeHasYear _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_has_year _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data DateTimeHasYearMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasYearMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeHasYear++-- method DateTime::ref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_ref" gst_date_time_ref :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO (Ptr DateTime)+++dateTimeRef ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m DateTime                           -- result+dateTimeRef _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_ref _obj'+    checkUnexpectedReturnNULL "gst_date_time_ref" result+    result' <- (wrapBoxed DateTime) result+    touchManagedPtr _obj+    return result'++data DateTimeRefMethodInfo+instance (signature ~ (m DateTime), MonadIO m) => MethodInfo DateTimeRefMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeRef++-- method DateTime::to_g_date_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GLib" "DateTime"+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_to_g_date_time" gst_date_time_to_g_date_time :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO (Ptr GLib.DateTime)+++dateTimeToGDateTime ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m GLib.DateTime                      -- result+dateTimeToGDateTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_to_g_date_time _obj'+    checkUnexpectedReturnNULL "gst_date_time_to_g_date_time" result+    result' <- (wrapBoxed GLib.DateTime) result+    touchManagedPtr _obj+    return result'++data DateTimeToGDateTimeMethodInfo+instance (signature ~ (m GLib.DateTime), MonadIO m) => MethodInfo DateTimeToGDateTimeMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeToGDateTime++-- method DateTime::to_iso8601_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_to_iso8601_string" gst_date_time_to_iso8601_string :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO CString+++dateTimeToIso8601String ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m T.Text                             -- result+dateTimeToIso8601String _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_date_time_to_iso8601_string _obj'+    checkUnexpectedReturnNULL "gst_date_time_to_iso8601_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data DateTimeToIso8601StringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DateTimeToIso8601StringMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeToIso8601String++-- method DateTime::unref+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_date_time_unref" gst_date_time_unref :: +    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"+    IO ()+++dateTimeUnref ::+    (MonadIO m) =>+    DateTime                                -- _obj+    -> m ()                                 -- result+dateTimeUnref _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_date_time_unref _obj'+    touchManagedPtr _obj+    return ()++data DateTimeUnrefMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo DateTimeUnrefMethodInfo DateTime signature where+    overloadedMethod _ = dateTimeUnref++type family ResolveDateTimeMethod (t :: Symbol) (o :: *) :: * where+    ResolveDateTimeMethod "hasDay" o = DateTimeHasDayMethodInfo+    ResolveDateTimeMethod "hasMonth" o = DateTimeHasMonthMethodInfo+    ResolveDateTimeMethod "hasSecond" o = DateTimeHasSecondMethodInfo+    ResolveDateTimeMethod "hasTime" o = DateTimeHasTimeMethodInfo+    ResolveDateTimeMethod "hasYear" o = DateTimeHasYearMethodInfo+    ResolveDateTimeMethod "ref" o = DateTimeRefMethodInfo+    ResolveDateTimeMethod "toGDateTime" o = DateTimeToGDateTimeMethodInfo+    ResolveDateTimeMethod "toIso8601String" o = DateTimeToIso8601StringMethodInfo+    ResolveDateTimeMethod "unref" o = DateTimeUnrefMethodInfo+    ResolveDateTimeMethod "getDay" o = DateTimeGetDayMethodInfo+    ResolveDateTimeMethod "getHour" o = DateTimeGetHourMethodInfo+    ResolveDateTimeMethod "getMicrosecond" o = DateTimeGetMicrosecondMethodInfo+    ResolveDateTimeMethod "getMinute" o = DateTimeGetMinuteMethodInfo+    ResolveDateTimeMethod "getMonth" o = DateTimeGetMonthMethodInfo+    ResolveDateTimeMethod "getSecond" o = DateTimeGetSecondMethodInfo+    ResolveDateTimeMethod "getTimeZoneOffset" o = DateTimeGetTimeZoneOffsetMethodInfo+    ResolveDateTimeMethod "getYear" o = DateTimeGetYearMethodInfo+    ResolveDateTimeMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveDateTimeMethod t DateTime, MethodInfo info DateTime p) => IsLabelProxy t (DateTime -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveDateTimeMethod t DateTime, MethodInfo info DateTime p) => IsLabel t (DateTime -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/DateTime.hs-boot view
@@ -0,0 +1,28 @@+module GI.Gst.Structs.DateTime 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++newtype DateTime = DateTime (ForeignPtr DateTime)+instance BoxedObject DateTime where+data DateTimeGetDayMethodInfo+data DateTimeGetHourMethodInfo+data DateTimeGetMicrosecondMethodInfo+data DateTimeGetMinuteMethodInfo+data DateTimeGetMonthMethodInfo+data DateTimeGetSecondMethodInfo+data DateTimeGetTimeZoneOffsetMethodInfo+data DateTimeGetYearMethodInfo+data DateTimeHasDayMethodInfo+data DateTimeHasMonthMethodInfo+data DateTimeHasSecondMethodInfo+data DateTimeHasTimeMethodInfo+data DateTimeHasYearMethodInfo+data DateTimeRefMethodInfo+data DateTimeToGDateTimeMethodInfo+data DateTimeToIso8601StringMethodInfo+data DateTimeUnrefMethodInfo
+ GI/Gst/Structs/DebugCategory.hs view
@@ -0,0 +1,294 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++This is the struct that describes the categories. Once initialized with+#GST_DEBUG_CATEGORY_INIT, its values can't be changed anymore.+-}++module GI.Gst.Structs.DebugCategory+    ( ++-- * Exported types+    DebugCategory(..)                       ,+    newZeroDebugCategory                    ,+    noDebugCategory                         ,+++ -- * Methods+-- ** debugCategoryFree+    DebugCategoryFreeMethodInfo             ,+    debugCategoryFree                       ,+++-- ** debugCategoryGetColor+    DebugCategoryGetColorMethodInfo         ,+    debugCategoryGetColor                   ,+++-- ** debugCategoryGetDescription+    DebugCategoryGetDescriptionMethodInfo   ,+    debugCategoryGetDescription             ,+++-- ** debugCategoryGetName+    DebugCategoryGetNameMethodInfo          ,+    debugCategoryGetName                    ,+++-- ** debugCategoryGetThreshold+    DebugCategoryGetThresholdMethodInfo     ,+    debugCategoryGetThreshold               ,+++-- ** debugCategoryResetThreshold+    DebugCategoryResetThresholdMethodInfo   ,+    debugCategoryResetThreshold             ,+++-- ** debugCategorySetThreshold+    DebugCategorySetThresholdMethodInfo     ,+    debugCategorySetThreshold               ,+++++    ) 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 GI.Gst.Callbacks++newtype DebugCategory = DebugCategory (ForeignPtr DebugCategory)+-- | Construct a `DebugCategory` struct initialized to zero.+newZeroDebugCategory :: MonadIO m => m DebugCategory+newZeroDebugCategory = liftIO $ callocBytes 24 >>= wrapPtr DebugCategory++noDebugCategory :: Maybe DebugCategory+noDebugCategory = Nothing++-- method DebugCategory::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_category_free" gst_debug_category_free :: +    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"+    IO ()+++debugCategoryFree ::+    (MonadIO m) =>+    DebugCategory                           -- _obj+    -> m ()                                 -- result+debugCategoryFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_debug_category_free _obj'+    touchManagedPtr _obj+    return ()++data DebugCategoryFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo DebugCategoryFreeMethodInfo DebugCategory signature where+    overloadedMethod _ = debugCategoryFree++-- method DebugCategory::get_color+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_category_get_color" gst_debug_category_get_color :: +    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"+    IO Word32+++debugCategoryGetColor ::+    (MonadIO m) =>+    DebugCategory                           -- _obj+    -> m Word32                             -- result+debugCategoryGetColor _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_debug_category_get_color _obj'+    touchManagedPtr _obj+    return result++data DebugCategoryGetColorMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo DebugCategoryGetColorMethodInfo DebugCategory signature where+    overloadedMethod _ = debugCategoryGetColor++-- method DebugCategory::get_description+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_category_get_description" gst_debug_category_get_description :: +    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"+    IO CString+++debugCategoryGetDescription ::+    (MonadIO m) =>+    DebugCategory                           -- _obj+    -> m T.Text                             -- result+debugCategoryGetDescription _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_debug_category_get_description _obj'+    checkUnexpectedReturnNULL "gst_debug_category_get_description" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data DebugCategoryGetDescriptionMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DebugCategoryGetDescriptionMethodInfo DebugCategory signature where+    overloadedMethod _ = debugCategoryGetDescription++-- method DebugCategory::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_category_get_name" gst_debug_category_get_name :: +    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"+    IO CString+++debugCategoryGetName ::+    (MonadIO m) =>+    DebugCategory                           -- _obj+    -> m T.Text                             -- result+debugCategoryGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_debug_category_get_name _obj'+    checkUnexpectedReturnNULL "gst_debug_category_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data DebugCategoryGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DebugCategoryGetNameMethodInfo DebugCategory signature where+    overloadedMethod _ = debugCategoryGetName++-- method DebugCategory::get_threshold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "DebugLevel"+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_category_get_threshold" gst_debug_category_get_threshold :: +    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"+    IO CUInt+++debugCategoryGetThreshold ::+    (MonadIO m) =>+    DebugCategory                           -- _obj+    -> m DebugLevel                         -- result+debugCategoryGetThreshold _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_debug_category_get_threshold _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data DebugCategoryGetThresholdMethodInfo+instance (signature ~ (m DebugLevel), MonadIO m) => MethodInfo DebugCategoryGetThresholdMethodInfo DebugCategory signature where+    overloadedMethod _ = debugCategoryGetThreshold++-- method DebugCategory::reset_threshold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_category_reset_threshold" gst_debug_category_reset_threshold :: +    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"+    IO ()+++debugCategoryResetThreshold ::+    (MonadIO m) =>+    DebugCategory                           -- _obj+    -> m ()                                 -- result+debugCategoryResetThreshold _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_debug_category_reset_threshold _obj'+    touchManagedPtr _obj+    return ()++data DebugCategoryResetThresholdMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo DebugCategoryResetThresholdMethodInfo DebugCategory signature where+    overloadedMethod _ = debugCategoryResetThreshold++-- method DebugCategory::set_threshold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_category_set_threshold" gst_debug_category_set_threshold :: +    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"+    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"+    IO ()+++debugCategorySetThreshold ::+    (MonadIO m) =>+    DebugCategory                           -- _obj+    -> DebugLevel                           -- level+    -> m ()                                 -- result+debugCategorySetThreshold _obj level = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let level' = (fromIntegral . fromEnum) level+    gst_debug_category_set_threshold _obj' level'+    touchManagedPtr _obj+    return ()++data DebugCategorySetThresholdMethodInfo+instance (signature ~ (DebugLevel -> m ()), MonadIO m) => MethodInfo DebugCategorySetThresholdMethodInfo DebugCategory signature where+    overloadedMethod _ = debugCategorySetThreshold++type family ResolveDebugCategoryMethod (t :: Symbol) (o :: *) :: * where+    ResolveDebugCategoryMethod "free" o = DebugCategoryFreeMethodInfo+    ResolveDebugCategoryMethod "resetThreshold" o = DebugCategoryResetThresholdMethodInfo+    ResolveDebugCategoryMethod "getColor" o = DebugCategoryGetColorMethodInfo+    ResolveDebugCategoryMethod "getDescription" o = DebugCategoryGetDescriptionMethodInfo+    ResolveDebugCategoryMethod "getName" o = DebugCategoryGetNameMethodInfo+    ResolveDebugCategoryMethod "getThreshold" o = DebugCategoryGetThresholdMethodInfo+    ResolveDebugCategoryMethod "setThreshold" o = DebugCategorySetThresholdMethodInfo+    ResolveDebugCategoryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveDebugCategoryMethod t DebugCategory, MethodInfo info DebugCategory p) => IsLabelProxy t (DebugCategory -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveDebugCategoryMethod t DebugCategory, MethodInfo info DebugCategory p) => IsLabel t (DebugCategory -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/DebugCategory.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gst.Structs.DebugCategory 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++newtype DebugCategory = DebugCategory (ForeignPtr DebugCategory)+data DebugCategoryFreeMethodInfo+data DebugCategoryGetColorMethodInfo+data DebugCategoryGetDescriptionMethodInfo+data DebugCategoryGetNameMethodInfo+data DebugCategoryGetThresholdMethodInfo+data DebugCategoryResetThresholdMethodInfo+data DebugCategorySetThresholdMethodInfo
+ GI/Gst/Structs/DebugMessage.hs view
@@ -0,0 +1,82 @@+++{- |+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.Structs.DebugMessage+    ( ++-- * Exported types+    DebugMessage(..)                        ,+    noDebugMessage                          ,+++ -- * Methods+-- ** debugMessageGet+    DebugMessageGetMethodInfo               ,+    debugMessageGet                         ,+++++    ) 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 GI.Gst.Callbacks++newtype DebugMessage = DebugMessage (ForeignPtr DebugMessage)+noDebugMessage :: Maybe DebugMessage+noDebugMessage = Nothing++-- method DebugMessage::get+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_debug_message_get" gst_debug_message_get :: +    Ptr DebugMessage ->                     -- _obj : TInterface "Gst" "DebugMessage"+    IO CString+++debugMessageGet ::+    (MonadIO m) =>+    DebugMessage                            -- _obj+    -> m T.Text                             -- result+debugMessageGet _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_debug_message_get _obj'+    checkUnexpectedReturnNULL "gst_debug_message_get" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data DebugMessageGetMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DebugMessageGetMethodInfo DebugMessage signature where+    overloadedMethod _ = debugMessageGet++type family ResolveDebugMessageMethod (t :: Symbol) (o :: *) :: * where+    ResolveDebugMessageMethod "get" o = DebugMessageGetMethodInfo+    ResolveDebugMessageMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveDebugMessageMethod t DebugMessage, MethodInfo info DebugMessage p) => IsLabelProxy t (DebugMessage -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveDebugMessageMethod t DebugMessage, MethodInfo info DebugMessage p) => IsLabel t (DebugMessage -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/DebugMessage.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gst.Structs.DebugMessage 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++newtype DebugMessage = DebugMessage (ForeignPtr DebugMessage)+data DebugMessageGetMethodInfo
+ GI/Gst/Structs/Event.hs view
@@ -0,0 +1,1915 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The event class provides factory methods to construct events for sending+and functions to query (parse) received events.++Events are usually created with gst_event_new_*() which takes event-type+specific parameters as arguments.+To send an event application will usually use gst_element_send_event() and+elements will use gst_pad_send_event() or gst_pad_push_event().+The event should be unreffed with gst_event_unref() if it has not been sent.++Events that have been received can be parsed with their respective+gst_event_parse_*() functions. It is valid to pass %NULL for unwanted details.++Events are passed between elements in parallel to the data stream. Some events+are serialized with buffers, others are not. Some events only travel downstream,+others only upstream. Some events can travel both upstream and downstream.++The events are used to signal special conditions in the datastream such as+EOS (end of stream) or the start of a new stream-segment.+Events are also used to flush the pipeline of any pending data.++Most of the event API is used inside plugins. Applications usually only+construct and use seek events.+To do that gst_event_new_seek() is used to create a seek event. It takes+the needed parameters to specify seeking time and mode.+|[+  GstEvent *event;+  gboolean result;+  ...+  // construct a seek event to play the media from second 2 to 5, flush+  // the pipeline to decrease latency.+  event = gst_event_new_seek (1.0,+     GST_FORMAT_TIME,+     GST_SEEK_FLAG_FLUSH,+     GST_SEEK_TYPE_SET, 2 * GST_SECOND,+     GST_SEEK_TYPE_SET, 5 * GST_SECOND);+  ...+  result = gst_element_send_event (pipeline, event);+  if (!result)+    g_warning ("seek failed");+  ...+]|+-}++module GI.Gst.Structs.Event+    ( ++-- * Exported types+    Event(..)                               ,+    newZeroEvent                            ,+    noEvent                                 ,+++ -- * Methods+-- ** eventCopySegment+    EventCopySegmentMethodInfo              ,+    eventCopySegment                        ,+++-- ** eventGetRunningTimeOffset+    EventGetRunningTimeOffsetMethodInfo     ,+    eventGetRunningTimeOffset               ,+++-- ** eventGetSeqnum+    EventGetSeqnumMethodInfo                ,+    eventGetSeqnum                          ,+++-- ** eventGetStructure+    EventGetStructureMethodInfo             ,+    eventGetStructure                       ,+++-- ** eventHasName+    EventHasNameMethodInfo                  ,+    eventHasName                            ,+++-- ** eventNewBufferSize+    eventNewBufferSize                      ,+++-- ** eventNewCaps+    eventNewCaps                            ,+++-- ** eventNewCustom+    eventNewCustom                          ,+++-- ** eventNewEos+    eventNewEos                             ,+++-- ** eventNewFlushStart+    eventNewFlushStart                      ,+++-- ** eventNewFlushStop+    eventNewFlushStop                       ,+++-- ** eventNewGap+    eventNewGap                             ,+++-- ** eventNewLatency+    eventNewLatency                         ,+++-- ** eventNewNavigation+    eventNewNavigation                      ,+++-- ** eventNewProtection+    eventNewProtection                      ,+++-- ** eventNewQos+    eventNewQos                             ,+++-- ** eventNewReconfigure+    eventNewReconfigure                     ,+++-- ** eventNewSeek+    eventNewSeek                            ,+++-- ** eventNewSegment+    eventNewSegment                         ,+++-- ** eventNewSegmentDone+    eventNewSegmentDone                     ,+++-- ** eventNewSinkMessage+    eventNewSinkMessage                     ,+++-- ** eventNewStep+    eventNewStep                            ,+++-- ** eventNewStreamStart+    eventNewStreamStart                     ,+++-- ** eventNewTag+    eventNewTag                             ,+++-- ** eventNewToc+    eventNewToc                             ,+++-- ** eventNewTocSelect+    eventNewTocSelect                       ,+++-- ** eventParseBufferSize+    EventParseBufferSizeMethodInfo          ,+    eventParseBufferSize                    ,+++-- ** eventParseCaps+    EventParseCapsMethodInfo                ,+    eventParseCaps                          ,+++-- ** eventParseFlushStop+    EventParseFlushStopMethodInfo           ,+    eventParseFlushStop                     ,+++-- ** eventParseGap+    EventParseGapMethodInfo                 ,+    eventParseGap                           ,+++-- ** eventParseGroupId+    EventParseGroupIdMethodInfo             ,+    eventParseGroupId                       ,+++-- ** eventParseLatency+    EventParseLatencyMethodInfo             ,+    eventParseLatency                       ,+++-- ** eventParseProtection+    EventParseProtectionMethodInfo          ,+    eventParseProtection                    ,+++-- ** eventParseQos+    EventParseQosMethodInfo                 ,+    eventParseQos                           ,+++-- ** eventParseSeek+    EventParseSeekMethodInfo                ,+    eventParseSeek                          ,+++-- ** eventParseSegment+    EventParseSegmentMethodInfo             ,+    eventParseSegment                       ,+++-- ** eventParseSegmentDone+    EventParseSegmentDoneMethodInfo         ,+    eventParseSegmentDone                   ,+++-- ** eventParseSinkMessage+    EventParseSinkMessageMethodInfo         ,+    eventParseSinkMessage                   ,+++-- ** eventParseStep+    EventParseStepMethodInfo                ,+    eventParseStep                          ,+++-- ** eventParseStreamFlags+    EventParseStreamFlagsMethodInfo         ,+    eventParseStreamFlags                   ,+++-- ** eventParseStreamStart+    EventParseStreamStartMethodInfo         ,+    eventParseStreamStart                   ,+++-- ** eventParseTag+    EventParseTagMethodInfo                 ,+    eventParseTag                           ,+++-- ** eventParseToc+    EventParseTocMethodInfo                 ,+    eventParseToc                           ,+++-- ** eventParseTocSelect+    EventParseTocSelectMethodInfo           ,+    eventParseTocSelect                     ,+++-- ** eventSetGroupId+    EventSetGroupIdMethodInfo               ,+    eventSetGroupId                         ,+++-- ** eventSetRunningTimeOffset+    EventSetRunningTimeOffsetMethodInfo     ,+    eventSetRunningTimeOffset               ,+++-- ** eventSetSeqnum+    EventSetSeqnumMethodInfo                ,+    eventSetSeqnum                          ,+++-- ** eventSetStreamFlags+    EventSetStreamFlagsMethodInfo           ,+    eventSetStreamFlags                     ,+++-- ** eventWritableStructure+    EventWritableStructureMethodInfo        ,+    eventWritableStructure                  ,+++++ -- * Properties+-- ** MiniObject+    eventReadMiniObject                     ,+++-- ** Seqnum+    eventReadSeqnum                         ,+++-- ** Timestamp+    eventReadTimestamp                      ,+++-- ** Type+    eventReadType                           ,+++++    ) 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 GI.Gst.Callbacks++newtype Event = Event (ForeignPtr Event)+foreign import ccall "gst_event_get_type" c_gst_event_get_type :: +    IO GType++instance BoxedObject Event where+    boxedType _ = c_gst_event_get_type++-- | Construct a `Event` struct initialized to zero.+newZeroEvent :: MonadIO m => m Event+newZeroEvent = liftIO $ callocBoxedBytes 88 >>= wrapBoxed Event++noEvent :: Maybe Event+noEvent = Nothing++eventReadMiniObject :: Event -> IO MiniObject+eventReadMiniObject s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)+    val' <- (newPtr 64 MiniObject) val+    return val'++eventReadType :: Event -> IO EventType+eventReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++eventReadTimestamp :: Event -> IO Word64+eventReadTimestamp s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO Word64+    return val++eventReadSeqnum :: Event -> IO Word32+eventReadSeqnum s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 80) :: IO Word32+    return val++-- method Event::new_buffer_size+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minsize", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "async", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_buffer_size" gst_event_new_buffer_size :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- minsize : TBasicType TInt64+    Int64 ->                                -- maxsize : TBasicType TInt64+    CInt ->                                 -- async : TBasicType TBoolean+    IO (Ptr Event)+++eventNewBufferSize ::+    (MonadIO m) =>+    Format                                  -- format+    -> Int64                                -- minsize+    -> Int64                                -- maxsize+    -> Bool                                 -- async+    -> m Event                              -- result+eventNewBufferSize format minsize maxsize async = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    let async' = (fromIntegral . fromEnum) async+    result <- gst_event_new_buffer_size format' minsize maxsize async'+    checkUnexpectedReturnNULL "gst_event_new_buffer_size" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_caps+-- method type : Constructor+-- Args : [Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_caps" gst_event_new_caps :: +    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO (Ptr Event)+++eventNewCaps ::+    (MonadIO m) =>+    Caps                                    -- caps+    -> m Event                              -- result+eventNewCaps caps = liftIO $ do+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_event_new_caps caps'+    checkUnexpectedReturnNULL "gst_event_new_caps" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr caps+    return result'++-- method Event::new_custom+-- method type : Constructor+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "EventType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_custom" gst_event_new_custom :: +    CUInt ->                                -- type : TInterface "Gst" "EventType"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO (Ptr Event)+++eventNewCustom ::+    (MonadIO m) =>+    EventType                               -- type_+    -> Structure                            -- structure+    -> m Event                              -- result+eventNewCustom type_ structure = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    structure' <- copyBoxed structure+    result <- gst_event_new_custom type_' structure'+    checkUnexpectedReturnNULL "gst_event_new_custom" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr structure+    return result'++-- method Event::new_eos+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_eos" gst_event_new_eos :: +    IO (Ptr Event)+++eventNewEos ::+    (MonadIO m) =>+    m Event                                 -- result+eventNewEos  = liftIO $ do+    result <- gst_event_new_eos+    checkUnexpectedReturnNULL "gst_event_new_eos" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_flush_start+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_flush_start" gst_event_new_flush_start :: +    IO (Ptr Event)+++eventNewFlushStart ::+    (MonadIO m) =>+    m Event                                 -- result+eventNewFlushStart  = liftIO $ do+    result <- gst_event_new_flush_start+    checkUnexpectedReturnNULL "gst_event_new_flush_start" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_flush_stop+-- method type : Constructor+-- Args : [Arg {argCName = "reset_time", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_flush_stop" gst_event_new_flush_stop :: +    CInt ->                                 -- reset_time : TBasicType TBoolean+    IO (Ptr Event)+++eventNewFlushStop ::+    (MonadIO m) =>+    Bool                                    -- resetTime+    -> m Event                              -- result+eventNewFlushStop resetTime = liftIO $ do+    let resetTime' = (fromIntegral . fromEnum) resetTime+    result <- gst_event_new_flush_stop resetTime'+    checkUnexpectedReturnNULL "gst_event_new_flush_stop" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_gap+-- method type : Constructor+-- Args : [Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_gap" gst_event_new_gap :: +    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- duration : TBasicType TUInt64+    IO (Ptr Event)+++eventNewGap ::+    (MonadIO m) =>+    Word64                                  -- timestamp+    -> Word64                               -- duration+    -> m Event                              -- result+eventNewGap timestamp duration = liftIO $ do+    result <- gst_event_new_gap timestamp duration+    checkUnexpectedReturnNULL "gst_event_new_gap" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_latency+-- method type : Constructor+-- Args : [Arg {argCName = "latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_latency" gst_event_new_latency :: +    Word64 ->                               -- latency : TBasicType TUInt64+    IO (Ptr Event)+++eventNewLatency ::+    (MonadIO m) =>+    Word64                                  -- latency+    -> m Event                              -- result+eventNewLatency latency = liftIO $ do+    result <- gst_event_new_latency latency+    checkUnexpectedReturnNULL "gst_event_new_latency" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_navigation+-- method type : Constructor+-- Args : [Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_navigation" gst_event_new_navigation :: +    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO (Ptr Event)+++eventNewNavigation ::+    (MonadIO m) =>+    Structure                               -- structure+    -> m Event                              -- result+eventNewNavigation structure = liftIO $ do+    structure' <- copyBoxed structure+    result <- gst_event_new_navigation structure'+    checkUnexpectedReturnNULL "gst_event_new_navigation" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr structure+    return result'++-- method Event::new_protection+-- method type : Constructor+-- Args : [Arg {argCName = "system_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_protection" gst_event_new_protection :: +    CString ->                              -- system_id : TBasicType TUTF8+    Ptr Buffer ->                           -- data : TInterface "Gst" "Buffer"+    CString ->                              -- origin : TBasicType TUTF8+    IO (Ptr Event)+++eventNewProtection ::+    (MonadIO m) =>+    T.Text                                  -- systemId+    -> Buffer                               -- data_+    -> T.Text                               -- origin+    -> m Event                              -- result+eventNewProtection systemId data_ origin = liftIO $ do+    systemId' <- textToCString systemId+    let data_' = unsafeManagedPtrGetPtr data_+    origin' <- textToCString origin+    result <- gst_event_new_protection systemId' data_' origin'+    checkUnexpectedReturnNULL "gst_event_new_protection" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr data_+    freeMem systemId'+    freeMem origin'+    return result'++-- method Event::new_qos+-- method type : Constructor+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "QOSType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_qos" gst_event_new_qos :: +    CUInt ->                                -- type : TInterface "Gst" "QOSType"+    CDouble ->                              -- proportion : TBasicType TDouble+    Int64 ->                                -- diff : TBasicType TInt64+    Word64 ->                               -- timestamp : TBasicType TUInt64+    IO (Ptr Event)+++eventNewQos ::+    (MonadIO m) =>+    QOSType                                 -- type_+    -> Double                               -- proportion+    -> Int64                                -- diff+    -> Word64                               -- timestamp+    -> m Event                              -- result+eventNewQos type_ proportion diff timestamp = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    let proportion' = realToFrac proportion+    result <- gst_event_new_qos type_' proportion' diff timestamp+    checkUnexpectedReturnNULL "gst_event_new_qos" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_reconfigure+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_reconfigure" gst_event_new_reconfigure :: +    IO (Ptr Event)+++eventNewReconfigure ::+    (MonadIO m) =>+    m Event                                 -- result+eventNewReconfigure  = liftIO $ do+    result <- gst_event_new_reconfigure+    checkUnexpectedReturnNULL "gst_event_new_reconfigure" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_seek+-- method type : Constructor+-- Args : [Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_seek" gst_event_new_seek :: +    CDouble ->                              -- rate : TBasicType TDouble+    CUInt ->                                -- format : TInterface "Gst" "Format"+    CUInt ->                                -- flags : TInterface "Gst" "SeekFlags"+    CUInt ->                                -- start_type : TInterface "Gst" "SeekType"+    Int64 ->                                -- start : TBasicType TInt64+    CUInt ->                                -- stop_type : TInterface "Gst" "SeekType"+    Int64 ->                                -- stop : TBasicType TInt64+    IO (Ptr Event)+++eventNewSeek ::+    (MonadIO m) =>+    Double                                  -- rate+    -> Format                               -- format+    -> [SeekFlags]                          -- flags+    -> SeekType                             -- startType+    -> Int64                                -- start+    -> SeekType                             -- stopType+    -> Int64                                -- stop+    -> m Event                              -- result+eventNewSeek rate format flags startType start stopType stop = liftIO $ do+    let rate' = realToFrac rate+    let format' = (fromIntegral . fromEnum) format+    let flags' = gflagsToWord flags+    let startType' = (fromIntegral . fromEnum) startType+    let stopType' = (fromIntegral . fromEnum) stopType+    result <- gst_event_new_seek rate' format' flags' startType' start stopType' stop+    checkUnexpectedReturnNULL "gst_event_new_seek" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_segment+-- method type : Constructor+-- Args : [Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_segment" gst_event_new_segment :: +    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"+    IO (Ptr Event)+++eventNewSegment ::+    (MonadIO m) =>+    Segment                                 -- segment+    -> m Event                              -- result+eventNewSegment segment = liftIO $ do+    let segment' = unsafeManagedPtrGetPtr segment+    result <- gst_event_new_segment segment'+    checkUnexpectedReturnNULL "gst_event_new_segment" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr segment+    return result'++-- method Event::new_segment_done+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_segment_done" gst_event_new_segment_done :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- position : TBasicType TInt64+    IO (Ptr Event)+++eventNewSegmentDone ::+    (MonadIO m) =>+    Format                                  -- format+    -> Int64                                -- position+    -> m Event                              -- result+eventNewSegmentDone format position = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- gst_event_new_segment_done format' position+    checkUnexpectedReturnNULL "gst_event_new_segment_done" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_sink_message+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_sink_message" gst_event_new_sink_message :: +    CString ->                              -- name : TBasicType TUTF8+    Ptr Message ->                          -- msg : TInterface "Gst" "Message"+    IO (Ptr Event)+++eventNewSinkMessage ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> Message                              -- msg+    -> m Event                              -- result+eventNewSinkMessage name msg = liftIO $ do+    name' <- textToCString name+    let msg' = unsafeManagedPtrGetPtr msg+    result <- gst_event_new_sink_message name' msg'+    checkUnexpectedReturnNULL "gst_event_new_sink_message" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr msg+    freeMem name'+    return result'++-- method Event::new_step+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_step" gst_event_new_step :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- amount : TBasicType TUInt64+    CDouble ->                              -- rate : TBasicType TDouble+    CInt ->                                 -- flush : TBasicType TBoolean+    CInt ->                                 -- intermediate : TBasicType TBoolean+    IO (Ptr Event)+++eventNewStep ::+    (MonadIO m) =>+    Format                                  -- format+    -> Word64                               -- amount+    -> Double                               -- rate+    -> Bool                                 -- flush+    -> Bool                                 -- intermediate+    -> m Event                              -- result+eventNewStep format amount rate flush intermediate = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    let rate' = realToFrac rate+    let flush' = (fromIntegral . fromEnum) flush+    let intermediate' = (fromIntegral . fromEnum) intermediate+    result <- gst_event_new_step format' amount rate' flush' intermediate'+    checkUnexpectedReturnNULL "gst_event_new_step" result+    result' <- (wrapBoxed Event) result+    return result'++-- method Event::new_stream_start+-- method type : Constructor+-- Args : [Arg {argCName = "stream_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_stream_start" gst_event_new_stream_start :: +    CString ->                              -- stream_id : TBasicType TUTF8+    IO (Ptr Event)+++eventNewStreamStart ::+    (MonadIO m) =>+    T.Text                                  -- streamId+    -> m Event                              -- result+eventNewStreamStart streamId = liftIO $ do+    streamId' <- textToCString streamId+    result <- gst_event_new_stream_start streamId'+    checkUnexpectedReturnNULL "gst_event_new_stream_start" result+    result' <- (wrapBoxed Event) result+    freeMem streamId'+    return result'++-- method Event::new_tag+-- method type : Constructor+-- Args : [Arg {argCName = "taglist", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_tag" gst_event_new_tag :: +    Ptr TagList ->                          -- taglist : TInterface "Gst" "TagList"+    IO (Ptr Event)+++eventNewTag ::+    (MonadIO m) =>+    TagList                                 -- taglist+    -> m Event                              -- result+eventNewTag taglist = liftIO $ do+    taglist' <- copyBoxed taglist+    result <- gst_event_new_tag taglist'+    checkUnexpectedReturnNULL "gst_event_new_tag" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr taglist+    return result'++-- method Event::new_toc+-- method type : Constructor+-- Args : [Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_toc" gst_event_new_toc :: +    Ptr Toc ->                              -- toc : TInterface "Gst" "Toc"+    CInt ->                                 -- updated : TBasicType TBoolean+    IO (Ptr Event)+++eventNewToc ::+    (MonadIO m) =>+    Toc                                     -- toc+    -> Bool                                 -- updated+    -> m Event                              -- result+eventNewToc toc updated = liftIO $ do+    let toc' = unsafeManagedPtrGetPtr toc+    let updated' = (fromIntegral . fromEnum) updated+    result <- gst_event_new_toc toc' updated'+    checkUnexpectedReturnNULL "gst_event_new_toc" result+    result' <- (wrapBoxed Event) result+    touchManagedPtr toc+    return result'++-- method Event::new_toc_select+-- method type : Constructor+-- Args : [Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_new_toc_select" gst_event_new_toc_select :: +    CString ->                              -- uid : TBasicType TUTF8+    IO (Ptr Event)+++eventNewTocSelect ::+    (MonadIO m) =>+    T.Text                                  -- uid+    -> m Event                              -- result+eventNewTocSelect uid = liftIO $ do+    uid' <- textToCString uid+    result <- gst_event_new_toc_select uid'+    checkUnexpectedReturnNULL "gst_event_new_toc_select" result+    result' <- (wrapBoxed Event) result+    freeMem uid'+    return result'++-- method Event::copy_segment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_copy_segment" gst_event_copy_segment :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"+    IO ()+++eventCopySegment ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> Segment                              -- segment+    -> m ()                                 -- result+eventCopySegment _obj segment = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let segment' = unsafeManagedPtrGetPtr segment+    gst_event_copy_segment _obj' segment'+    touchManagedPtr _obj+    touchManagedPtr segment+    return ()++data EventCopySegmentMethodInfo+instance (signature ~ (Segment -> m ()), MonadIO m) => MethodInfo EventCopySegmentMethodInfo Event signature where+    overloadedMethod _ = eventCopySegment++-- method Event::get_running_time_offset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_get_running_time_offset" gst_event_get_running_time_offset :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    IO Int64+++eventGetRunningTimeOffset ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m Int64                              -- result+eventGetRunningTimeOffset _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_event_get_running_time_offset _obj'+    touchManagedPtr _obj+    return result++data EventGetRunningTimeOffsetMethodInfo+instance (signature ~ (m Int64), MonadIO m) => MethodInfo EventGetRunningTimeOffsetMethodInfo Event signature where+    overloadedMethod _ = eventGetRunningTimeOffset++-- method Event::get_seqnum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_get_seqnum" gst_event_get_seqnum :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    IO Word32+++eventGetSeqnum ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m Word32                             -- result+eventGetSeqnum _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_event_get_seqnum _obj'+    touchManagedPtr _obj+    return result++data EventGetSeqnumMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo EventGetSeqnumMethodInfo Event signature where+    overloadedMethod _ = eventGetSeqnum++-- method Event::get_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_get_structure" gst_event_get_structure :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    IO (Ptr Structure)+++eventGetStructure ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m Structure                          -- result+eventGetStructure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_event_get_structure _obj'+    checkUnexpectedReturnNULL "gst_event_get_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data EventGetStructureMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo EventGetStructureMethodInfo Event signature where+    overloadedMethod _ = eventGetStructure++-- method Event::has_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_has_name" gst_event_has_name :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++eventHasName ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> T.Text                               -- name+    -> m Bool                               -- result+eventHasName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- gst_event_has_name _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data EventHasNameMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo EventHasNameMethodInfo Event signature where+    overloadedMethod _ = eventHasName++-- method Event::parse_buffer_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minsize", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "async", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_buffer_size" gst_event_parse_buffer_size :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- minsize : TBasicType TInt64+    Ptr Int64 ->                            -- maxsize : TBasicType TInt64+    Ptr CInt ->                             -- async : TBasicType TBoolean+    IO ()+++eventParseBufferSize ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Format,Int64,Int64,Bool)          -- result+eventParseBufferSize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    minsize <- allocMem :: IO (Ptr Int64)+    maxsize <- allocMem :: IO (Ptr Int64)+    async <- allocMem :: IO (Ptr CInt)+    gst_event_parse_buffer_size _obj' format minsize maxsize async+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    minsize' <- peek minsize+    maxsize' <- peek maxsize+    async' <- peek async+    let async'' = (/= 0) async'+    touchManagedPtr _obj+    freeMem format+    freeMem minsize+    freeMem maxsize+    freeMem async+    return (format'', minsize', maxsize', async'')++data EventParseBufferSizeMethodInfo+instance (signature ~ (m (Format,Int64,Int64,Bool)), MonadIO m) => MethodInfo EventParseBufferSizeMethodInfo Event signature where+    overloadedMethod _ = eventParseBufferSize++-- method Event::parse_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_caps" gst_event_parse_caps :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO ()+++eventParseCaps ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Caps)                             -- result+eventParseCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)+    gst_event_parse_caps _obj' caps+    caps' <- (wrapBoxed Caps) caps+    touchManagedPtr _obj+    return caps'++data EventParseCapsMethodInfo+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo EventParseCapsMethodInfo Event signature where+    overloadedMethod _ = eventParseCaps++-- method Event::parse_flush_stop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reset_time", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_flush_stop" gst_event_parse_flush_stop :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CInt ->                             -- reset_time : TBasicType TBoolean+    IO ()+++eventParseFlushStop ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Bool)                             -- result+eventParseFlushStop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    resetTime <- allocMem :: IO (Ptr CInt)+    gst_event_parse_flush_stop _obj' resetTime+    resetTime' <- peek resetTime+    let resetTime'' = (/= 0) resetTime'+    touchManagedPtr _obj+    freeMem resetTime+    return resetTime''++data EventParseFlushStopMethodInfo+instance (signature ~ (m (Bool)), MonadIO m) => MethodInfo EventParseFlushStopMethodInfo Event signature where+    overloadedMethod _ = eventParseFlushStop++-- method Event::parse_gap+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_gap" gst_event_parse_gap :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr Word64 ->                           -- timestamp : TBasicType TUInt64+    Ptr Word64 ->                           -- duration : TBasicType TUInt64+    IO ()+++eventParseGap ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Word64,Word64)                    -- result+eventParseGap _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    timestamp <- allocMem :: IO (Ptr Word64)+    duration <- allocMem :: IO (Ptr Word64)+    gst_event_parse_gap _obj' timestamp duration+    timestamp' <- peek timestamp+    duration' <- peek duration+    touchManagedPtr _obj+    freeMem timestamp+    freeMem duration+    return (timestamp', duration')++data EventParseGapMethodInfo+instance (signature ~ (m (Word64,Word64)), MonadIO m) => MethodInfo EventParseGapMethodInfo Event signature where+    overloadedMethod _ = eventParseGap++-- method Event::parse_group_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_group_id" gst_event_parse_group_id :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr Word32 ->                           -- group_id : TBasicType TUInt32+    IO CInt+++eventParseGroupId ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Bool,Word32)                      -- result+eventParseGroupId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    groupId <- allocMem :: IO (Ptr Word32)+    result <- gst_event_parse_group_id _obj' groupId+    let result' = (/= 0) result+    groupId' <- peek groupId+    touchManagedPtr _obj+    freeMem groupId+    return (result', groupId')++data EventParseGroupIdMethodInfo+instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo EventParseGroupIdMethodInfo Event signature where+    overloadedMethod _ = eventParseGroupId++-- method Event::parse_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_latency" gst_event_parse_latency :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr Word64 ->                           -- latency : TBasicType TUInt64+    IO ()+++eventParseLatency ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Word64)                           -- result+eventParseLatency _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    latency <- allocMem :: IO (Ptr Word64)+    gst_event_parse_latency _obj' latency+    latency' <- peek latency+    touchManagedPtr _obj+    freeMem latency+    return latency'++data EventParseLatencyMethodInfo+instance (signature ~ (m (Word64)), MonadIO m) => MethodInfo EventParseLatencyMethodInfo Event signature where+    overloadedMethod _ = eventParseLatency++-- method Event::parse_protection+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "system_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_protection" gst_event_parse_protection :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CString ->                          -- system_id : TBasicType TUTF8+    Ptr Buffer ->                           -- data : TInterface "Gst" "Buffer"+    CString ->                              -- origin : TBasicType TUTF8+    IO ()+++eventParseProtection ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> Maybe (T.Text)                       -- origin+    -> m (T.Text,Buffer)                    -- result+eventParseProtection _obj origin = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    systemId <- allocMem :: IO (Ptr CString)+    data_ <- callocBoxedBytes 112 :: IO (Ptr Buffer)+    maybeOrigin <- case origin of+        Nothing -> return nullPtr+        Just jOrigin -> do+            jOrigin' <- textToCString jOrigin+            return jOrigin'+    gst_event_parse_protection _obj' systemId data_ maybeOrigin+    systemId' <- peek systemId+    systemId'' <- cstringToText systemId'+    data_' <- (wrapBoxed Buffer) data_+    touchManagedPtr _obj+    freeMem systemId+    freeMem maybeOrigin+    return (systemId'', data_')++data EventParseProtectionMethodInfo+instance (signature ~ (Maybe (T.Text) -> m (T.Text,Buffer)), MonadIO m) => MethodInfo EventParseProtectionMethodInfo Event signature where+    overloadedMethod _ = eventParseProtection++-- method Event::parse_qos+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "QOSType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "diff", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_qos" gst_event_parse_qos :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CUInt ->                            -- type : TInterface "Gst" "QOSType"+    Ptr CDouble ->                          -- proportion : TBasicType TDouble+    Ptr Int64 ->                            -- diff : TBasicType TInt64+    Ptr Word64 ->                           -- timestamp : TBasicType TUInt64+    IO ()+++eventParseQos ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (QOSType,Double,Int64,Word64)      -- result+eventParseQos _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    type_ <- allocMem :: IO (Ptr CUInt)+    proportion <- allocMem :: IO (Ptr CDouble)+    diff <- allocMem :: IO (Ptr Int64)+    timestamp <- allocMem :: IO (Ptr Word64)+    gst_event_parse_qos _obj' type_ proportion diff timestamp+    type_' <- peek type_+    let type_'' = (toEnum . fromIntegral) type_'+    proportion' <- peek proportion+    let proportion'' = realToFrac proportion'+    diff' <- peek diff+    timestamp' <- peek timestamp+    touchManagedPtr _obj+    freeMem type_+    freeMem proportion+    freeMem diff+    freeMem timestamp+    return (type_'', proportion'', diff', timestamp')++data EventParseQosMethodInfo+instance (signature ~ (m (QOSType,Double,Int64,Word64)), MonadIO m) => MethodInfo EventParseQosMethodInfo Event signature where+    overloadedMethod _ = eventParseQos++-- method Event::parse_seek+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_seek" gst_event_parse_seek :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CDouble ->                          -- rate : TBasicType TDouble+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr CUInt ->                            -- flags : TInterface "Gst" "SeekFlags"+    Ptr CUInt ->                            -- start_type : TInterface "Gst" "SeekType"+    Ptr Int64 ->                            -- start : TBasicType TInt64+    Ptr CUInt ->                            -- stop_type : TInterface "Gst" "SeekType"+    Ptr Int64 ->                            -- stop : TBasicType TInt64+    IO ()+++eventParseSeek ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Double,Format,[SeekFlags],SeekType,Int64,SeekType,Int64)-- result+eventParseSeek _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    rate <- allocMem :: IO (Ptr CDouble)+    format <- allocMem :: IO (Ptr CUInt)+    flags <- allocMem :: IO (Ptr CUInt)+    startType <- allocMem :: IO (Ptr CUInt)+    start <- allocMem :: IO (Ptr Int64)+    stopType <- allocMem :: IO (Ptr CUInt)+    stop <- allocMem :: IO (Ptr Int64)+    gst_event_parse_seek _obj' rate format flags startType start stopType stop+    rate' <- peek rate+    let rate'' = realToFrac rate'+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    flags' <- peek flags+    let flags'' = wordToGFlags flags'+    startType' <- peek startType+    let startType'' = (toEnum . fromIntegral) startType'+    start' <- peek start+    stopType' <- peek stopType+    let stopType'' = (toEnum . fromIntegral) stopType'+    stop' <- peek stop+    touchManagedPtr _obj+    freeMem rate+    freeMem format+    freeMem flags+    freeMem startType+    freeMem start+    freeMem stopType+    freeMem stop+    return (rate'', format'', flags'', startType'', start', stopType'', stop')++data EventParseSeekMethodInfo+instance (signature ~ (m (Double,Format,[SeekFlags],SeekType,Int64,SeekType,Int64)), MonadIO m) => MethodInfo EventParseSeekMethodInfo Event signature where+    overloadedMethod _ = eventParseSeek++-- method Event::parse_segment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_segment" gst_event_parse_segment :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"+    IO ()+++eventParseSegment ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Segment)                          -- result+eventParseSegment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    segment <- callocBoxedBytes 120 :: IO (Ptr Segment)+    gst_event_parse_segment _obj' segment+    segment' <- (wrapBoxed Segment) segment+    touchManagedPtr _obj+    return segment'++data EventParseSegmentMethodInfo+instance (signature ~ (m (Segment)), MonadIO m) => MethodInfo EventParseSegmentMethodInfo Event signature where+    overloadedMethod _ = eventParseSegment++-- method Event::parse_segment_done+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_segment_done" gst_event_parse_segment_done :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- position : TBasicType TInt64+    IO ()+++eventParseSegmentDone ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Format,Int64)                     -- result+eventParseSegmentDone _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    position <- allocMem :: IO (Ptr Int64)+    gst_event_parse_segment_done _obj' format position+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    position' <- peek position+    touchManagedPtr _obj+    freeMem format+    freeMem position+    return (format'', position')++data EventParseSegmentDoneMethodInfo+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo EventParseSegmentDoneMethodInfo Event signature where+    overloadedMethod _ = eventParseSegmentDone++-- method Event::parse_sink_message+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface "Gst" "Message", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_sink_message" gst_event_parse_sink_message :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr Message ->                          -- msg : TInterface "Gst" "Message"+    IO ()+++eventParseSinkMessage ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Message)                          -- result+eventParseSinkMessage _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    msg <- callocBoxedBytes 120 :: IO (Ptr Message)+    gst_event_parse_sink_message _obj' msg+    msg' <- (wrapBoxed Message) msg+    touchManagedPtr _obj+    return msg'++data EventParseSinkMessageMethodInfo+instance (signature ~ (m (Message)), MonadIO m) => MethodInfo EventParseSinkMessageMethodInfo Event signature where+    overloadedMethod _ = eventParseSinkMessage++-- method Event::parse_step+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_step" gst_event_parse_step :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Word64 ->                           -- amount : TBasicType TUInt64+    Ptr CDouble ->                          -- rate : TBasicType TDouble+    Ptr CInt ->                             -- flush : TBasicType TBoolean+    Ptr CInt ->                             -- intermediate : TBasicType TBoolean+    IO ()+++eventParseStep ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Format,Word64,Double,Bool,Bool)   -- result+eventParseStep _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    amount <- allocMem :: IO (Ptr Word64)+    rate <- allocMem :: IO (Ptr CDouble)+    flush <- allocMem :: IO (Ptr CInt)+    intermediate <- allocMem :: IO (Ptr CInt)+    gst_event_parse_step _obj' format amount rate flush intermediate+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    amount' <- peek amount+    rate' <- peek rate+    let rate'' = realToFrac rate'+    flush' <- peek flush+    let flush'' = (/= 0) flush'+    intermediate' <- peek intermediate+    let intermediate'' = (/= 0) intermediate'+    touchManagedPtr _obj+    freeMem format+    freeMem amount+    freeMem rate+    freeMem flush+    freeMem intermediate+    return (format'', amount', rate'', flush'', intermediate'')++data EventParseStepMethodInfo+instance (signature ~ (m (Format,Word64,Double,Bool,Bool)), MonadIO m) => MethodInfo EventParseStepMethodInfo Event signature where+    overloadedMethod _ = eventParseStep++-- method Event::parse_stream_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "StreamFlags", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_stream_flags" gst_event_parse_stream_flags :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CUInt ->                            -- flags : TInterface "Gst" "StreamFlags"+    IO ()+++eventParseStreamFlags ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m ([StreamFlags])                    -- result+eventParseStreamFlags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    flags <- allocMem :: IO (Ptr CUInt)+    gst_event_parse_stream_flags _obj' flags+    flags' <- peek flags+    let flags'' = wordToGFlags flags'+    touchManagedPtr _obj+    freeMem flags+    return flags''++data EventParseStreamFlagsMethodInfo+instance (signature ~ (m ([StreamFlags])), MonadIO m) => MethodInfo EventParseStreamFlagsMethodInfo Event signature where+    overloadedMethod _ = eventParseStreamFlags++-- method Event::parse_stream_start+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_stream_start" gst_event_parse_stream_start :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CString ->                          -- stream_id : TBasicType TUTF8+    IO ()+++eventParseStreamStart ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (T.Text)                           -- result+eventParseStreamStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    streamId <- allocMem :: IO (Ptr CString)+    gst_event_parse_stream_start _obj' streamId+    streamId' <- peek streamId+    streamId'' <- cstringToText streamId'+    touchManagedPtr _obj+    freeMem streamId+    return streamId''++data EventParseStreamStartMethodInfo+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo EventParseStreamStartMethodInfo Event signature where+    overloadedMethod _ = eventParseStreamStart++-- method Event::parse_tag+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "taglist", argType = TInterface "Gst" "TagList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_tag" gst_event_parse_tag :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr TagList ->                          -- taglist : TInterface "Gst" "TagList"+    IO ()+++eventParseTag ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (TagList)                          -- result+eventParseTag _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    taglist <- callocBoxedBytes 64 :: IO (Ptr TagList)+    gst_event_parse_tag _obj' taglist+    taglist' <- (wrapBoxed TagList) taglist+    touchManagedPtr _obj+    return taglist'++data EventParseTagMethodInfo+instance (signature ~ (m (TagList)), MonadIO m) => MethodInfo EventParseTagMethodInfo Event signature where+    overloadedMethod _ = eventParseTag++-- method Event::parse_toc+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_toc" gst_event_parse_toc :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr (Ptr Toc) ->                        -- toc : TInterface "Gst" "Toc"+    Ptr CInt ->                             -- updated : TBasicType TBoolean+    IO ()+++eventParseToc ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (Toc,Bool)                         -- result+eventParseToc _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    toc <- allocMem :: IO (Ptr (Ptr Toc))+    updated <- allocMem :: IO (Ptr CInt)+    gst_event_parse_toc _obj' toc updated+    toc' <- peek toc+    toc'' <- (wrapBoxed Toc) toc'+    updated' <- peek updated+    let updated'' = (/= 0) updated'+    touchManagedPtr _obj+    freeMem toc+    freeMem updated+    return (toc'', updated'')++data EventParseTocMethodInfo+instance (signature ~ (m (Toc,Bool)), MonadIO m) => MethodInfo EventParseTocMethodInfo Event signature where+    overloadedMethod _ = eventParseToc++-- method Event::parse_toc_select+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_parse_toc_select" gst_event_parse_toc_select :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Ptr CString ->                          -- uid : TBasicType TUTF8+    IO ()+++eventParseTocSelect ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m (T.Text)                           -- result+eventParseTocSelect _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    uid <- allocMem :: IO (Ptr CString)+    gst_event_parse_toc_select _obj' uid+    uid' <- peek uid+    uid'' <- cstringToText uid'+    freeMem uid'+    touchManagedPtr _obj+    freeMem uid+    return uid''++data EventParseTocSelectMethodInfo+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo EventParseTocSelectMethodInfo Event signature where+    overloadedMethod _ = eventParseTocSelect++-- method Event::set_group_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_set_group_id" gst_event_set_group_id :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Word32 ->                               -- group_id : TBasicType TUInt32+    IO ()+++eventSetGroupId ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> Word32                               -- groupId+    -> m ()                                 -- result+eventSetGroupId _obj groupId = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_event_set_group_id _obj' groupId+    touchManagedPtr _obj+    return ()++data EventSetGroupIdMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo EventSetGroupIdMethodInfo Event signature where+    overloadedMethod _ = eventSetGroupId++-- method Event::set_running_time_offset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_set_running_time_offset" gst_event_set_running_time_offset :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Int64 ->                                -- offset : TBasicType TInt64+    IO ()+++eventSetRunningTimeOffset ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> Int64                                -- offset+    -> m ()                                 -- result+eventSetRunningTimeOffset _obj offset = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_event_set_running_time_offset _obj' offset+    touchManagedPtr _obj+    return ()++data EventSetRunningTimeOffsetMethodInfo+instance (signature ~ (Int64 -> m ()), MonadIO m) => MethodInfo EventSetRunningTimeOffsetMethodInfo Event signature where+    overloadedMethod _ = eventSetRunningTimeOffset++-- method Event::set_seqnum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seqnum", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_set_seqnum" gst_event_set_seqnum :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    Word32 ->                               -- seqnum : TBasicType TUInt32+    IO ()+++eventSetSeqnum ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> Word32                               -- seqnum+    -> m ()                                 -- result+eventSetSeqnum _obj seqnum = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_event_set_seqnum _obj' seqnum+    touchManagedPtr _obj+    return ()++data EventSetSeqnumMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo EventSetSeqnumMethodInfo Event signature where+    overloadedMethod _ = eventSetSeqnum++-- method Event::set_stream_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "StreamFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_set_stream_flags" gst_event_set_stream_flags :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    CUInt ->                                -- flags : TInterface "Gst" "StreamFlags"+    IO ()+++eventSetStreamFlags ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> [StreamFlags]                        -- flags+    -> m ()                                 -- result+eventSetStreamFlags _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = gflagsToWord flags+    gst_event_set_stream_flags _obj' flags'+    touchManagedPtr _obj+    return ()++data EventSetStreamFlagsMethodInfo+instance (signature ~ ([StreamFlags] -> m ()), MonadIO m) => MethodInfo EventSetStreamFlagsMethodInfo Event signature where+    overloadedMethod _ = eventSetStreamFlags++-- method Event::writable_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_event_writable_structure" gst_event_writable_structure :: +    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"+    IO (Ptr Structure)+++eventWritableStructure ::+    (MonadIO m) =>+    Event                                   -- _obj+    -> m Structure                          -- result+eventWritableStructure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_event_writable_structure _obj'+    checkUnexpectedReturnNULL "gst_event_writable_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data EventWritableStructureMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo EventWritableStructureMethodInfo Event signature where+    overloadedMethod _ = eventWritableStructure++type family ResolveEventMethod (t :: Symbol) (o :: *) :: * where+    ResolveEventMethod "copySegment" o = EventCopySegmentMethodInfo+    ResolveEventMethod "hasName" o = EventHasNameMethodInfo+    ResolveEventMethod "parseBufferSize" o = EventParseBufferSizeMethodInfo+    ResolveEventMethod "parseCaps" o = EventParseCapsMethodInfo+    ResolveEventMethod "parseFlushStop" o = EventParseFlushStopMethodInfo+    ResolveEventMethod "parseGap" o = EventParseGapMethodInfo+    ResolveEventMethod "parseGroupId" o = EventParseGroupIdMethodInfo+    ResolveEventMethod "parseLatency" o = EventParseLatencyMethodInfo+    ResolveEventMethod "parseProtection" o = EventParseProtectionMethodInfo+    ResolveEventMethod "parseQos" o = EventParseQosMethodInfo+    ResolveEventMethod "parseSeek" o = EventParseSeekMethodInfo+    ResolveEventMethod "parseSegment" o = EventParseSegmentMethodInfo+    ResolveEventMethod "parseSegmentDone" o = EventParseSegmentDoneMethodInfo+    ResolveEventMethod "parseSinkMessage" o = EventParseSinkMessageMethodInfo+    ResolveEventMethod "parseStep" o = EventParseStepMethodInfo+    ResolveEventMethod "parseStreamFlags" o = EventParseStreamFlagsMethodInfo+    ResolveEventMethod "parseStreamStart" o = EventParseStreamStartMethodInfo+    ResolveEventMethod "parseTag" o = EventParseTagMethodInfo+    ResolveEventMethod "parseToc" o = EventParseTocMethodInfo+    ResolveEventMethod "parseTocSelect" o = EventParseTocSelectMethodInfo+    ResolveEventMethod "writableStructure" o = EventWritableStructureMethodInfo+    ResolveEventMethod "getRunningTimeOffset" o = EventGetRunningTimeOffsetMethodInfo+    ResolveEventMethod "getSeqnum" o = EventGetSeqnumMethodInfo+    ResolveEventMethod "getStructure" o = EventGetStructureMethodInfo+    ResolveEventMethod "setGroupId" o = EventSetGroupIdMethodInfo+    ResolveEventMethod "setRunningTimeOffset" o = EventSetRunningTimeOffsetMethodInfo+    ResolveEventMethod "setSeqnum" o = EventSetSeqnumMethodInfo+    ResolveEventMethod "setStreamFlags" o = EventSetStreamFlagsMethodInfo+    ResolveEventMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveEventMethod t Event, MethodInfo info Event p) => IsLabelProxy t (Event -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveEventMethod t Event, MethodInfo info Event p) => IsLabel t (Event -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Event.hs-boot view
@@ -0,0 +1,39 @@+module GI.Gst.Structs.Event 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++newtype Event = Event (ForeignPtr Event)+instance BoxedObject Event where+data EventCopySegmentMethodInfo+data EventGetRunningTimeOffsetMethodInfo+data EventGetSeqnumMethodInfo+data EventGetStructureMethodInfo+data EventHasNameMethodInfo+data EventParseBufferSizeMethodInfo+data EventParseCapsMethodInfo+data EventParseFlushStopMethodInfo+data EventParseGapMethodInfo+data EventParseGroupIdMethodInfo+data EventParseLatencyMethodInfo+data EventParseProtectionMethodInfo+data EventParseQosMethodInfo+data EventParseSeekMethodInfo+data EventParseSegmentMethodInfo+data EventParseSegmentDoneMethodInfo+data EventParseSinkMessageMethodInfo+data EventParseStepMethodInfo+data EventParseStreamFlagsMethodInfo+data EventParseStreamStartMethodInfo+data EventParseTagMethodInfo+data EventParseTocMethodInfo+data EventParseTocSelectMethodInfo+data EventSetGroupIdMethodInfo+data EventSetRunningTimeOffsetMethodInfo+data EventSetSeqnumMethodInfo+data EventSetStreamFlagsMethodInfo+data EventWritableStructureMethodInfo
+ GI/Gst/Structs/FormatDefinition.hs view
@@ -0,0 +1,93 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A format definition+-}++module GI.Gst.Structs.FormatDefinition+    ( ++-- * Exported types+    FormatDefinition(..)                    ,+    newZeroFormatDefinition                 ,+    noFormatDefinition                      ,+++ -- * Properties+-- ** Description+    formatDefinitionReadDescription         ,+++-- ** Nick+    formatDefinitionReadNick                ,+++-- ** Quark+    formatDefinitionReadQuark               ,+++-- ** Value+    formatDefinitionReadValue               ,+++++    ) 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 GI.Gst.Callbacks++newtype FormatDefinition = FormatDefinition (ForeignPtr FormatDefinition)+-- | Construct a `FormatDefinition` struct initialized to zero.+newZeroFormatDefinition :: MonadIO m => m FormatDefinition+newZeroFormatDefinition = liftIO $ callocBytes 32 >>= wrapPtr FormatDefinition++noFormatDefinition :: Maybe FormatDefinition+noFormatDefinition = Nothing++formatDefinitionReadValue :: FormatDefinition -> IO Format+formatDefinitionReadValue s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++formatDefinitionReadNick :: FormatDefinition -> IO T.Text+formatDefinitionReadNick s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++formatDefinitionReadDescription :: FormatDefinition -> IO T.Text+formatDefinitionReadDescription s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++formatDefinitionReadQuark :: FormatDefinition -> IO Word32+formatDefinitionReadQuark s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word32+    return val++type family ResolveFormatDefinitionMethod (t :: Symbol) (o :: *) :: * where+    ResolveFormatDefinitionMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveFormatDefinitionMethod t FormatDefinition, MethodInfo info FormatDefinition p) => IsLabelProxy t (FormatDefinition -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveFormatDefinitionMethod t FormatDefinition, MethodInfo info FormatDefinition p) => IsLabel t (FormatDefinition -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/FormatDefinition.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.FormatDefinition 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++newtype FormatDefinition = FormatDefinition (ForeignPtr FormatDefinition)
+ GI/Gst/Structs/Iterator.hs view
@@ -0,0 +1,545 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A GstIterator is used to retrieve multiple objects from another object in+a threadsafe way.++Various GStreamer objects provide access to their internal structures using+an iterator.++Note that if calling a GstIterator function results in your code receiving+a refcounted object (with, say, g_value_get_object()), the refcount for that+object will not be increased. Your code is responsible for taking a reference+if it wants to continue using it later.++The basic use pattern of an iterator is as follows:+|[+  GstIterator *it = _get_iterator(object);+  GValue item = G_VALUE_INIT;+  done = FALSE;+  while (!done) {+    switch (gst_iterator_next (it, &amp;item)) {+      case GST_ITERATOR_OK:+        ...get/use/change item here...+        g_value_reset (&amp;item);+        break;+      case GST_ITERATOR_RESYNC:+        ...rollback changes to items...+        gst_iterator_resync (it);+        break;+      case GST_ITERATOR_ERROR:+        ...wrong parameters were given...+        done = TRUE;+        break;+      case GST_ITERATOR_DONE:+        done = TRUE;+        break;+    }+  }+  g_value_unset (&amp;item);+  gst_iterator_free (it);+]|+-}++module GI.Gst.Structs.Iterator+    ( ++-- * Exported types+    Iterator(..)                            ,+    newZeroIterator                         ,+    noIterator                              ,+++ -- * Methods+-- ** iteratorCopy+    IteratorCopyMethodInfo                  ,+    iteratorCopy                            ,+++-- ** iteratorFilter+    IteratorFilterMethodInfo                ,+    iteratorFilter                          ,+++-- ** iteratorFindCustom+    IteratorFindCustomMethodInfo            ,+    iteratorFindCustom                      ,+++-- ** iteratorFold+    IteratorFoldMethodInfo                  ,+    iteratorFold                            ,+++-- ** iteratorForeach+    IteratorForeachMethodInfo               ,+    iteratorForeach                         ,+++-- ** iteratorFree+    IteratorFreeMethodInfo                  ,+    iteratorFree                            ,+++-- ** iteratorNewSingle+    iteratorNewSingle                       ,+++-- ** iteratorNext+    IteratorNextMethodInfo                  ,+    iteratorNext                            ,+++-- ** iteratorPush+    IteratorPushMethodInfo                  ,+    iteratorPush                            ,+++-- ** iteratorResync+    IteratorResyncMethodInfo                ,+    iteratorResync                          ,+++++ -- * Properties+-- ** Cookie+    iteratorReadCookie                      ,+++-- ** Lock+    iteratorReadLock                        ,+++-- ** MasterCookie+    iteratorReadMasterCookie                ,+++-- ** Pushed+    iteratorReadPushed                      ,+++-- ** Size+    iteratorReadSize                        ,+++-- ** Type+    iteratorReadType                        ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype Iterator = Iterator (ForeignPtr Iterator)+foreign import ccall "gst_iterator_get_type" c_gst_iterator_get_type :: +    IO GType++instance BoxedObject Iterator where+    boxedType _ = c_gst_iterator_get_type++-- | Construct a `Iterator` struct initialized to zero.+newZeroIterator :: MonadIO m => m Iterator+newZeroIterator = liftIO $ callocBoxedBytes 120 >>= wrapBoxed Iterator++noIterator :: Maybe Iterator+noIterator = Nothing++-- XXX Skipped getter for "Iterator:copy" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "Iterator:next" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "Iterator:item" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "Iterator:resync" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "Iterator:free" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++iteratorReadPushed :: Iterator -> IO Iterator+iteratorReadPushed s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO (Ptr Iterator)+    val' <- (newBoxed Iterator) val+    return val'++iteratorReadType :: Iterator -> IO GType+iteratorReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO CGType+    let val' = GType val+    return val'++iteratorReadLock :: Iterator -> IO GLib.Mutex+iteratorReadLock s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO (Ptr GLib.Mutex)+    val' <- (newPtr 8 GLib.Mutex) val+    return val'++iteratorReadCookie :: Iterator -> IO Word32+iteratorReadCookie s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO Word32+    return val++iteratorReadMasterCookie :: Iterator -> IO Word32+iteratorReadMasterCookie s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO Word32+    return val++iteratorReadSize :: Iterator -> IO Word32+iteratorReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 80) :: IO Word32+    return val++-- method Iterator::new_single+-- method type : Constructor+-- Args : [Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_new_single" gst_iterator_new_single :: +    CGType ->                               -- type : TBasicType TGType+    Ptr GValue ->                           -- object : TInterface "GObject" "Value"+    IO (Ptr Iterator)+++iteratorNewSingle ::+    (MonadIO m) =>+    GType                                   -- type_+    -> GValue                               -- object+    -> m Iterator                           -- result+iteratorNewSingle type_ object = liftIO $ do+    let type_' = gtypeToCGType type_+    let object' = unsafeManagedPtrGetPtr object+    result <- gst_iterator_new_single type_' object'+    checkUnexpectedReturnNULL "gst_iterator_new_single" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr object+    return result'++-- method Iterator::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_copy" gst_iterator_copy :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    IO (Ptr Iterator)+++iteratorCopy ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> m Iterator                           -- result+iteratorCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_iterator_copy _obj'+    checkUnexpectedReturnNULL "gst_iterator_copy" result+    result' <- (wrapBoxed Iterator) result+    touchManagedPtr _obj+    return result'++data IteratorCopyMethodInfo+instance (signature ~ (m Iterator), MonadIO m) => MethodInfo IteratorCopyMethodInfo Iterator signature where+    overloadedMethod _ = iteratorCopy++-- method Iterator::filter+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GLib" "CompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Iterator"+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_filter" gst_iterator_filter :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    FunPtr GLib.CompareFuncC ->             -- func : TInterface "GLib" "CompareFunc"+    Ptr GValue ->                           -- user_data : TInterface "GObject" "Value"+    IO (Ptr Iterator)+++iteratorFilter ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> GLib.CompareFunc                     -- func+    -> GValue                               -- userData+    -> m Iterator                           -- result+iteratorFilter _obj func userData = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- GLib.mkCompareFunc (GLib.compareFuncWrapper Nothing func)+    let userData' = unsafeManagedPtrGetPtr userData+    result <- gst_iterator_filter _obj' func' userData'+    checkUnexpectedReturnNULL "gst_iterator_filter" result+    result' <- (wrapBoxed Iterator) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    touchManagedPtr userData+    return result'++data IteratorFilterMethodInfo+instance (signature ~ (GLib.CompareFunc -> GValue -> m Iterator), MonadIO m) => MethodInfo IteratorFilterMethodInfo Iterator signature where+    overloadedMethod _ = iteratorFilter++-- method Iterator::find_custom+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GLib" "CompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elem", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_find_custom" gst_iterator_find_custom :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    FunPtr GLib.CompareFuncC ->             -- func : TInterface "GLib" "CompareFunc"+    Ptr GValue ->                           -- elem : TInterface "GObject" "Value"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++iteratorFindCustom ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> GLib.CompareFunc                     -- func+    -> m (Bool,GValue)                      -- result+iteratorFindCustom _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- GLib.mkCompareFunc (GLib.compareFuncWrapper Nothing func)+    elem <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let userData = nullPtr+    result <- gst_iterator_find_custom _obj' func' elem userData+    let result' = (/= 0) result+    elem' <- (wrapBoxed GValue) elem+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return (result', elem')++data IteratorFindCustomMethodInfo+instance (signature ~ (GLib.CompareFunc -> m (Bool,GValue)), MonadIO m) => MethodInfo IteratorFindCustomMethodInfo Iterator signature where+    overloadedMethod _ = iteratorFindCustom++-- method Iterator::fold+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "IteratorFoldFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ret", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "IteratorResult"+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_fold" gst_iterator_fold :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    FunPtr IteratorFoldFunctionC ->         -- func : TInterface "Gst" "IteratorFoldFunction"+    Ptr GValue ->                           -- ret : TInterface "GObject" "Value"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CUInt+++iteratorFold ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> IteratorFoldFunction                 -- func+    -> GValue                               -- ret+    -> m IteratorResult                     -- result+iteratorFold _obj func ret = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkIteratorFoldFunction (iteratorFoldFunctionWrapper Nothing func)+    let ret' = unsafeManagedPtrGetPtr ret+    let userData = nullPtr+    result <- gst_iterator_fold _obj' func' ret' userData+    let result' = (toEnum . fromIntegral) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    touchManagedPtr ret+    return result'++data IteratorFoldMethodInfo+instance (signature ~ (IteratorFoldFunction -> GValue -> m IteratorResult), MonadIO m) => MethodInfo IteratorFoldMethodInfo Iterator signature where+    overloadedMethod _ = iteratorFold++-- method Iterator::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "IteratorForeachFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "IteratorResult"+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_foreach" gst_iterator_foreach :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    FunPtr IteratorForeachFunctionC ->      -- func : TInterface "Gst" "IteratorForeachFunction"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CUInt+++iteratorForeach ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> IteratorForeachFunction              -- func+    -> m IteratorResult                     -- result+iteratorForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkIteratorForeachFunction (iteratorForeachFunctionWrapper Nothing func)+    let userData = nullPtr+    result <- gst_iterator_foreach _obj' func' userData+    let result' = (toEnum . fromIntegral) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return result'++data IteratorForeachMethodInfo+instance (signature ~ (IteratorForeachFunction -> m IteratorResult), MonadIO m) => MethodInfo IteratorForeachMethodInfo Iterator signature where+    overloadedMethod _ = iteratorForeach++-- method Iterator::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_free" gst_iterator_free :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    IO ()+++iteratorFree ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> m ()                                 -- result+iteratorFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_iterator_free _obj'+    touchManagedPtr _obj+    return ()++data IteratorFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo IteratorFreeMethodInfo Iterator signature where+    overloadedMethod _ = iteratorFree++-- method Iterator::next+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elem", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "IteratorResult"+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_next" gst_iterator_next :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    Ptr GValue ->                           -- elem : TInterface "GObject" "Value"+    IO CUInt+++iteratorNext ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> m (IteratorResult,GValue)            -- result+iteratorNext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    elem <- callocBoxedBytes 24 :: IO (Ptr GValue)+    result <- gst_iterator_next _obj' elem+    let result' = (toEnum . fromIntegral) result+    elem' <- (wrapBoxed GValue) elem+    touchManagedPtr _obj+    return (result', elem')++data IteratorNextMethodInfo+instance (signature ~ (m (IteratorResult,GValue)), MonadIO m) => MethodInfo IteratorNextMethodInfo Iterator signature where+    overloadedMethod _ = iteratorNext++-- method Iterator::push+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "other", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_push" gst_iterator_push :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    Ptr Iterator ->                         -- other : TInterface "Gst" "Iterator"+    IO ()+++iteratorPush ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> Iterator                             -- other+    -> m ()                                 -- result+iteratorPush _obj other = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let other' = unsafeManagedPtrGetPtr other+    gst_iterator_push _obj' other'+    touchManagedPtr _obj+    touchManagedPtr other+    return ()++data IteratorPushMethodInfo+instance (signature ~ (Iterator -> m ()), MonadIO m) => MethodInfo IteratorPushMethodInfo Iterator signature where+    overloadedMethod _ = iteratorPush++-- method Iterator::resync+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_iterator_resync" gst_iterator_resync :: +    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"+    IO ()+++iteratorResync ::+    (MonadIO m) =>+    Iterator                                -- _obj+    -> m ()                                 -- result+iteratorResync _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_iterator_resync _obj'+    touchManagedPtr _obj+    return ()++data IteratorResyncMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo IteratorResyncMethodInfo Iterator signature where+    overloadedMethod _ = iteratorResync++type family ResolveIteratorMethod (t :: Symbol) (o :: *) :: * where+    ResolveIteratorMethod "copy" o = IteratorCopyMethodInfo+    ResolveIteratorMethod "filter" o = IteratorFilterMethodInfo+    ResolveIteratorMethod "findCustom" o = IteratorFindCustomMethodInfo+    ResolveIteratorMethod "fold" o = IteratorFoldMethodInfo+    ResolveIteratorMethod "foreach" o = IteratorForeachMethodInfo+    ResolveIteratorMethod "free" o = IteratorFreeMethodInfo+    ResolveIteratorMethod "next" o = IteratorNextMethodInfo+    ResolveIteratorMethod "push" o = IteratorPushMethodInfo+    ResolveIteratorMethod "resync" o = IteratorResyncMethodInfo+    ResolveIteratorMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveIteratorMethod t Iterator, MethodInfo info Iterator p) => IsLabelProxy t (Iterator -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveIteratorMethod t Iterator, MethodInfo info Iterator p) => IsLabel t (Iterator -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Iterator.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gst.Structs.Iterator 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++newtype Iterator = Iterator (ForeignPtr Iterator)+instance BoxedObject Iterator where+data IteratorCopyMethodInfo+data IteratorFilterMethodInfo+data IteratorFindCustomMethodInfo+data IteratorFoldMethodInfo+data IteratorForeachMethodInfo+data IteratorFreeMethodInfo+data IteratorNextMethodInfo+data IteratorPushMethodInfo+data IteratorResyncMethodInfo
+ GI/Gst/Structs/MapInfo.hs view
@@ -0,0 +1,97 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A structure containing the result of a map operation such as+gst_memory_map(). It contains the data and size.+-}++module GI.Gst.Structs.MapInfo+    ( ++-- * Exported types+    MapInfo(..)                             ,+    newZeroMapInfo                          ,+    noMapInfo                               ,+++ -- * Properties+-- ** Flags+    mapInfoReadFlags                        ,+++-- ** Maxsize+    mapInfoReadMaxsize                      ,+++-- ** Memory+    mapInfoReadMemory                       ,+++-- ** Size+    mapInfoReadSize                         ,+++++    ) 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 GI.Gst.Callbacks++newtype MapInfo = MapInfo (ForeignPtr MapInfo)+-- | Construct a `MapInfo` struct initialized to zero.+newZeroMapInfo :: MonadIO m => m MapInfo+newZeroMapInfo = liftIO $ callocBytes 104 >>= wrapPtr MapInfo++noMapInfo :: Maybe MapInfo+noMapInfo = Nothing++mapInfoReadMemory :: MapInfo -> IO Memory+mapInfoReadMemory s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Memory)+    val' <- (newBoxed Memory) val+    return val'++mapInfoReadFlags :: MapInfo -> IO [MapFlags]+mapInfoReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CUInt+    let val' = wordToGFlags val+    return val'++-- XXX Skipped getter for "MapInfo:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 3 (TBasicType TUInt8)"++mapInfoReadSize :: MapInfo -> IO Word64+mapInfoReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word64+    return val++mapInfoReadMaxsize :: MapInfo -> IO Word64+mapInfoReadMaxsize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word64+    return val++-- XXX Skipped getter for "MapInfo:user_data" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TVoid)"++type family ResolveMapInfoMethod (t :: Symbol) (o :: *) :: * where+    ResolveMapInfoMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveMapInfoMethod t MapInfo, MethodInfo info MapInfo p) => IsLabelProxy t (MapInfo -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveMapInfoMethod t MapInfo, MethodInfo info MapInfo p) => IsLabel t (MapInfo -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/MapInfo.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.MapInfo 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++newtype MapInfo = MapInfo (ForeignPtr MapInfo)
+ GI/Gst/Structs/Memory.hs view
@@ -0,0 +1,562 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++GstMemory is a lightweight refcounted object that wraps a region of memory.+They are typically used to manage the data of a #GstBuffer.++A GstMemory object has an allocated region of memory of maxsize. The maximum+size does not change during the lifetime of the memory object. The memory+also has an offset and size property that specifies the valid range of memory+in the allocated region.++Memory is usually created by allocators with a gst_allocator_alloc()+method call. When %NULL is used as the allocator, the default allocator will+be used.++New allocators can be registered with gst_allocator_register().+Allocators are identified by name and can be retrieved with+gst_allocator_find(). gst_allocator_set_default() can be used to change the+default allocator.++New memory can be created with gst_memory_new_wrapped() that wraps the memory+allocated elsewhere.++Refcounting of the memory block is performed with gst_memory_ref() and+gst_memory_unref().++The size of the memory can be retrieved and changed with+gst_memory_get_sizes() and gst_memory_resize() respectively.++Getting access to the data of the memory is performed with gst_memory_map().+The call will return a pointer to offset bytes into the region of memory.+After the memory access is completed, gst_memory_unmap() should be called.++Memory can be copied with gst_memory_copy(), which will return a writable+copy. gst_memory_share() will create a new memory block that shares the+memory with an existing memory block at a custom offset and with a custom+size.++Memory can be efficiently merged when gst_memory_is_span() returns %TRUE.+-}++module GI.Gst.Structs.Memory+    ( ++-- * Exported types+    Memory(..)                              ,+    newZeroMemory                           ,+    noMemory                                ,+++ -- * Methods+-- ** memoryCopy+    MemoryCopyMethodInfo                    ,+    memoryCopy                              ,+++-- ** memoryGetSizes+    MemoryGetSizesMethodInfo                ,+    memoryGetSizes                          ,+++-- ** memoryIsSpan+    MemoryIsSpanMethodInfo                  ,+    memoryIsSpan                            ,+++-- ** memoryIsType+    MemoryIsTypeMethodInfo                  ,+    memoryIsType                            ,+++-- ** memoryMakeMapped+    MemoryMakeMappedMethodInfo              ,+    memoryMakeMapped                        ,+++-- ** memoryMap+    MemoryMapMethodInfo                     ,+    memoryMap                               ,+++-- ** memoryNewWrapped+    memoryNewWrapped                        ,+++-- ** memoryResize+    MemoryResizeMethodInfo                  ,+    memoryResize                            ,+++-- ** memoryShare+    MemoryShareMethodInfo                   ,+    memoryShare                             ,+++-- ** memoryUnmap+    MemoryUnmapMethodInfo                   ,+    memoryUnmap                             ,+++++ -- * Properties+-- ** Align+    memoryReadAlign                         ,+++-- ** Allocator+    memoryReadAllocator                     ,+++-- ** Maxsize+    memoryReadMaxsize                       ,+++-- ** MiniObject+    memoryReadMiniObject                    ,+++-- ** Offset+    memoryReadOffset                        ,+++-- ** Parent+    memoryReadParent                        ,+++-- ** Size+    memoryReadSize                          ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype Memory = Memory (ForeignPtr Memory)+foreign import ccall "gst_memory_get_type" c_gst_memory_get_type :: +    IO GType++instance BoxedObject Memory where+    boxedType _ = c_gst_memory_get_type++-- | Construct a `Memory` struct initialized to zero.+newZeroMemory :: MonadIO m => m Memory+newZeroMemory = liftIO $ callocBoxedBytes 112 >>= wrapBoxed Memory++noMemory :: Maybe Memory+noMemory = Nothing++memoryReadMiniObject :: Memory -> IO MiniObject+memoryReadMiniObject s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)+    val' <- (newPtr 64 MiniObject) val+    return val'++memoryReadAllocator :: Memory -> IO Allocator+memoryReadAllocator s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO (Ptr Allocator)+    val' <- (newObject Allocator) val+    return val'++memoryReadParent :: Memory -> IO Memory+memoryReadParent s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO (Ptr Memory)+    val' <- (newBoxed Memory) val+    return val'++memoryReadMaxsize :: Memory -> IO Word64+memoryReadMaxsize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 80) :: IO Word64+    return val++memoryReadAlign :: Memory -> IO Word64+memoryReadAlign s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 88) :: IO Word64+    return val++memoryReadOffset :: Memory -> IO Word64+memoryReadOffset s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 96) :: IO Word64+    return val++memoryReadSize :: Memory -> IO Word64+memoryReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 104) :: IO Word64+    return val++-- method Memory::new_wrapped+-- method type : Constructor+-- Args : [Arg {argCName = "flags", argType = TInterface "Gst" "MemoryFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 4 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_new_wrapped" gst_memory_new_wrapped :: +    CUInt ->                                -- flags : TInterface "Gst" "MemoryFlags"+    Ptr Word8 ->                            -- data : TCArray False (-1) 4 (TBasicType TUInt8)+    Word64 ->                               -- maxsize : TBasicType TUInt64+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- size : TBasicType TUInt64+    Ptr () ->                               -- user_data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"+    IO (Ptr Memory)+++memoryNewWrapped ::+    (MonadIO m) =>+    [MemoryFlags]                           -- flags+    -> ByteString                           -- data_+    -> Word64                               -- maxsize+    -> Word64                               -- offset+    -> Maybe (GLib.DestroyNotify)           -- notify+    -> m Memory                             -- result+memoryNewWrapped flags data_ maxsize offset notify = liftIO $ do+    let size = fromIntegral $ B.length data_+    let flags' = gflagsToWord flags+    data_' <- packByteString data_+    ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    maybeNotify <- case notify of+        Nothing -> return (castPtrToFunPtr nullPtr)+        Just jNotify -> do+            jNotify' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrnotify) jNotify)+            poke ptrnotify jNotify'+            return jNotify'+    let userData = nullPtr+    result <- gst_memory_new_wrapped flags' data_' maxsize offset size userData maybeNotify+    checkUnexpectedReturnNULL "gst_memory_new_wrapped" result+    result' <- (wrapBoxed Memory) result+    freeMem data_'+    return result'++-- method Memory::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_copy" gst_memory_copy :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Int64 ->                                -- offset : TBasicType TInt64+    Int64 ->                                -- size : TBasicType TInt64+    IO (Ptr Memory)+++memoryCopy ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> Int64                                -- offset+    -> Int64                                -- size+    -> m Memory                             -- result+memoryCopy _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_memory_copy _obj' offset size+    checkUnexpectedReturnNULL "gst_memory_copy" result+    result' <- (wrapBoxed Memory) result+    touchManagedPtr _obj+    return result'++data MemoryCopyMethodInfo+instance (signature ~ (Int64 -> Int64 -> m Memory), MonadIO m) => MethodInfo MemoryCopyMethodInfo Memory signature where+    overloadedMethod _ = memoryCopy++-- method Memory::get_sizes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_get_sizes" gst_memory_get_sizes :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Word64 ->                               -- offset : TBasicType TUInt64+    Word64 ->                               -- maxsize : TBasicType TUInt64+    IO Word64+++memoryGetSizes ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> Word64                               -- offset+    -> Word64                               -- maxsize+    -> m Word64                             -- result+memoryGetSizes _obj offset maxsize = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_memory_get_sizes _obj' offset maxsize+    touchManagedPtr _obj+    return result++data MemoryGetSizesMethodInfo+instance (signature ~ (Word64 -> Word64 -> m Word64), MonadIO m) => MethodInfo MemoryGetSizesMethodInfo Memory signature where+    overloadedMethod _ = memoryGetSizes++-- method Memory::is_span+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem2", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_is_span" gst_memory_is_span :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Ptr Memory ->                           -- mem2 : TInterface "Gst" "Memory"+    Word64 ->                               -- offset : TBasicType TUInt64+    IO CInt+++memoryIsSpan ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> Memory                               -- mem2+    -> Word64                               -- offset+    -> m Bool                               -- result+memoryIsSpan _obj mem2 offset = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mem2' = unsafeManagedPtrGetPtr mem2+    result <- gst_memory_is_span _obj' mem2' offset+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr mem2+    return result'++data MemoryIsSpanMethodInfo+instance (signature ~ (Memory -> Word64 -> m Bool), MonadIO m) => MethodInfo MemoryIsSpanMethodInfo Memory signature where+    overloadedMethod _ = memoryIsSpan++-- method Memory::is_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_is_type" gst_memory_is_type :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    CString ->                              -- mem_type : TBasicType TUTF8+    IO CInt+++memoryIsType ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> T.Text                               -- memType+    -> m Bool                               -- result+memoryIsType _obj memType = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    memType' <- textToCString memType+    result <- gst_memory_is_type _obj' memType'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem memType'+    return result'++data MemoryIsTypeMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo MemoryIsTypeMethodInfo Memory signature where+    overloadedMethod _ = memoryIsType++-- method Memory::make_mapped+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_make_mapped" gst_memory_make_mapped :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"+    IO (Ptr Memory)+++memoryMakeMapped ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> [MapFlags]                           -- flags+    -> m (Memory,MapInfo)                   -- result+memoryMakeMapped _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    info <- callocBytes 104 :: IO (Ptr MapInfo)+    let flags' = gflagsToWord flags+    result <- gst_memory_make_mapped _obj' info flags'+    checkUnexpectedReturnNULL "gst_memory_make_mapped" result+    result' <- (wrapBoxed Memory) result+    info' <- (wrapPtr MapInfo) info+    touchManagedPtr _obj+    return (result', info')++data MemoryMakeMappedMethodInfo+instance (signature ~ ([MapFlags] -> m (Memory,MapInfo)), MonadIO m) => MethodInfo MemoryMakeMappedMethodInfo Memory signature where+    overloadedMethod _ = memoryMakeMapped++-- method Memory::map+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_map" gst_memory_map :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"+    IO CInt+++memoryMap ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> [MapFlags]                           -- flags+    -> m (Bool,MapInfo)                     -- result+memoryMap _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    info <- callocBytes 104 :: IO (Ptr MapInfo)+    let flags' = gflagsToWord flags+    result <- gst_memory_map _obj' info flags'+    let result' = (/= 0) result+    info' <- (wrapPtr MapInfo) info+    touchManagedPtr _obj+    return (result', info')++data MemoryMapMethodInfo+instance (signature ~ ([MapFlags] -> m (Bool,MapInfo)), MonadIO m) => MethodInfo MemoryMapMethodInfo Memory signature where+    overloadedMethod _ = memoryMap++-- method Memory::resize+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_resize" gst_memory_resize :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Int64 ->                                -- offset : TBasicType TInt64+    Word64 ->                               -- size : TBasicType TUInt64+    IO ()+++memoryResize ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> Int64                                -- offset+    -> Word64                               -- size+    -> m ()                                 -- result+memoryResize _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_memory_resize _obj' offset size+    touchManagedPtr _obj+    return ()++data MemoryResizeMethodInfo+instance (signature ~ (Int64 -> Word64 -> m ()), MonadIO m) => MethodInfo MemoryResizeMethodInfo Memory signature where+    overloadedMethod _ = memoryResize++-- method Memory::share+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Memory"+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_share" gst_memory_share :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Int64 ->                                -- offset : TBasicType TInt64+    Int64 ->                                -- size : TBasicType TInt64+    IO (Ptr Memory)+++memoryShare ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> Int64                                -- offset+    -> Int64                                -- size+    -> m Memory                             -- result+memoryShare _obj offset size = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_memory_share _obj' offset size+    checkUnexpectedReturnNULL "gst_memory_share" result+    result' <- (wrapBoxed Memory) result+    touchManagedPtr _obj+    return result'++data MemoryShareMethodInfo+instance (signature ~ (Int64 -> Int64 -> m Memory), MonadIO m) => MethodInfo MemoryShareMethodInfo Memory signature where+    overloadedMethod _ = memoryShare++-- method Memory::unmap+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_memory_unmap" gst_memory_unmap :: +    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"+    IO ()+++memoryUnmap ::+    (MonadIO m) =>+    Memory                                  -- _obj+    -> MapInfo                              -- info+    -> m ()                                 -- result+memoryUnmap _obj info = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let info' = unsafeManagedPtrGetPtr info+    gst_memory_unmap _obj' info'+    touchManagedPtr _obj+    touchManagedPtr info+    return ()++data MemoryUnmapMethodInfo+instance (signature ~ (MapInfo -> m ()), MonadIO m) => MethodInfo MemoryUnmapMethodInfo Memory signature where+    overloadedMethod _ = memoryUnmap++type family ResolveMemoryMethod (t :: Symbol) (o :: *) :: * where+    ResolveMemoryMethod "copy" o = MemoryCopyMethodInfo+    ResolveMemoryMethod "isSpan" o = MemoryIsSpanMethodInfo+    ResolveMemoryMethod "isType" o = MemoryIsTypeMethodInfo+    ResolveMemoryMethod "makeMapped" o = MemoryMakeMappedMethodInfo+    ResolveMemoryMethod "map" o = MemoryMapMethodInfo+    ResolveMemoryMethod "resize" o = MemoryResizeMethodInfo+    ResolveMemoryMethod "share" o = MemoryShareMethodInfo+    ResolveMemoryMethod "unmap" o = MemoryUnmapMethodInfo+    ResolveMemoryMethod "getSizes" o = MemoryGetSizesMethodInfo+    ResolveMemoryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveMemoryMethod t Memory, MethodInfo info Memory p) => IsLabelProxy t (Memory -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveMemoryMethod t Memory, MethodInfo info Memory p) => IsLabel t (Memory -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Memory.hs-boot view
@@ -0,0 +1,20 @@+module GI.Gst.Structs.Memory 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++newtype Memory = Memory (ForeignPtr Memory)+instance BoxedObject Memory where+data MemoryCopyMethodInfo+data MemoryGetSizesMethodInfo+data MemoryIsSpanMethodInfo+data MemoryIsTypeMethodInfo+data MemoryMakeMappedMethodInfo+data MemoryMapMethodInfo+data MemoryResizeMethodInfo+data MemoryShareMethodInfo+data MemoryUnmapMethodInfo
+ GI/Gst/Structs/Message.hs view
@@ -0,0 +1,3035 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Messages are implemented as a subclass of #GstMiniObject with a generic+#GstStructure as the content. This allows for writing custom messages without+requiring an API change while allowing a wide range of different types+of messages.++Messages are posted by objects in the pipeline and are passed to the+application using the #GstBus.++The basic use pattern of posting a message on a #GstBus is as follows:+|[+  gst_bus_post (bus, gst_message_new_eos());+]|++A #GstElement usually posts messages on the bus provided by the parent+container using gst_element_post_message().+-}++module GI.Gst.Structs.Message+    ( ++-- * Exported types+    Message(..)                             ,+    newZeroMessage                          ,+    noMessage                               ,+++ -- * Methods+-- ** messageGetSeqnum+    MessageGetSeqnumMethodInfo              ,+    messageGetSeqnum                        ,+++-- ** messageGetStreamStatusObject+    MessageGetStreamStatusObjectMethodInfo  ,+    messageGetStreamStatusObject            ,+++-- ** messageGetStructure+    MessageGetStructureMethodInfo           ,+    messageGetStructure                     ,+++-- ** messageHasName+    MessageHasNameMethodInfo                ,+    messageHasName                          ,+++-- ** messageNewApplication+    messageNewApplication                   ,+++-- ** messageNewAsyncDone+    messageNewAsyncDone                     ,+++-- ** messageNewAsyncStart+    messageNewAsyncStart                    ,+++-- ** messageNewBuffering+    messageNewBuffering                     ,+++-- ** messageNewClockLost+    messageNewClockLost                     ,+++-- ** messageNewClockProvide+    messageNewClockProvide                  ,+++-- ** messageNewCustom+    messageNewCustom                        ,+++-- ** messageNewDeviceAdded+    messageNewDeviceAdded                   ,+++-- ** messageNewDeviceRemoved+    messageNewDeviceRemoved                 ,+++-- ** messageNewDurationChanged+    messageNewDurationChanged               ,+++-- ** messageNewElement+    messageNewElement                       ,+++-- ** messageNewEos+    messageNewEos                           ,+++-- ** messageNewError+    messageNewError                         ,+++-- ** messageNewHaveContext+    messageNewHaveContext                   ,+++-- ** messageNewInfo+    messageNewInfo                          ,+++-- ** messageNewLatency+    messageNewLatency                       ,+++-- ** messageNewNeedContext+    messageNewNeedContext                   ,+++-- ** messageNewNewClock+    messageNewNewClock                      ,+++-- ** messageNewProgress+    messageNewProgress                      ,+++-- ** messageNewQos+    messageNewQos                           ,+++-- ** messageNewRequestState+    messageNewRequestState                  ,+++-- ** messageNewResetTime+    messageNewResetTime                     ,+++-- ** messageNewSegmentDone+    messageNewSegmentDone                   ,+++-- ** messageNewSegmentStart+    messageNewSegmentStart                  ,+++-- ** messageNewStateChanged+    messageNewStateChanged                  ,+++-- ** messageNewStateDirty+    messageNewStateDirty                    ,+++-- ** messageNewStepDone+    messageNewStepDone                      ,+++-- ** messageNewStepStart+    messageNewStepStart                     ,+++-- ** messageNewStreamStart+    messageNewStreamStart                   ,+++-- ** messageNewStreamStatus+    messageNewStreamStatus                  ,+++-- ** messageNewStructureChange+    messageNewStructureChange               ,+++-- ** messageNewTag+    messageNewTag                           ,+++-- ** messageNewToc+    messageNewToc                           ,+++-- ** messageNewWarning+    messageNewWarning                       ,+++-- ** messageParseAsyncDone+    MessageParseAsyncDoneMethodInfo         ,+    messageParseAsyncDone                   ,+++-- ** messageParseBuffering+    MessageParseBufferingMethodInfo         ,+    messageParseBuffering                   ,+++-- ** messageParseBufferingStats+    MessageParseBufferingStatsMethodInfo    ,+    messageParseBufferingStats              ,+++-- ** messageParseClockLost+    MessageParseClockLostMethodInfo         ,+    messageParseClockLost                   ,+++-- ** messageParseClockProvide+    MessageParseClockProvideMethodInfo      ,+    messageParseClockProvide                ,+++-- ** messageParseContextType+    MessageParseContextTypeMethodInfo       ,+    messageParseContextType                 ,+++-- ** messageParseDeviceAdded+    MessageParseDeviceAddedMethodInfo       ,+    messageParseDeviceAdded                 ,+++-- ** messageParseDeviceRemoved+    MessageParseDeviceRemovedMethodInfo     ,+    messageParseDeviceRemoved               ,+++-- ** messageParseError+    MessageParseErrorMethodInfo             ,+    messageParseError                       ,+++-- ** messageParseGroupId+    MessageParseGroupIdMethodInfo           ,+    messageParseGroupId                     ,+++-- ** messageParseHaveContext+    MessageParseHaveContextMethodInfo       ,+    messageParseHaveContext                 ,+++-- ** messageParseInfo+    MessageParseInfoMethodInfo              ,+    messageParseInfo                        ,+++-- ** messageParseNewClock+    MessageParseNewClockMethodInfo          ,+    messageParseNewClock                    ,+++-- ** messageParseProgress+    MessageParseProgressMethodInfo          ,+    messageParseProgress                    ,+++-- ** messageParseQos+    MessageParseQosMethodInfo               ,+    messageParseQos                         ,+++-- ** messageParseQosStats+    MessageParseQosStatsMethodInfo          ,+    messageParseQosStats                    ,+++-- ** messageParseQosValues+    MessageParseQosValuesMethodInfo         ,+    messageParseQosValues                   ,+++-- ** messageParseRequestState+    MessageParseRequestStateMethodInfo      ,+    messageParseRequestState                ,+++-- ** messageParseResetTime+    MessageParseResetTimeMethodInfo         ,+    messageParseResetTime                   ,+++-- ** messageParseSegmentDone+    MessageParseSegmentDoneMethodInfo       ,+    messageParseSegmentDone                 ,+++-- ** messageParseSegmentStart+    MessageParseSegmentStartMethodInfo      ,+    messageParseSegmentStart                ,+++-- ** messageParseStateChanged+    MessageParseStateChangedMethodInfo      ,+    messageParseStateChanged                ,+++-- ** messageParseStepDone+    MessageParseStepDoneMethodInfo          ,+    messageParseStepDone                    ,+++-- ** messageParseStepStart+    MessageParseStepStartMethodInfo         ,+    messageParseStepStart                   ,+++-- ** messageParseStreamStatus+    MessageParseStreamStatusMethodInfo      ,+    messageParseStreamStatus                ,+++-- ** messageParseStructureChange+    MessageParseStructureChangeMethodInfo   ,+    messageParseStructureChange             ,+++-- ** messageParseTag+    MessageParseTagMethodInfo               ,+    messageParseTag                         ,+++-- ** messageParseToc+    MessageParseTocMethodInfo               ,+    messageParseToc                         ,+++-- ** messageParseWarning+    MessageParseWarningMethodInfo           ,+    messageParseWarning                     ,+++-- ** messageSetBufferingStats+    MessageSetBufferingStatsMethodInfo      ,+    messageSetBufferingStats                ,+++-- ** messageSetGroupId+    MessageSetGroupIdMethodInfo             ,+    messageSetGroupId                       ,+++-- ** messageSetQosStats+    MessageSetQosStatsMethodInfo            ,+    messageSetQosStats                      ,+++-- ** messageSetQosValues+    MessageSetQosValuesMethodInfo           ,+    messageSetQosValues                     ,+++-- ** messageSetSeqnum+    MessageSetSeqnumMethodInfo              ,+    messageSetSeqnum                        ,+++-- ** messageSetStreamStatusObject+    MessageSetStreamStatusObjectMethodInfo  ,+    messageSetStreamStatusObject            ,+++++ -- * Properties+-- ** MiniObject+    messageReadMiniObject                   ,+++-- ** Seqnum+    messageReadSeqnum                       ,+++-- ** Src+    messageReadSrc                          ,+++-- ** Timestamp+    messageReadTimestamp                    ,+++-- ** Type+    messageReadType                         ,+++++    ) 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 GI.Gst.Callbacks++newtype Message = Message (ForeignPtr Message)+foreign import ccall "gst_message_get_type" c_gst_message_get_type :: +    IO GType++instance BoxedObject Message where+    boxedType _ = c_gst_message_get_type++-- | Construct a `Message` struct initialized to zero.+newZeroMessage :: MonadIO m => m Message+newZeroMessage = liftIO $ callocBoxedBytes 120 >>= wrapBoxed Message++noMessage :: Maybe Message+noMessage = Nothing++messageReadMiniObject :: Message -> IO MiniObject+messageReadMiniObject s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)+    val' <- (newPtr 64 MiniObject) val+    return val'++messageReadType :: Message -> IO [MessageType]+messageReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO CUInt+    let val' = wordToGFlags val+    return val'++messageReadTimestamp :: Message -> IO Word64+messageReadTimestamp s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO Word64+    return val++messageReadSrc :: Message -> IO Object+messageReadSrc s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 80) :: IO (Ptr Object)+    val' <- (newObject Object) val+    return val'++messageReadSeqnum :: Message -> IO Word32+messageReadSeqnum s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 88) :: IO Word32+    return val++-- method Message::new_application+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_application" gst_message_new_application :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO (Ptr Message)+++messageNewApplication ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Structure                            -- structure+    -> m Message                            -- result+messageNewApplication src structure = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    structure' <- copyBoxed structure+    result <- gst_message_new_application maybeSrc structure'+    checkUnexpectedReturnNULL "gst_message_new_application" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr structure+    return result'++-- method Message::new_async_done+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_async_done" gst_message_new_async_done :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Word64 ->                               -- running_time : TBasicType TUInt64+    IO (Ptr Message)+++messageNewAsyncDone ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Word64                               -- runningTime+    -> m Message                            -- result+messageNewAsyncDone src runningTime = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_async_done maybeSrc runningTime+    checkUnexpectedReturnNULL "gst_message_new_async_done" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_async_start+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_async_start" gst_message_new_async_start :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    IO (Ptr Message)+++messageNewAsyncStart ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> m Message                            -- result+messageNewAsyncStart src = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_async_start maybeSrc+    checkUnexpectedReturnNULL "gst_message_new_async_start" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_buffering+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_buffering" gst_message_new_buffering :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Int32 ->                                -- percent : TBasicType TInt32+    IO (Ptr Message)+++messageNewBuffering ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Int32                                -- percent+    -> m Message                            -- result+messageNewBuffering src percent = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_buffering maybeSrc percent+    checkUnexpectedReturnNULL "gst_message_new_buffering" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_clock_lost+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_clock_lost" gst_message_new_clock_lost :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"+    IO (Ptr Message)+++messageNewClockLost ::+    (MonadIO m, ObjectK a, ClockK b) =>+    Maybe (a)                               -- src+    -> b                                    -- clock+    -> m Message                            -- result+messageNewClockLost src clock = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let clock' = unsafeManagedPtrCastPtr clock+    result <- gst_message_new_clock_lost maybeSrc clock'+    checkUnexpectedReturnNULL "gst_message_new_clock_lost" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr clock+    return result'++-- method Message::new_clock_provide+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ready", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_clock_provide" gst_message_new_clock_provide :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"+    CInt ->                                 -- ready : TBasicType TBoolean+    IO (Ptr Message)+++messageNewClockProvide ::+    (MonadIO m, ObjectK a, ClockK b) =>+    Maybe (a)                               -- src+    -> b                                    -- clock+    -> Bool                                 -- ready+    -> m Message                            -- result+messageNewClockProvide src clock ready = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let clock' = unsafeManagedPtrCastPtr clock+    let ready' = (fromIntegral . fromEnum) ready+    result <- gst_message_new_clock_provide maybeSrc clock' ready'+    checkUnexpectedReturnNULL "gst_message_new_clock_provide" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr clock+    return result'++-- method Message::new_custom+-- method type : Constructor+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_custom" gst_message_new_custom :: +    CUInt ->                                -- type : TInterface "Gst" "MessageType"+    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO (Ptr Message)+++messageNewCustom ::+    (MonadIO m, ObjectK a) =>+    [MessageType]                           -- type_+    -> Maybe (a)                            -- src+    -> Maybe (Structure)                    -- structure+    -> m Message                            -- result+messageNewCustom type_ src structure = liftIO $ do+    let type_' = gflagsToWord type_+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    maybeStructure <- case structure of+        Nothing -> return nullPtr+        Just jStructure -> do+            jStructure' <- copyBoxed jStructure+            return jStructure'+    result <- gst_message_new_custom type_' maybeSrc maybeStructure+    checkUnexpectedReturnNULL "gst_message_new_custom" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    whenJust structure touchManagedPtr+    return result'++-- method Message::new_device_added+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_device_added" gst_message_new_device_added :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Device ->                           -- device : TInterface "Gst" "Device"+    IO (Ptr Message)+++messageNewDeviceAdded ::+    (MonadIO m, ObjectK a, DeviceK b) =>+    a                                       -- src+    -> b                                    -- device+    -> m Message                            -- result+messageNewDeviceAdded src device = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let device' = unsafeManagedPtrCastPtr device+    result <- gst_message_new_device_added src' device'+    checkUnexpectedReturnNULL "gst_message_new_device_added" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    touchManagedPtr device+    return result'++-- method Message::new_device_removed+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_device_removed" gst_message_new_device_removed :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Device ->                           -- device : TInterface "Gst" "Device"+    IO (Ptr Message)+++messageNewDeviceRemoved ::+    (MonadIO m, ObjectK a, DeviceK b) =>+    a                                       -- src+    -> b                                    -- device+    -> m Message                            -- result+messageNewDeviceRemoved src device = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let device' = unsafeManagedPtrCastPtr device+    result <- gst_message_new_device_removed src' device'+    checkUnexpectedReturnNULL "gst_message_new_device_removed" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    touchManagedPtr device+    return result'++-- method Message::new_duration_changed+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_duration_changed" gst_message_new_duration_changed :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    IO (Ptr Message)+++messageNewDurationChanged ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> m Message                            -- result+messageNewDurationChanged src = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_duration_changed maybeSrc+    checkUnexpectedReturnNULL "gst_message_new_duration_changed" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_element+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_element" gst_message_new_element :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO (Ptr Message)+++messageNewElement ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Structure                            -- structure+    -> m Message                            -- result+messageNewElement src structure = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    structure' <- copyBoxed structure+    result <- gst_message_new_element maybeSrc structure'+    checkUnexpectedReturnNULL "gst_message_new_element" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr structure+    return result'++-- method Message::new_eos+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_eos" gst_message_new_eos :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    IO (Ptr Message)+++messageNewEos ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> m Message                            -- result+messageNewEos src = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_eos maybeSrc+    checkUnexpectedReturnNULL "gst_message_new_eos" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_error+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_error" gst_message_new_error :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr GError ->                           -- error : TError+    CString ->                              -- debug : TBasicType TUTF8+    IO (Ptr Message)+++messageNewError ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> GError                               -- error_+    -> T.Text                               -- debug+    -> m Message                            -- result+messageNewError src error_ debug = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let error_' = unsafeManagedPtrGetPtr error_+    debug' <- textToCString debug+    result <- gst_message_new_error maybeSrc error_' debug'+    checkUnexpectedReturnNULL "gst_message_new_error" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr error_+    freeMem debug'+    return result'++-- method Message::new_have_context+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_have_context" gst_message_new_have_context :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Context ->                          -- context : TInterface "Gst" "Context"+    IO (Ptr Message)+++messageNewHaveContext ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Context                              -- context+    -> m Message                            -- result+messageNewHaveContext src context = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    context' <- copyBoxed context+    result <- gst_message_new_have_context maybeSrc context'+    checkUnexpectedReturnNULL "gst_message_new_have_context" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr context+    return result'++-- method Message::new_info+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_info" gst_message_new_info :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr GError ->                           -- error : TError+    CString ->                              -- debug : TBasicType TUTF8+    IO (Ptr Message)+++messageNewInfo ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> GError                               -- error_+    -> T.Text                               -- debug+    -> m Message                            -- result+messageNewInfo src error_ debug = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let error_' = unsafeManagedPtrGetPtr error_+    debug' <- textToCString debug+    result <- gst_message_new_info maybeSrc error_' debug'+    checkUnexpectedReturnNULL "gst_message_new_info" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr error_+    freeMem debug'+    return result'++-- method Message::new_latency+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_latency" gst_message_new_latency :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    IO (Ptr Message)+++messageNewLatency ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> m Message                            -- result+messageNewLatency src = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_latency maybeSrc+    checkUnexpectedReturnNULL "gst_message_new_latency" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_need_context+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_need_context" gst_message_new_need_context :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CString ->                              -- context_type : TBasicType TUTF8+    IO (Ptr Message)+++messageNewNeedContext ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> T.Text                               -- contextType+    -> m Message                            -- result+messageNewNeedContext src contextType = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    contextType' <- textToCString contextType+    result <- gst_message_new_need_context maybeSrc contextType'+    checkUnexpectedReturnNULL "gst_message_new_need_context" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    freeMem contextType'+    return result'++-- method Message::new_new_clock+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_new_clock" gst_message_new_new_clock :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"+    IO (Ptr Message)+++messageNewNewClock ::+    (MonadIO m, ObjectK a, ClockK b) =>+    Maybe (a)                               -- src+    -> b                                    -- clock+    -> m Message                            -- result+messageNewNewClock src clock = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let clock' = unsafeManagedPtrCastPtr clock+    result <- gst_message_new_new_clock maybeSrc clock'+    checkUnexpectedReturnNULL "gst_message_new_new_clock" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr clock+    return result'++-- method Message::new_progress+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "ProgressType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_progress" gst_message_new_progress :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- type : TInterface "Gst" "ProgressType"+    CString ->                              -- code : TBasicType TUTF8+    CString ->                              -- text : TBasicType TUTF8+    IO (Ptr Message)+++messageNewProgress ::+    (MonadIO m, ObjectK a) =>+    a                                       -- src+    -> ProgressType                         -- type_+    -> T.Text                               -- code+    -> T.Text                               -- text+    -> m Message                            -- result+messageNewProgress src type_ code text = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let type_' = (fromIntegral . fromEnum) type_+    code' <- textToCString code+    text' <- textToCString text+    result <- gst_message_new_progress src' type_' code' text'+    checkUnexpectedReturnNULL "gst_message_new_progress" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    freeMem code'+    freeMem text'+    return result'++-- method Message::new_qos+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_qos" gst_message_new_qos :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CInt ->                                 -- live : TBasicType TBoolean+    Word64 ->                               -- running_time : TBasicType TUInt64+    Word64 ->                               -- stream_time : TBasicType TUInt64+    Word64 ->                               -- timestamp : TBasicType TUInt64+    Word64 ->                               -- duration : TBasicType TUInt64+    IO (Ptr Message)+++messageNewQos ::+    (MonadIO m, ObjectK a) =>+    a                                       -- src+    -> Bool                                 -- live+    -> Word64                               -- runningTime+    -> Word64                               -- streamTime+    -> Word64                               -- timestamp+    -> Word64                               -- duration+    -> m Message                            -- result+messageNewQos src live runningTime streamTime timestamp duration = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let live' = (fromIntegral . fromEnum) live+    result <- gst_message_new_qos src' live' runningTime streamTime timestamp duration+    checkUnexpectedReturnNULL "gst_message_new_qos" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    return result'++-- method Message::new_request_state+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_request_state" gst_message_new_request_state :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- state : TInterface "Gst" "State"+    IO (Ptr Message)+++messageNewRequestState ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> State                                -- state+    -> m Message                            -- result+messageNewRequestState src state = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let state' = (fromIntegral . fromEnum) state+    result <- gst_message_new_request_state maybeSrc state'+    checkUnexpectedReturnNULL "gst_message_new_request_state" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_reset_time+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_reset_time" gst_message_new_reset_time :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Word64 ->                               -- running_time : TBasicType TUInt64+    IO (Ptr Message)+++messageNewResetTime ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Word64                               -- runningTime+    -> m Message                            -- result+messageNewResetTime src runningTime = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_reset_time maybeSrc runningTime+    checkUnexpectedReturnNULL "gst_message_new_reset_time" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_segment_done+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_segment_done" gst_message_new_segment_done :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- position : TBasicType TInt64+    IO (Ptr Message)+++messageNewSegmentDone ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Format                               -- format+    -> Int64                                -- position+    -> m Message                            -- result+messageNewSegmentDone src format position = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let format' = (fromIntegral . fromEnum) format+    result <- gst_message_new_segment_done maybeSrc format' position+    checkUnexpectedReturnNULL "gst_message_new_segment_done" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_segment_start+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_segment_start" gst_message_new_segment_start :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- position : TBasicType TInt64+    IO (Ptr Message)+++messageNewSegmentStart ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> Format                               -- format+    -> Int64                                -- position+    -> m Message                            -- result+messageNewSegmentStart src format position = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let format' = (fromIntegral . fromEnum) format+    result <- gst_message_new_segment_start maybeSrc format' position+    checkUnexpectedReturnNULL "gst_message_new_segment_start" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_state_changed+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oldstate", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "newstate", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pending", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_state_changed" gst_message_new_state_changed :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- oldstate : TInterface "Gst" "State"+    CUInt ->                                -- newstate : TInterface "Gst" "State"+    CUInt ->                                -- pending : TInterface "Gst" "State"+    IO (Ptr Message)+++messageNewStateChanged ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> State                                -- oldstate+    -> State                                -- newstate+    -> State                                -- pending+    -> m Message                            -- result+messageNewStateChanged src oldstate newstate pending = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let oldstate' = (fromIntegral . fromEnum) oldstate+    let newstate' = (fromIntegral . fromEnum) newstate+    let pending' = (fromIntegral . fromEnum) pending+    result <- gst_message_new_state_changed maybeSrc oldstate' newstate' pending'+    checkUnexpectedReturnNULL "gst_message_new_state_changed" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_state_dirty+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_state_dirty" gst_message_new_state_dirty :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    IO (Ptr Message)+++messageNewStateDirty ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> m Message                            -- result+messageNewStateDirty src = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_state_dirty maybeSrc+    checkUnexpectedReturnNULL "gst_message_new_state_dirty" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_step_done+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "eos", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_step_done" gst_message_new_step_done :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- amount : TBasicType TUInt64+    CDouble ->                              -- rate : TBasicType TDouble+    CInt ->                                 -- flush : TBasicType TBoolean+    CInt ->                                 -- intermediate : TBasicType TBoolean+    Word64 ->                               -- duration : TBasicType TUInt64+    CInt ->                                 -- eos : TBasicType TBoolean+    IO (Ptr Message)+++messageNewStepDone ::+    (MonadIO m, ObjectK a) =>+    a                                       -- src+    -> Format                               -- format+    -> Word64                               -- amount+    -> Double                               -- rate+    -> Bool                                 -- flush+    -> Bool                                 -- intermediate+    -> Word64                               -- duration+    -> Bool                                 -- eos+    -> m Message                            -- result+messageNewStepDone src format amount rate flush intermediate duration eos = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let format' = (fromIntegral . fromEnum) format+    let rate' = realToFrac rate+    let flush' = (fromIntegral . fromEnum) flush+    let intermediate' = (fromIntegral . fromEnum) intermediate+    let eos' = (fromIntegral . fromEnum) eos+    result <- gst_message_new_step_done src' format' amount rate' flush' intermediate' duration eos'+    checkUnexpectedReturnNULL "gst_message_new_step_done" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    return result'++-- method Message::new_step_start+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_step_start" gst_message_new_step_start :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CInt ->                                 -- active : TBasicType TBoolean+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- amount : TBasicType TUInt64+    CDouble ->                              -- rate : TBasicType TDouble+    CInt ->                                 -- flush : TBasicType TBoolean+    CInt ->                                 -- intermediate : TBasicType TBoolean+    IO (Ptr Message)+++messageNewStepStart ::+    (MonadIO m, ObjectK a) =>+    a                                       -- src+    -> Bool                                 -- active+    -> Format                               -- format+    -> Word64                               -- amount+    -> Double                               -- rate+    -> Bool                                 -- flush+    -> Bool                                 -- intermediate+    -> m Message                            -- result+messageNewStepStart src active format amount rate flush intermediate = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let active' = (fromIntegral . fromEnum) active+    let format' = (fromIntegral . fromEnum) format+    let rate' = realToFrac rate+    let flush' = (fromIntegral . fromEnum) flush+    let intermediate' = (fromIntegral . fromEnum) intermediate+    result <- gst_message_new_step_start src' active' format' amount rate' flush' intermediate'+    checkUnexpectedReturnNULL "gst_message_new_step_start" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    return result'++-- method Message::new_stream_start+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_stream_start" gst_message_new_stream_start :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    IO (Ptr Message)+++messageNewStreamStart ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> m Message                            -- result+messageNewStreamStart src = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    result <- gst_message_new_stream_start maybeSrc+    checkUnexpectedReturnNULL "gst_message_new_stream_start" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    return result'++-- method Message::new_stream_status+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StreamStatusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_stream_status" gst_message_new_stream_status :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- type : TInterface "Gst" "StreamStatusType"+    Ptr Element ->                          -- owner : TInterface "Gst" "Element"+    IO (Ptr Message)+++messageNewStreamStatus ::+    (MonadIO m, ObjectK a, ElementK b) =>+    a                                       -- src+    -> StreamStatusType                     -- type_+    -> b                                    -- owner+    -> m Message                            -- result+messageNewStreamStatus src type_ owner = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let type_' = (fromIntegral . fromEnum) type_+    let owner' = unsafeManagedPtrCastPtr owner+    result <- gst_message_new_stream_status src' type_' owner'+    checkUnexpectedReturnNULL "gst_message_new_stream_status" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    touchManagedPtr owner+    return result'++-- method Message::new_structure_change+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StructureChangeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_structure_change" gst_message_new_structure_change :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    CUInt ->                                -- type : TInterface "Gst" "StructureChangeType"+    Ptr Element ->                          -- owner : TInterface "Gst" "Element"+    CInt ->                                 -- busy : TBasicType TBoolean+    IO (Ptr Message)+++messageNewStructureChange ::+    (MonadIO m, ObjectK a, ElementK b) =>+    Maybe (a)                               -- src+    -> StructureChangeType                  -- type_+    -> b                                    -- owner+    -> Bool                                 -- busy+    -> m Message                            -- result+messageNewStructureChange src type_ owner busy = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let type_' = (fromIntegral . fromEnum) type_+    let owner' = unsafeManagedPtrCastPtr owner+    let busy' = (fromIntegral . fromEnum) busy+    result <- gst_message_new_structure_change maybeSrc type_' owner' busy'+    checkUnexpectedReturnNULL "gst_message_new_structure_change" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr owner+    return result'++-- method Message::new_tag+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_list", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_tag" gst_message_new_tag :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr TagList ->                          -- tag_list : TInterface "Gst" "TagList"+    IO (Ptr Message)+++messageNewTag ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> TagList                              -- tagList+    -> m Message                            -- result+messageNewTag src tagList = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    tagList' <- copyBoxed tagList+    result <- gst_message_new_tag maybeSrc tagList'+    checkUnexpectedReturnNULL "gst_message_new_tag" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr tagList+    return result'++-- method Message::new_toc+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_toc" gst_message_new_toc :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr Toc ->                              -- toc : TInterface "Gst" "Toc"+    CInt ->                                 -- updated : TBasicType TBoolean+    IO (Ptr Message)+++messageNewToc ::+    (MonadIO m, ObjectK a) =>+    a                                       -- src+    -> Toc                                  -- toc+    -> Bool                                 -- updated+    -> m Message                            -- result+messageNewToc src toc updated = liftIO $ do+    let src' = unsafeManagedPtrCastPtr src+    let toc' = unsafeManagedPtrGetPtr toc+    let updated' = (fromIntegral . fromEnum) updated+    result <- gst_message_new_toc src' toc' updated'+    checkUnexpectedReturnNULL "gst_message_new_toc" result+    result' <- (wrapBoxed Message) result+    touchManagedPtr src+    touchManagedPtr toc+    return result'++-- method Message::new_warning+-- method type : Constructor+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Message"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_new_warning" gst_message_new_warning :: +    Ptr Object ->                           -- src : TInterface "Gst" "Object"+    Ptr GError ->                           -- error : TError+    CString ->                              -- debug : TBasicType TUTF8+    IO (Ptr Message)+++messageNewWarning ::+    (MonadIO m, ObjectK a) =>+    Maybe (a)                               -- src+    -> GError                               -- error_+    -> T.Text                               -- debug+    -> m Message                            -- result+messageNewWarning src error_ debug = liftIO $ do+    maybeSrc <- case src of+        Nothing -> return nullPtr+        Just jSrc -> do+            let jSrc' = unsafeManagedPtrCastPtr jSrc+            return jSrc'+    let error_' = unsafeManagedPtrGetPtr error_+    debug' <- textToCString debug+    result <- gst_message_new_warning maybeSrc error_' debug'+    checkUnexpectedReturnNULL "gst_message_new_warning" result+    result' <- (wrapBoxed Message) result+    whenJust src touchManagedPtr+    touchManagedPtr error_+    freeMem debug'+    return result'++-- method Message::get_seqnum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_get_seqnum" gst_message_get_seqnum :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    IO Word32+++messageGetSeqnum ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m Word32                             -- result+messageGetSeqnum _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_message_get_seqnum _obj'+    touchManagedPtr _obj+    return result++data MessageGetSeqnumMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo MessageGetSeqnumMethodInfo Message signature where+    overloadedMethod _ = messageGetSeqnum++-- method Message::get_stream_status_object+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_get_stream_status_object" gst_message_get_stream_status_object :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    IO (Ptr GValue)+++messageGetStreamStatusObject ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m GValue                             -- result+messageGetStreamStatusObject _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_message_get_stream_status_object _obj'+    checkUnexpectedReturnNULL "gst_message_get_stream_status_object" result+    result' <- (newBoxed GValue) result+    touchManagedPtr _obj+    return result'++data MessageGetStreamStatusObjectMethodInfo+instance (signature ~ (m GValue), MonadIO m) => MethodInfo MessageGetStreamStatusObjectMethodInfo Message signature where+    overloadedMethod _ = messageGetStreamStatusObject++-- method Message::get_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_get_structure" gst_message_get_structure :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    IO (Ptr Structure)+++messageGetStructure ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m Structure                          -- result+messageGetStructure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_message_get_structure _obj'+    checkUnexpectedReturnNULL "gst_message_get_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data MessageGetStructureMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo MessageGetStructureMethodInfo Message signature where+    overloadedMethod _ = messageGetStructure++-- method Message::has_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_has_name" gst_message_has_name :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++messageHasName ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> T.Text                               -- name+    -> m Bool                               -- result+messageHasName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- gst_message_has_name _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data MessageHasNameMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo MessageHasNameMethodInfo Message signature where+    overloadedMethod _ = messageHasName++-- method Message::parse_async_done+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_async_done" gst_message_parse_async_done :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64+    IO ()+++messageParseAsyncDone ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Word64)                           -- result+messageParseAsyncDone _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    runningTime <- allocMem :: IO (Ptr Word64)+    gst_message_parse_async_done _obj' runningTime+    runningTime' <- peek runningTime+    touchManagedPtr _obj+    freeMem runningTime+    return runningTime'++data MessageParseAsyncDoneMethodInfo+instance (signature ~ (m (Word64)), MonadIO m) => MethodInfo MessageParseAsyncDoneMethodInfo Message signature where+    overloadedMethod _ = messageParseAsyncDone++-- method Message::parse_buffering+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_buffering" gst_message_parse_buffering :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr Int32 ->                            -- percent : TBasicType TInt32+    IO ()+++messageParseBuffering ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Int32)                            -- result+messageParseBuffering _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    percent <- allocMem :: IO (Ptr Int32)+    gst_message_parse_buffering _obj' percent+    percent' <- peek percent+    touchManagedPtr _obj+    freeMem percent+    return percent'++data MessageParseBufferingMethodInfo+instance (signature ~ (m (Int32)), MonadIO m) => MethodInfo MessageParseBufferingMethodInfo Message signature where+    overloadedMethod _ = messageParseBuffering++-- method Message::parse_buffering_stats+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_buffering_stats" gst_message_parse_buffering_stats :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- mode : TInterface "Gst" "BufferingMode"+    Ptr Int32 ->                            -- avg_in : TBasicType TInt32+    Ptr Int32 ->                            -- avg_out : TBasicType TInt32+    Ptr Int64 ->                            -- buffering_left : TBasicType TInt64+    IO ()+++messageParseBufferingStats ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (BufferingMode,Int32,Int32,Int64)  -- result+messageParseBufferingStats _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mode <- allocMem :: IO (Ptr CUInt)+    avgIn <- allocMem :: IO (Ptr Int32)+    avgOut <- allocMem :: IO (Ptr Int32)+    bufferingLeft <- allocMem :: IO (Ptr Int64)+    gst_message_parse_buffering_stats _obj' mode avgIn avgOut bufferingLeft+    mode' <- peek mode+    let mode'' = (toEnum . fromIntegral) mode'+    avgIn' <- peek avgIn+    avgOut' <- peek avgOut+    bufferingLeft' <- peek bufferingLeft+    touchManagedPtr _obj+    freeMem mode+    freeMem avgIn+    freeMem avgOut+    freeMem bufferingLeft+    return (mode'', avgIn', avgOut', bufferingLeft')++data MessageParseBufferingStatsMethodInfo+instance (signature ~ (m (BufferingMode,Int32,Int32,Int64)), MonadIO m) => MethodInfo MessageParseBufferingStatsMethodInfo Message signature where+    overloadedMethod _ = messageParseBufferingStats++-- method Message::parse_clock_lost+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_clock_lost" gst_message_parse_clock_lost :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr (Ptr Clock) ->                      -- clock : TInterface "Gst" "Clock"+    IO ()+++messageParseClockLost ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Clock)                            -- result+messageParseClockLost _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    clock <- allocMem :: IO (Ptr (Ptr Clock))+    gst_message_parse_clock_lost _obj' clock+    clock' <- peek clock+    clock'' <- (newObject Clock) clock'+    touchManagedPtr _obj+    freeMem clock+    return clock''++data MessageParseClockLostMethodInfo+instance (signature ~ (m (Clock)), MonadIO m) => MethodInfo MessageParseClockLostMethodInfo Message signature where+    overloadedMethod _ = messageParseClockLost++-- method Message::parse_clock_provide+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ready", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_clock_provide" gst_message_parse_clock_provide :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr (Ptr Clock) ->                      -- clock : TInterface "Gst" "Clock"+    Ptr CInt ->                             -- ready : TBasicType TBoolean+    IO ()+++messageParseClockProvide ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Clock,Bool)                       -- result+messageParseClockProvide _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    clock <- allocMem :: IO (Ptr (Ptr Clock))+    ready <- allocMem :: IO (Ptr CInt)+    gst_message_parse_clock_provide _obj' clock ready+    clock' <- peek clock+    clock'' <- (newObject Clock) clock'+    ready' <- peek ready+    let ready'' = (/= 0) ready'+    touchManagedPtr _obj+    freeMem clock+    freeMem ready+    return (clock'', ready'')++data MessageParseClockProvideMethodInfo+instance (signature ~ (m (Clock,Bool)), MonadIO m) => MethodInfo MessageParseClockProvideMethodInfo Message signature where+    overloadedMethod _ = messageParseClockProvide++-- method Message::parse_context_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_context_type" gst_message_parse_context_type :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CString ->                          -- context_type : TBasicType TUTF8+    IO CInt+++messageParseContextType ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Bool,T.Text)                      -- result+messageParseContextType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    contextType <- allocMem :: IO (Ptr CString)+    result <- gst_message_parse_context_type _obj' contextType+    let result' = (/= 0) result+    contextType' <- peek contextType+    contextType'' <- cstringToText contextType'+    freeMem contextType'+    touchManagedPtr _obj+    freeMem contextType+    return (result', contextType'')++data MessageParseContextTypeMethodInfo+instance (signature ~ (m (Bool,T.Text)), MonadIO m) => MethodInfo MessageParseContextTypeMethodInfo Message signature where+    overloadedMethod _ = messageParseContextType++-- method Message::parse_device_added+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_device_added" gst_message_parse_device_added :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr (Ptr Device) ->                     -- device : TInterface "Gst" "Device"+    IO ()+++messageParseDeviceAdded ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Device)                           -- result+messageParseDeviceAdded _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    device <- allocMem :: IO (Ptr (Ptr Device))+    gst_message_parse_device_added _obj' device+    device' <- peek device+    device'' <- (newObject Device) device'+    touchManagedPtr _obj+    freeMem device+    return device''++data MessageParseDeviceAddedMethodInfo+instance (signature ~ (m (Device)), MonadIO m) => MethodInfo MessageParseDeviceAddedMethodInfo Message signature where+    overloadedMethod _ = messageParseDeviceAdded++-- method Message::parse_device_removed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_device_removed" gst_message_parse_device_removed :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr (Ptr Device) ->                     -- device : TInterface "Gst" "Device"+    IO ()+++messageParseDeviceRemoved ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Device)                           -- result+messageParseDeviceRemoved _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    device <- allocMem :: IO (Ptr (Ptr Device))+    gst_message_parse_device_removed _obj' device+    device' <- peek device+    device'' <- (newObject Device) device'+    touchManagedPtr _obj+    freeMem device+    return device''++data MessageParseDeviceRemovedMethodInfo+instance (signature ~ (m (Device)), MonadIO m) => MethodInfo MessageParseDeviceRemovedMethodInfo Message signature where+    overloadedMethod _ = messageParseDeviceRemoved++-- method Message::parse_error+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gerror", argType = TError, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_error" gst_message_parse_error :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr GError ->                           -- gerror : TError+    Ptr CString ->                          -- debug : TBasicType TUTF8+    IO ()+++messageParseError ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (GError,T.Text)                    -- result+messageParseError _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gerror <- callocBoxedBytes 16 :: IO (Ptr GError)+    debug <- allocMem :: IO (Ptr CString)+    gst_message_parse_error _obj' gerror debug+    gerror' <- (wrapBoxed GError) gerror+    debug' <- peek debug+    debug'' <- cstringToText debug'+    freeMem debug'+    touchManagedPtr _obj+    freeMem debug+    return (gerror', debug'')++data MessageParseErrorMethodInfo+instance (signature ~ (m (GError,T.Text)), MonadIO m) => MethodInfo MessageParseErrorMethodInfo Message signature where+    overloadedMethod _ = messageParseError++-- method Message::parse_group_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_group_id" gst_message_parse_group_id :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr Word32 ->                           -- group_id : TBasicType TUInt32+    IO CInt+++messageParseGroupId ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Bool,Word32)                      -- result+messageParseGroupId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    groupId <- allocMem :: IO (Ptr Word32)+    result <- gst_message_parse_group_id _obj' groupId+    let result' = (/= 0) result+    groupId' <- peek groupId+    touchManagedPtr _obj+    freeMem groupId+    return (result', groupId')++data MessageParseGroupIdMethodInfo+instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo MessageParseGroupIdMethodInfo Message signature where+    overloadedMethod _ = messageParseGroupId++-- method Message::parse_have_context+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_have_context" gst_message_parse_have_context :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr (Ptr Context) ->                    -- context : TInterface "Gst" "Context"+    IO ()+++messageParseHaveContext ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Context)                          -- result+messageParseHaveContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    context <- allocMem :: IO (Ptr (Ptr Context))+    gst_message_parse_have_context _obj' context+    context' <- peek context+    context'' <- (wrapBoxed Context) context'+    touchManagedPtr _obj+    freeMem context+    return context''++data MessageParseHaveContextMethodInfo+instance (signature ~ (m (Context)), MonadIO m) => MethodInfo MessageParseHaveContextMethodInfo Message signature where+    overloadedMethod _ = messageParseHaveContext++-- method Message::parse_info+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gerror", argType = TError, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_info" gst_message_parse_info :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr GError ->                           -- gerror : TError+    Ptr CString ->                          -- debug : TBasicType TUTF8+    IO ()+++messageParseInfo ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (GError,T.Text)                    -- result+messageParseInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gerror <- callocBoxedBytes 16 :: IO (Ptr GError)+    debug <- allocMem :: IO (Ptr CString)+    gst_message_parse_info _obj' gerror debug+    gerror' <- (wrapBoxed GError) gerror+    debug' <- peek debug+    debug'' <- cstringToText debug'+    freeMem debug'+    touchManagedPtr _obj+    freeMem debug+    return (gerror', debug'')++data MessageParseInfoMethodInfo+instance (signature ~ (m (GError,T.Text)), MonadIO m) => MethodInfo MessageParseInfoMethodInfo Message signature where+    overloadedMethod _ = messageParseInfo++-- method Message::parse_new_clock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_new_clock" gst_message_parse_new_clock :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr (Ptr Clock) ->                      -- clock : TInterface "Gst" "Clock"+    IO ()+++messageParseNewClock ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Clock)                            -- result+messageParseNewClock _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    clock <- allocMem :: IO (Ptr (Ptr Clock))+    gst_message_parse_new_clock _obj' clock+    clock' <- peek clock+    clock'' <- (newObject Clock) clock'+    touchManagedPtr _obj+    freeMem clock+    return clock''++data MessageParseNewClockMethodInfo+instance (signature ~ (m (Clock)), MonadIO m) => MethodInfo MessageParseNewClockMethodInfo Message signature where+    overloadedMethod _ = messageParseNewClock++-- method Message::parse_progress+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "ProgressType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_progress" gst_message_parse_progress :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- type : TInterface "Gst" "ProgressType"+    Ptr CString ->                          -- code : TBasicType TUTF8+    Ptr CString ->                          -- text : TBasicType TUTF8+    IO ()+++messageParseProgress ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (ProgressType,T.Text,T.Text)       -- result+messageParseProgress _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    type_ <- allocMem :: IO (Ptr CUInt)+    code <- allocMem :: IO (Ptr CString)+    text <- allocMem :: IO (Ptr CString)+    gst_message_parse_progress _obj' type_ code text+    type_' <- peek type_+    let type_'' = (toEnum . fromIntegral) type_'+    code' <- peek code+    code'' <- cstringToText code'+    freeMem code'+    text' <- peek text+    text'' <- cstringToText text'+    freeMem text'+    touchManagedPtr _obj+    freeMem type_+    freeMem code+    freeMem text+    return (type_'', code'', text'')++data MessageParseProgressMethodInfo+instance (signature ~ (m (ProgressType,T.Text,T.Text)), MonadIO m) => MethodInfo MessageParseProgressMethodInfo Message signature where+    overloadedMethod _ = messageParseProgress++-- method Message::parse_qos+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_qos" gst_message_parse_qos :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CInt ->                             -- live : TBasicType TBoolean+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64+    Ptr Word64 ->                           -- stream_time : TBasicType TUInt64+    Ptr Word64 ->                           -- timestamp : TBasicType TUInt64+    Ptr Word64 ->                           -- duration : TBasicType TUInt64+    IO ()+++messageParseQos ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Bool,Word64,Word64,Word64,Word64) -- result+messageParseQos _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    live <- allocMem :: IO (Ptr CInt)+    runningTime <- allocMem :: IO (Ptr Word64)+    streamTime <- allocMem :: IO (Ptr Word64)+    timestamp <- allocMem :: IO (Ptr Word64)+    duration <- allocMem :: IO (Ptr Word64)+    gst_message_parse_qos _obj' live runningTime streamTime timestamp duration+    live' <- peek live+    let live'' = (/= 0) live'+    runningTime' <- peek runningTime+    streamTime' <- peek streamTime+    timestamp' <- peek timestamp+    duration' <- peek duration+    touchManagedPtr _obj+    freeMem live+    freeMem runningTime+    freeMem streamTime+    freeMem timestamp+    freeMem duration+    return (live'', runningTime', streamTime', timestamp', duration')++data MessageParseQosMethodInfo+instance (signature ~ (m (Bool,Word64,Word64,Word64,Word64)), MonadIO m) => MethodInfo MessageParseQosMethodInfo Message signature where+    overloadedMethod _ = messageParseQos++-- method Message::parse_qos_stats+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "processed", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dropped", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_qos_stats" gst_message_parse_qos_stats :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Word64 ->                           -- processed : TBasicType TUInt64+    Ptr Word64 ->                           -- dropped : TBasicType TUInt64+    IO ()+++messageParseQosStats ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Format,Word64,Word64)             -- result+messageParseQosStats _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    processed <- allocMem :: IO (Ptr Word64)+    dropped <- allocMem :: IO (Ptr Word64)+    gst_message_parse_qos_stats _obj' format processed dropped+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    processed' <- peek processed+    dropped' <- peek dropped+    touchManagedPtr _obj+    freeMem format+    freeMem processed+    freeMem dropped+    return (format'', processed', dropped')++data MessageParseQosStatsMethodInfo+instance (signature ~ (m (Format,Word64,Word64)), MonadIO m) => MethodInfo MessageParseQosStatsMethodInfo Message signature where+    overloadedMethod _ = messageParseQosStats++-- method Message::parse_qos_values+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "quality", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_qos_values" gst_message_parse_qos_values :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr Int64 ->                            -- jitter : TBasicType TInt64+    Ptr CDouble ->                          -- proportion : TBasicType TDouble+    Ptr Int32 ->                            -- quality : TBasicType TInt32+    IO ()+++messageParseQosValues ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Int64,Double,Int32)               -- result+messageParseQosValues _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    jitter <- allocMem :: IO (Ptr Int64)+    proportion <- allocMem :: IO (Ptr CDouble)+    quality <- allocMem :: IO (Ptr Int32)+    gst_message_parse_qos_values _obj' jitter proportion quality+    jitter' <- peek jitter+    proportion' <- peek proportion+    let proportion'' = realToFrac proportion'+    quality' <- peek quality+    touchManagedPtr _obj+    freeMem jitter+    freeMem proportion+    freeMem quality+    return (jitter', proportion'', quality')++data MessageParseQosValuesMethodInfo+instance (signature ~ (m (Int64,Double,Int32)), MonadIO m) => MethodInfo MessageParseQosValuesMethodInfo Message signature where+    overloadedMethod _ = messageParseQosValues++-- method Message::parse_request_state+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_request_state" gst_message_parse_request_state :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- state : TInterface "Gst" "State"+    IO ()+++messageParseRequestState ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (State)                            -- result+messageParseRequestState _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    state <- allocMem :: IO (Ptr CUInt)+    gst_message_parse_request_state _obj' state+    state' <- peek state+    let state'' = (toEnum . fromIntegral) state'+    touchManagedPtr _obj+    freeMem state+    return state''++data MessageParseRequestStateMethodInfo+instance (signature ~ (m (State)), MonadIO m) => MethodInfo MessageParseRequestStateMethodInfo Message signature where+    overloadedMethod _ = messageParseRequestState++-- method Message::parse_reset_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_reset_time" gst_message_parse_reset_time :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64+    IO ()+++messageParseResetTime ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Word64)                           -- result+messageParseResetTime _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    runningTime <- allocMem :: IO (Ptr Word64)+    gst_message_parse_reset_time _obj' runningTime+    runningTime' <- peek runningTime+    touchManagedPtr _obj+    freeMem runningTime+    return runningTime'++data MessageParseResetTimeMethodInfo+instance (signature ~ (m (Word64)), MonadIO m) => MethodInfo MessageParseResetTimeMethodInfo Message signature where+    overloadedMethod _ = messageParseResetTime++-- method Message::parse_segment_done+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_segment_done" gst_message_parse_segment_done :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- position : TBasicType TInt64+    IO ()+++messageParseSegmentDone ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Format,Int64)                     -- result+messageParseSegmentDone _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    position <- allocMem :: IO (Ptr Int64)+    gst_message_parse_segment_done _obj' format position+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    position' <- peek position+    touchManagedPtr _obj+    freeMem format+    freeMem position+    return (format'', position')++data MessageParseSegmentDoneMethodInfo+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo MessageParseSegmentDoneMethodInfo Message signature where+    overloadedMethod _ = messageParseSegmentDone++-- method Message::parse_segment_start+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_segment_start" gst_message_parse_segment_start :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- position : TBasicType TInt64+    IO ()+++messageParseSegmentStart ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Format,Int64)                     -- result+messageParseSegmentStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    position <- allocMem :: IO (Ptr Int64)+    gst_message_parse_segment_start _obj' format position+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    position' <- peek position+    touchManagedPtr _obj+    freeMem format+    freeMem position+    return (format'', position')++data MessageParseSegmentStartMethodInfo+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo MessageParseSegmentStartMethodInfo Message signature where+    overloadedMethod _ = messageParseSegmentStart++-- method Message::parse_state_changed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oldstate", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "newstate", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pending", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_state_changed" gst_message_parse_state_changed :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- oldstate : TInterface "Gst" "State"+    Ptr CUInt ->                            -- newstate : TInterface "Gst" "State"+    Ptr CUInt ->                            -- pending : TInterface "Gst" "State"+    IO ()+++messageParseStateChanged ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (State,State,State)                -- result+messageParseStateChanged _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    oldstate <- allocMem :: IO (Ptr CUInt)+    newstate <- allocMem :: IO (Ptr CUInt)+    pending <- allocMem :: IO (Ptr CUInt)+    gst_message_parse_state_changed _obj' oldstate newstate pending+    oldstate' <- peek oldstate+    let oldstate'' = (toEnum . fromIntegral) oldstate'+    newstate' <- peek newstate+    let newstate'' = (toEnum . fromIntegral) newstate'+    pending' <- peek pending+    let pending'' = (toEnum . fromIntegral) pending'+    touchManagedPtr _obj+    freeMem oldstate+    freeMem newstate+    freeMem pending+    return (oldstate'', newstate'', pending'')++data MessageParseStateChangedMethodInfo+instance (signature ~ (m (State,State,State)), MonadIO m) => MethodInfo MessageParseStateChangedMethodInfo Message signature where+    overloadedMethod _ = messageParseStateChanged++-- method Message::parse_step_done+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "eos", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_step_done" gst_message_parse_step_done :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Word64 ->                           -- amount : TBasicType TUInt64+    Ptr CDouble ->                          -- rate : TBasicType TDouble+    Ptr CInt ->                             -- flush : TBasicType TBoolean+    Ptr CInt ->                             -- intermediate : TBasicType TBoolean+    Ptr Word64 ->                           -- duration : TBasicType TUInt64+    Ptr CInt ->                             -- eos : TBasicType TBoolean+    IO ()+++messageParseStepDone ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Format,Word64,Double,Bool,Bool,Word64,Bool)-- result+messageParseStepDone _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    amount <- allocMem :: IO (Ptr Word64)+    rate <- allocMem :: IO (Ptr CDouble)+    flush <- allocMem :: IO (Ptr CInt)+    intermediate <- allocMem :: IO (Ptr CInt)+    duration <- allocMem :: IO (Ptr Word64)+    eos <- allocMem :: IO (Ptr CInt)+    gst_message_parse_step_done _obj' format amount rate flush intermediate duration eos+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    amount' <- peek amount+    rate' <- peek rate+    let rate'' = realToFrac rate'+    flush' <- peek flush+    let flush'' = (/= 0) flush'+    intermediate' <- peek intermediate+    let intermediate'' = (/= 0) intermediate'+    duration' <- peek duration+    eos' <- peek eos+    let eos'' = (/= 0) eos'+    touchManagedPtr _obj+    freeMem format+    freeMem amount+    freeMem rate+    freeMem flush+    freeMem intermediate+    freeMem duration+    freeMem eos+    return (format'', amount', rate'', flush'', intermediate'', duration', eos'')++data MessageParseStepDoneMethodInfo+instance (signature ~ (m (Format,Word64,Double,Bool,Bool,Word64,Bool)), MonadIO m) => MethodInfo MessageParseStepDoneMethodInfo Message signature where+    overloadedMethod _ = messageParseStepDone++-- method Message::parse_step_start+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_step_start" gst_message_parse_step_start :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CInt ->                             -- active : TBasicType TBoolean+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Word64 ->                           -- amount : TBasicType TUInt64+    Ptr CDouble ->                          -- rate : TBasicType TDouble+    Ptr CInt ->                             -- flush : TBasicType TBoolean+    Ptr CInt ->                             -- intermediate : TBasicType TBoolean+    IO ()+++messageParseStepStart ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Bool,Format,Word64,Double,Bool,Bool)-- result+messageParseStepStart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    active <- allocMem :: IO (Ptr CInt)+    format <- allocMem :: IO (Ptr CUInt)+    amount <- allocMem :: IO (Ptr Word64)+    rate <- allocMem :: IO (Ptr CDouble)+    flush <- allocMem :: IO (Ptr CInt)+    intermediate <- allocMem :: IO (Ptr CInt)+    gst_message_parse_step_start _obj' active format amount rate flush intermediate+    active' <- peek active+    let active'' = (/= 0) active'+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    amount' <- peek amount+    rate' <- peek rate+    let rate'' = realToFrac rate'+    flush' <- peek flush+    let flush'' = (/= 0) flush'+    intermediate' <- peek intermediate+    let intermediate'' = (/= 0) intermediate'+    touchManagedPtr _obj+    freeMem active+    freeMem format+    freeMem amount+    freeMem rate+    freeMem flush+    freeMem intermediate+    return (active'', format'', amount', rate'', flush'', intermediate'')++data MessageParseStepStartMethodInfo+instance (signature ~ (m (Bool,Format,Word64,Double,Bool,Bool)), MonadIO m) => MethodInfo MessageParseStepStartMethodInfo Message signature where+    overloadedMethod _ = messageParseStepStart++-- method Message::parse_stream_status+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StreamStatusType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_stream_status" gst_message_parse_stream_status :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- type : TInterface "Gst" "StreamStatusType"+    Ptr (Ptr Element) ->                    -- owner : TInterface "Gst" "Element"+    IO ()+++messageParseStreamStatus ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (StreamStatusType,Element)         -- result+messageParseStreamStatus _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    type_ <- allocMem :: IO (Ptr CUInt)+    owner <- allocMem :: IO (Ptr (Ptr Element))+    gst_message_parse_stream_status _obj' type_ owner+    type_' <- peek type_+    let type_'' = (toEnum . fromIntegral) type_'+    owner' <- peek owner+    owner'' <- (newObject Element) owner'+    touchManagedPtr _obj+    freeMem type_+    freeMem owner+    return (type_'', owner'')++data MessageParseStreamStatusMethodInfo+instance (signature ~ (m (StreamStatusType,Element)), MonadIO m) => MethodInfo MessageParseStreamStatusMethodInfo Message signature where+    overloadedMethod _ = messageParseStreamStatus++-- method Message::parse_structure_change+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StructureChangeType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_structure_change" gst_message_parse_structure_change :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr CUInt ->                            -- type : TInterface "Gst" "StructureChangeType"+    Ptr (Ptr Element) ->                    -- owner : TInterface "Gst" "Element"+    Ptr CInt ->                             -- busy : TBasicType TBoolean+    IO ()+++messageParseStructureChange ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (StructureChangeType,Element,Bool) -- result+messageParseStructureChange _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    type_ <- allocMem :: IO (Ptr CUInt)+    owner <- allocMem :: IO (Ptr (Ptr Element))+    busy <- allocMem :: IO (Ptr CInt)+    gst_message_parse_structure_change _obj' type_ owner busy+    type_' <- peek type_+    let type_'' = (toEnum . fromIntegral) type_'+    owner' <- peek owner+    owner'' <- (newObject Element) owner'+    busy' <- peek busy+    let busy'' = (/= 0) busy'+    touchManagedPtr _obj+    freeMem type_+    freeMem owner+    freeMem busy+    return (type_'', owner'', busy'')++data MessageParseStructureChangeMethodInfo+instance (signature ~ (m (StructureChangeType,Element,Bool)), MonadIO m) => MethodInfo MessageParseStructureChangeMethodInfo Message signature where+    overloadedMethod _ = messageParseStructureChange++-- method Message::parse_tag+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_list", argType = TInterface "Gst" "TagList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_tag" gst_message_parse_tag :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr TagList ->                          -- tag_list : TInterface "Gst" "TagList"+    IO ()+++messageParseTag ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (TagList)                          -- result+messageParseTag _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tagList <- callocBoxedBytes 64 :: IO (Ptr TagList)+    gst_message_parse_tag _obj' tagList+    tagList' <- (wrapBoxed TagList) tagList+    touchManagedPtr _obj+    return tagList'++data MessageParseTagMethodInfo+instance (signature ~ (m (TagList)), MonadIO m) => MethodInfo MessageParseTagMethodInfo Message signature where+    overloadedMethod _ = messageParseTag++-- method Message::parse_toc+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_toc" gst_message_parse_toc :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr (Ptr Toc) ->                        -- toc : TInterface "Gst" "Toc"+    Ptr CInt ->                             -- updated : TBasicType TBoolean+    IO ()+++messageParseToc ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (Toc,Bool)                         -- result+messageParseToc _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    toc <- allocMem :: IO (Ptr (Ptr Toc))+    updated <- allocMem :: IO (Ptr CInt)+    gst_message_parse_toc _obj' toc updated+    toc' <- peek toc+    toc'' <- (wrapBoxed Toc) toc'+    updated' <- peek updated+    let updated'' = (/= 0) updated'+    touchManagedPtr _obj+    freeMem toc+    freeMem updated+    return (toc'', updated'')++data MessageParseTocMethodInfo+instance (signature ~ (m (Toc,Bool)), MonadIO m) => MethodInfo MessageParseTocMethodInfo Message signature where+    overloadedMethod _ = messageParseToc++-- method Message::parse_warning+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gerror", argType = TError, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_parse_warning" gst_message_parse_warning :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr GError ->                           -- gerror : TError+    Ptr CString ->                          -- debug : TBasicType TUTF8+    IO ()+++messageParseWarning ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> m (GError,T.Text)                    -- result+messageParseWarning _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gerror <- callocBoxedBytes 16 :: IO (Ptr GError)+    debug <- allocMem :: IO (Ptr CString)+    gst_message_parse_warning _obj' gerror debug+    gerror' <- (wrapBoxed GError) gerror+    debug' <- peek debug+    debug'' <- cstringToText debug'+    freeMem debug'+    touchManagedPtr _obj+    freeMem debug+    return (gerror', debug'')++data MessageParseWarningMethodInfo+instance (signature ~ (m (GError,T.Text)), MonadIO m) => MethodInfo MessageParseWarningMethodInfo Message signature where+    overloadedMethod _ = messageParseWarning++-- method Message::set_buffering_stats+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_set_buffering_stats" gst_message_set_buffering_stats :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    CUInt ->                                -- mode : TInterface "Gst" "BufferingMode"+    Int32 ->                                -- avg_in : TBasicType TInt32+    Int32 ->                                -- avg_out : TBasicType TInt32+    Int64 ->                                -- buffering_left : TBasicType TInt64+    IO ()+++messageSetBufferingStats ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> BufferingMode                        -- mode+    -> Int32                                -- avgIn+    -> Int32                                -- avgOut+    -> Int64                                -- bufferingLeft+    -> m ()                                 -- result+messageSetBufferingStats _obj mode avgIn avgOut bufferingLeft = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gst_message_set_buffering_stats _obj' mode' avgIn avgOut bufferingLeft+    touchManagedPtr _obj+    return ()++data MessageSetBufferingStatsMethodInfo+instance (signature ~ (BufferingMode -> Int32 -> Int32 -> Int64 -> m ()), MonadIO m) => MethodInfo MessageSetBufferingStatsMethodInfo Message signature where+    overloadedMethod _ = messageSetBufferingStats++-- method Message::set_group_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_set_group_id" gst_message_set_group_id :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Word32 ->                               -- group_id : TBasicType TUInt32+    IO ()+++messageSetGroupId ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> Word32                               -- groupId+    -> m ()                                 -- result+messageSetGroupId _obj groupId = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_message_set_group_id _obj' groupId+    touchManagedPtr _obj+    return ()++data MessageSetGroupIdMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MessageSetGroupIdMethodInfo Message signature where+    overloadedMethod _ = messageSetGroupId++-- method Message::set_qos_stats+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "processed", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dropped", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_set_qos_stats" gst_message_set_qos_stats :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- processed : TBasicType TUInt64+    Word64 ->                               -- dropped : TBasicType TUInt64+    IO ()+++messageSetQosStats ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> Format                               -- format+    -> Word64                               -- processed+    -> Word64                               -- dropped+    -> m ()                                 -- result+messageSetQosStats _obj format processed dropped = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_message_set_qos_stats _obj' format' processed dropped+    touchManagedPtr _obj+    return ()++data MessageSetQosStatsMethodInfo+instance (signature ~ (Format -> Word64 -> Word64 -> m ()), MonadIO m) => MethodInfo MessageSetQosStatsMethodInfo Message signature where+    overloadedMethod _ = messageSetQosStats++-- method Message::set_qos_values+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quality", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_set_qos_values" gst_message_set_qos_values :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Int64 ->                                -- jitter : TBasicType TInt64+    CDouble ->                              -- proportion : TBasicType TDouble+    Int32 ->                                -- quality : TBasicType TInt32+    IO ()+++messageSetQosValues ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> Int64                                -- jitter+    -> Double                               -- proportion+    -> Int32                                -- quality+    -> m ()                                 -- result+messageSetQosValues _obj jitter proportion quality = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let proportion' = realToFrac proportion+    gst_message_set_qos_values _obj' jitter proportion' quality+    touchManagedPtr _obj+    return ()++data MessageSetQosValuesMethodInfo+instance (signature ~ (Int64 -> Double -> Int32 -> m ()), MonadIO m) => MethodInfo MessageSetQosValuesMethodInfo Message signature where+    overloadedMethod _ = messageSetQosValues++-- method Message::set_seqnum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seqnum", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_set_seqnum" gst_message_set_seqnum :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Word32 ->                               -- seqnum : TBasicType TUInt32+    IO ()+++messageSetSeqnum ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> Word32                               -- seqnum+    -> m ()                                 -- result+messageSetSeqnum _obj seqnum = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_message_set_seqnum _obj' seqnum+    touchManagedPtr _obj+    return ()++data MessageSetSeqnumMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MessageSetSeqnumMethodInfo Message signature where+    overloadedMethod _ = messageSetSeqnum++-- method Message::set_stream_status_object+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_message_set_stream_status_object" gst_message_set_stream_status_object :: +    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"+    Ptr GValue ->                           -- object : TInterface "GObject" "Value"+    IO ()+++messageSetStreamStatusObject ::+    (MonadIO m) =>+    Message                                 -- _obj+    -> GValue                               -- object+    -> m ()                                 -- result+messageSetStreamStatusObject _obj object = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let object' = unsafeManagedPtrGetPtr object+    gst_message_set_stream_status_object _obj' object'+    touchManagedPtr _obj+    touchManagedPtr object+    return ()++data MessageSetStreamStatusObjectMethodInfo+instance (signature ~ (GValue -> m ()), MonadIO m) => MethodInfo MessageSetStreamStatusObjectMethodInfo Message signature where+    overloadedMethod _ = messageSetStreamStatusObject++type family ResolveMessageMethod (t :: Symbol) (o :: *) :: * where+    ResolveMessageMethod "hasName" o = MessageHasNameMethodInfo+    ResolveMessageMethod "parseAsyncDone" o = MessageParseAsyncDoneMethodInfo+    ResolveMessageMethod "parseBuffering" o = MessageParseBufferingMethodInfo+    ResolveMessageMethod "parseBufferingStats" o = MessageParseBufferingStatsMethodInfo+    ResolveMessageMethod "parseClockLost" o = MessageParseClockLostMethodInfo+    ResolveMessageMethod "parseClockProvide" o = MessageParseClockProvideMethodInfo+    ResolveMessageMethod "parseContextType" o = MessageParseContextTypeMethodInfo+    ResolveMessageMethod "parseDeviceAdded" o = MessageParseDeviceAddedMethodInfo+    ResolveMessageMethod "parseDeviceRemoved" o = MessageParseDeviceRemovedMethodInfo+    ResolveMessageMethod "parseError" o = MessageParseErrorMethodInfo+    ResolveMessageMethod "parseGroupId" o = MessageParseGroupIdMethodInfo+    ResolveMessageMethod "parseHaveContext" o = MessageParseHaveContextMethodInfo+    ResolveMessageMethod "parseInfo" o = MessageParseInfoMethodInfo+    ResolveMessageMethod "parseNewClock" o = MessageParseNewClockMethodInfo+    ResolveMessageMethod "parseProgress" o = MessageParseProgressMethodInfo+    ResolveMessageMethod "parseQos" o = MessageParseQosMethodInfo+    ResolveMessageMethod "parseQosStats" o = MessageParseQosStatsMethodInfo+    ResolveMessageMethod "parseQosValues" o = MessageParseQosValuesMethodInfo+    ResolveMessageMethod "parseRequestState" o = MessageParseRequestStateMethodInfo+    ResolveMessageMethod "parseResetTime" o = MessageParseResetTimeMethodInfo+    ResolveMessageMethod "parseSegmentDone" o = MessageParseSegmentDoneMethodInfo+    ResolveMessageMethod "parseSegmentStart" o = MessageParseSegmentStartMethodInfo+    ResolveMessageMethod "parseStateChanged" o = MessageParseStateChangedMethodInfo+    ResolveMessageMethod "parseStepDone" o = MessageParseStepDoneMethodInfo+    ResolveMessageMethod "parseStepStart" o = MessageParseStepStartMethodInfo+    ResolveMessageMethod "parseStreamStatus" o = MessageParseStreamStatusMethodInfo+    ResolveMessageMethod "parseStructureChange" o = MessageParseStructureChangeMethodInfo+    ResolveMessageMethod "parseTag" o = MessageParseTagMethodInfo+    ResolveMessageMethod "parseToc" o = MessageParseTocMethodInfo+    ResolveMessageMethod "parseWarning" o = MessageParseWarningMethodInfo+    ResolveMessageMethod "getSeqnum" o = MessageGetSeqnumMethodInfo+    ResolveMessageMethod "getStreamStatusObject" o = MessageGetStreamStatusObjectMethodInfo+    ResolveMessageMethod "getStructure" o = MessageGetStructureMethodInfo+    ResolveMessageMethod "setBufferingStats" o = MessageSetBufferingStatsMethodInfo+    ResolveMessageMethod "setGroupId" o = MessageSetGroupIdMethodInfo+    ResolveMessageMethod "setQosStats" o = MessageSetQosStatsMethodInfo+    ResolveMessageMethod "setQosValues" o = MessageSetQosValuesMethodInfo+    ResolveMessageMethod "setSeqnum" o = MessageSetSeqnumMethodInfo+    ResolveMessageMethod "setStreamStatusObject" o = MessageSetStreamStatusObjectMethodInfo+    ResolveMessageMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveMessageMethod t Message, MethodInfo info Message p) => IsLabelProxy t (Message -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveMessageMethod t Message, MethodInfo info Message p) => IsLabel t (Message -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Message.hs-boot view
@@ -0,0 +1,50 @@+module GI.Gst.Structs.Message 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++newtype Message = Message (ForeignPtr Message)+instance BoxedObject Message where+data MessageGetSeqnumMethodInfo+data MessageGetStreamStatusObjectMethodInfo+data MessageGetStructureMethodInfo+data MessageHasNameMethodInfo+data MessageParseAsyncDoneMethodInfo+data MessageParseBufferingMethodInfo+data MessageParseBufferingStatsMethodInfo+data MessageParseClockLostMethodInfo+data MessageParseClockProvideMethodInfo+data MessageParseContextTypeMethodInfo+data MessageParseDeviceAddedMethodInfo+data MessageParseDeviceRemovedMethodInfo+data MessageParseErrorMethodInfo+data MessageParseGroupIdMethodInfo+data MessageParseHaveContextMethodInfo+data MessageParseInfoMethodInfo+data MessageParseNewClockMethodInfo+data MessageParseProgressMethodInfo+data MessageParseQosMethodInfo+data MessageParseQosStatsMethodInfo+data MessageParseQosValuesMethodInfo+data MessageParseRequestStateMethodInfo+data MessageParseResetTimeMethodInfo+data MessageParseSegmentDoneMethodInfo+data MessageParseSegmentStartMethodInfo+data MessageParseStateChangedMethodInfo+data MessageParseStepDoneMethodInfo+data MessageParseStepStartMethodInfo+data MessageParseStreamStatusMethodInfo+data MessageParseStructureChangeMethodInfo+data MessageParseTagMethodInfo+data MessageParseTocMethodInfo+data MessageParseWarningMethodInfo+data MessageSetBufferingStatsMethodInfo+data MessageSetGroupIdMethodInfo+data MessageSetQosStatsMethodInfo+data MessageSetQosValuesMethodInfo+data MessageSetSeqnumMethodInfo+data MessageSetStreamStatusObjectMethodInfo
+ GI/Gst/Structs/Meta.hs view
@@ -0,0 +1,262 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The #GstMeta structure should be included as the first member of a #GstBuffer+metadata structure. The structure defines the API of the metadata and should+be accessible to all elements using the metadata.++A metadata API is registered with gst_meta_api_type_register() which takes a+name for the metadata API and some tags associated with the metadata.+With gst_meta_api_type_has_tag() one can check if a certain metadata API+contains a given tag.++Multiple implementations of a metadata API can be registered.+To implement a metadata API, gst_meta_register() should be used. This+function takes all parameters needed to create, free and transform metadata+along with the size of the metadata. The function returns a #GstMetaInfo+structure that contains the information for the implementation of the API.++A specific implementation can be retrieved by name with gst_meta_get_info().++See #GstBuffer for how the metadata can be added, retrieved and removed from+buffers.+-}++module GI.Gst.Structs.Meta+    ( ++-- * Exported types+    Meta(..)                                ,+    newZeroMeta                             ,+    noMeta                                  ,+++ -- * Methods+-- ** metaApiTypeGetTags+    metaApiTypeGetTags                      ,+++-- ** metaApiTypeHasTag+    metaApiTypeHasTag                       ,+++-- ** metaApiTypeRegister+    metaApiTypeRegister                     ,+++-- ** metaGetInfo+    metaGetInfo                             ,+++-- ** metaRegister+    metaRegister                            ,+++++ -- * Properties+-- ** Flags+    metaReadFlags                           ,+++-- ** Info+    metaReadInfo                            ,+++++    ) 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 GI.Gst.Callbacks++newtype Meta = Meta (ForeignPtr Meta)+-- | Construct a `Meta` struct initialized to zero.+newZeroMeta :: MonadIO m => m Meta+newZeroMeta = liftIO $ callocBytes 16 >>= wrapPtr Meta++noMeta :: Maybe Meta+noMeta = Nothing++metaReadFlags :: Meta -> IO [MetaFlags]+metaReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = wordToGFlags val+    return val'++metaReadInfo :: Meta -> IO MetaInfo+metaReadInfo s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr MetaInfo)+    val' <- (newPtr 80 MetaInfo) val+    return val'++-- method Meta::api_type_get_tags+-- method type : MemberFunction+-- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_meta_api_type_get_tags" gst_meta_api_type_get_tags :: +    CGType ->                               -- api : TBasicType TGType+    IO (Ptr CString)+++metaApiTypeGetTags ::+    (MonadIO m) =>+    GType                                   -- api+    -> m [T.Text]                           -- result+metaApiTypeGetTags api = liftIO $ do+    let api' = gtypeToCGType api+    result <- gst_meta_api_type_get_tags api'+    checkUnexpectedReturnNULL "gst_meta_api_type_get_tags" result+    result' <- unpackZeroTerminatedUTF8CArray result+    return result'++-- method Meta::api_type_has_tag+-- method type : MemberFunction+-- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_meta_api_type_has_tag" gst_meta_api_type_has_tag :: +    CGType ->                               -- api : TBasicType TGType+    Word32 ->                               -- tag : TBasicType TUInt32+    IO CInt+++metaApiTypeHasTag ::+    (MonadIO m) =>+    GType                                   -- api+    -> Word32                               -- tag+    -> m Bool                               -- result+metaApiTypeHasTag api tag = liftIO $ do+    let api' = gtypeToCGType api+    result <- gst_meta_api_type_has_tag api' tag+    let result' = (/= 0) result+    return result'++-- method Meta::api_type_register+-- method type : MemberFunction+-- Args : [Arg {argCName = "api", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_meta_api_type_register" gst_meta_api_type_register :: +    CString ->                              -- api : TBasicType TUTF8+    CString ->                              -- tags : TBasicType TUTF8+    IO CGType+++metaApiTypeRegister ::+    (MonadIO m) =>+    T.Text                                  -- api+    -> T.Text                               -- tags+    -> m GType                              -- result+metaApiTypeRegister api tags = liftIO $ do+    api' <- textToCString api+    tags' <- textToCString tags+    result <- gst_meta_api_type_register api' tags'+    let result' = GType result+    freeMem api'+    freeMem tags'+    return result'++-- method Meta::get_info+-- method type : MemberFunction+-- Args : [Arg {argCName = "impl", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_meta_get_info" gst_meta_get_info :: +    CString ->                              -- impl : TBasicType TUTF8+    IO (Ptr MetaInfo)+++metaGetInfo ::+    (MonadIO m) =>+    T.Text                                  -- impl+    -> m MetaInfo                           -- result+metaGetInfo impl = liftIO $ do+    impl' <- textToCString impl+    result <- gst_meta_get_info impl'+    checkUnexpectedReturnNULL "gst_meta_get_info" result+    result' <- (newPtr 80 MetaInfo) result+    freeMem impl'+    return result'++-- method Meta::register+-- method type : MemberFunction+-- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "impl", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init_func", argType = TInterface "Gst" "MetaInitFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "free_func", argType = TInterface "Gst" "MetaFreeFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "transform_func", argType = TInterface "Gst" "MetaTransformFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_meta_register" gst_meta_register :: +    CGType ->                               -- api : TBasicType TGType+    CString ->                              -- impl : TBasicType TUTF8+    Word64 ->                               -- size : TBasicType TUInt64+    FunPtr MetaInitFunctionC ->             -- init_func : TInterface "Gst" "MetaInitFunction"+    FunPtr MetaFreeFunctionC ->             -- free_func : TInterface "Gst" "MetaFreeFunction"+    FunPtr MetaTransformFunctionC ->        -- transform_func : TInterface "Gst" "MetaTransformFunction"+    IO (Ptr MetaInfo)+++metaRegister ::+    (MonadIO m) =>+    GType                                   -- api+    -> T.Text                               -- impl+    -> Word64                               -- size+    -> MetaInitFunction                     -- initFunc+    -> MetaFreeFunction                     -- freeFunc+    -> MetaTransformFunction                -- transformFunc+    -> m MetaInfo                           -- result+metaRegister api impl size initFunc freeFunc transformFunc = liftIO $ do+    let api' = gtypeToCGType api+    impl' <- textToCString impl+    ptrinitFunc <- callocMem :: IO (Ptr (FunPtr MetaInitFunctionC))+    initFunc' <- mkMetaInitFunction (metaInitFunctionWrapper (Just ptrinitFunc) initFunc)+    poke ptrinitFunc initFunc'+    ptrfreeFunc <- callocMem :: IO (Ptr (FunPtr MetaFreeFunctionC))+    freeFunc' <- mkMetaFreeFunction (metaFreeFunctionWrapper (Just ptrfreeFunc) freeFunc)+    poke ptrfreeFunc freeFunc'+    ptrtransformFunc <- callocMem :: IO (Ptr (FunPtr MetaTransformFunctionC))+    transformFunc' <- mkMetaTransformFunction (metaTransformFunctionWrapper (Just ptrtransformFunc) transformFunc)+    poke ptrtransformFunc transformFunc'+    result <- gst_meta_register api' impl' size initFunc' freeFunc' transformFunc'+    checkUnexpectedReturnNULL "gst_meta_register" result+    result' <- (newPtr 80 MetaInfo) result+    freeMem impl'+    return result'++type family ResolveMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveMetaMethod t Meta, MethodInfo info Meta p) => IsLabelProxy t (Meta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveMetaMethod t Meta, MethodInfo info Meta p) => IsLabel t (Meta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Meta.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.Meta 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++newtype Meta = Meta (ForeignPtr Meta)
+ GI/Gst/Structs/MetaInfo.hs view
@@ -0,0 +1,90 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The #GstMetaInfo provides information about a specific metadata+structure.+-}++module GI.Gst.Structs.MetaInfo+    ( ++-- * Exported types+    MetaInfo(..)                            ,+    newZeroMetaInfo                         ,+    noMetaInfo                              ,+++ -- * Properties+-- ** Api+    metaInfoReadApi                         ,+++-- ** Size+    metaInfoReadSize                        ,+++-- ** Type+    metaInfoReadType                        ,+++++    ) 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 GI.Gst.Callbacks++newtype MetaInfo = MetaInfo (ForeignPtr MetaInfo)+-- | Construct a `MetaInfo` struct initialized to zero.+newZeroMetaInfo :: MonadIO m => m MetaInfo+newZeroMetaInfo = liftIO $ callocBytes 80 >>= wrapPtr MetaInfo++noMetaInfo :: Maybe MetaInfo+noMetaInfo = Nothing++metaInfoReadApi :: MetaInfo -> IO GType+metaInfoReadApi s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CGType+    let val' = GType val+    return val'++metaInfoReadType :: MetaInfo -> IO GType+metaInfoReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CGType+    let val' = GType val+    return val'++metaInfoReadSize :: MetaInfo -> IO Word64+metaInfoReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word64+    return val++-- XXX Skipped getter for "MetaInfo:init_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "MetaInfo:free_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "MetaInfo:transform_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++type family ResolveMetaInfoMethod (t :: Symbol) (o :: *) :: * where+    ResolveMetaInfoMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveMetaInfoMethod t MetaInfo, MethodInfo info MetaInfo p) => IsLabelProxy t (MetaInfo -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveMetaInfoMethod t MetaInfo, MethodInfo info MetaInfo p) => IsLabel t (MetaInfo -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/MetaInfo.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.MetaInfo 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++newtype MetaInfo = MetaInfo (ForeignPtr MetaInfo)
+ GI/Gst/Structs/MetaTransformCopy.hs view
@@ -0,0 +1,82 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Extra data passed to a "gst-copy" transform #GstMetaTransformFunction.+-}++module GI.Gst.Structs.MetaTransformCopy+    ( ++-- * Exported types+    MetaTransformCopy(..)                   ,+    newZeroMetaTransformCopy                ,+    noMetaTransformCopy                     ,+++ -- * Properties+-- ** Offset+    metaTransformCopyReadOffset             ,+++-- ** Region+    metaTransformCopyReadRegion             ,+++-- ** Size+    metaTransformCopyReadSize               ,+++++    ) 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 GI.Gst.Callbacks++newtype MetaTransformCopy = MetaTransformCopy (ForeignPtr MetaTransformCopy)+-- | Construct a `MetaTransformCopy` struct initialized to zero.+newZeroMetaTransformCopy :: MonadIO m => m MetaTransformCopy+newZeroMetaTransformCopy = liftIO $ callocBytes 24 >>= wrapPtr MetaTransformCopy++noMetaTransformCopy :: Maybe MetaTransformCopy+noMetaTransformCopy = Nothing++metaTransformCopyReadRegion :: MetaTransformCopy -> IO Bool+metaTransformCopyReadRegion s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CInt+    let val' = (/= 0) val+    return val'++metaTransformCopyReadOffset :: MetaTransformCopy -> IO Word64+metaTransformCopyReadOffset s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word64+    return val++metaTransformCopyReadSize :: MetaTransformCopy -> IO Word64+metaTransformCopyReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word64+    return val++type family ResolveMetaTransformCopyMethod (t :: Symbol) (o :: *) :: * where+    ResolveMetaTransformCopyMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveMetaTransformCopyMethod t MetaTransformCopy, MethodInfo info MetaTransformCopy p) => IsLabelProxy t (MetaTransformCopy -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveMetaTransformCopyMethod t MetaTransformCopy, MethodInfo info MetaTransformCopy p) => IsLabel t (MetaTransformCopy -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/MetaTransformCopy.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.MetaTransformCopy 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++newtype MetaTransformCopy = MetaTransformCopy (ForeignPtr MetaTransformCopy)
+ GI/Gst/Structs/MiniObject.hs view
@@ -0,0 +1,379 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GstMiniObject is a simple structure that can be used to implement refcounted+types.++Subclasses will include #GstMiniObject as the first member in their structure+and then call gst_mini_object_init() to initialize the #GstMiniObject fields.++gst_mini_object_ref() and gst_mini_object_unref() increment and decrement the+refcount respectively. When the refcount of a mini-object reaches 0, the+dispose function is called first and when this returns %TRUE, the free+function of the miniobject is called.++A copy can be made with gst_mini_object_copy().++gst_mini_object_is_writable() will return %TRUE when the refcount of the+object is exactly 1, meaning the current caller has the only reference to the+object. gst_mini_object_make_writable() will return a writable version of the+object, which might be a new copy when the refcount was not 1.++Opaque data can be associated with a #GstMiniObject with+gst_mini_object_set_qdata() and gst_mini_object_get_qdata(). The data is+meant to be specific to the particular object and is not automatically copied+with gst_mini_object_copy() or similar methods.++A weak reference can be added and remove with gst_mini_object_weak_ref()+and gst_mini_object_weak_unref() respectively.+-}++module GI.Gst.Structs.MiniObject+    ( ++-- * Exported types+    MiniObject(..)                          ,+    newZeroMiniObject                       ,+    noMiniObject                            ,+++ -- * Methods+-- ** miniObjectGetQdata+    MiniObjectGetQdataMethodInfo            ,+    miniObjectGetQdata                      ,+++-- ** miniObjectIsWritable+    MiniObjectIsWritableMethodInfo          ,+    miniObjectIsWritable                    ,+++-- ** miniObjectLock+    MiniObjectLockMethodInfo                ,+    miniObjectLock                          ,+++-- ** miniObjectSetQdata+    MiniObjectSetQdataMethodInfo            ,+    miniObjectSetQdata                      ,+++-- ** miniObjectStealQdata+    MiniObjectStealQdataMethodInfo          ,+    miniObjectStealQdata                    ,+++-- ** miniObjectTake+    miniObjectTake                          ,+++-- ** miniObjectUnlock+    MiniObjectUnlockMethodInfo              ,+    miniObjectUnlock                        ,+++++ -- * Properties+-- ** Flags+    miniObjectReadFlags                     ,+++-- ** Lockstate+    miniObjectReadLockstate                 ,+++-- ** Refcount+    miniObjectReadRefcount                  ,+++-- ** Type+    miniObjectReadType                      ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype MiniObject = MiniObject (ForeignPtr MiniObject)+-- | Construct a `MiniObject` struct initialized to zero.+newZeroMiniObject :: MonadIO m => m MiniObject+newZeroMiniObject = liftIO $ callocBytes 64 >>= wrapPtr MiniObject++noMiniObject :: Maybe MiniObject+noMiniObject = Nothing++miniObjectReadType :: MiniObject -> IO GType+miniObjectReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CGType+    let val' = GType val+    return val'++miniObjectReadRefcount :: MiniObject -> IO Int32+miniObjectReadRefcount s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Int32+    return val++miniObjectReadLockstate :: MiniObject -> IO Int32+miniObjectReadLockstate s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO Int32+    return val++miniObjectReadFlags :: MiniObject -> IO Word32+miniObjectReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO Word32+    return val++-- XXX Skipped getter for "MiniObject:dispose" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "MiniObject:free" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- method MiniObject::get_qdata+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_mini_object_get_qdata" gst_mini_object_get_qdata :: +    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"+    Word32 ->                               -- quark : TBasicType TUInt32+    IO ()+++miniObjectGetQdata ::+    (MonadIO m) =>+    MiniObject                              -- _obj+    -> Word32                               -- quark+    -> m ()                                 -- result+miniObjectGetQdata _obj quark = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_mini_object_get_qdata _obj' quark+    touchManagedPtr _obj+    return ()++data MiniObjectGetQdataMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MiniObjectGetQdataMethodInfo MiniObject signature where+    overloadedMethod _ = miniObjectGetQdata++-- method MiniObject::is_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_mini_object_is_writable" gst_mini_object_is_writable :: +    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"+    IO CInt+++miniObjectIsWritable ::+    (MonadIO m) =>+    MiniObject                              -- _obj+    -> m Bool                               -- result+miniObjectIsWritable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_mini_object_is_writable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data MiniObjectIsWritableMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo MiniObjectIsWritableMethodInfo MiniObject signature where+    overloadedMethod _ = miniObjectIsWritable++-- method MiniObject::lock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "LockFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_mini_object_lock" gst_mini_object_lock :: +    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"+    CUInt ->                                -- flags : TInterface "Gst" "LockFlags"+    IO CInt+++miniObjectLock ::+    (MonadIO m) =>+    MiniObject                              -- _obj+    -> [LockFlags]                          -- flags+    -> m Bool                               -- result+miniObjectLock _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = gflagsToWord flags+    result <- gst_mini_object_lock _obj' flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data MiniObjectLockMethodInfo+instance (signature ~ ([LockFlags] -> m Bool), MonadIO m) => MethodInfo MiniObjectLockMethodInfo MiniObject signature where+    overloadedMethod _ = miniObjectLock++-- method MiniObject::set_qdata+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_mini_object_set_qdata" gst_mini_object_set_qdata :: +    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"+    Word32 ->                               -- quark : TBasicType TUInt32+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"+    IO ()+++miniObjectSetQdata ::+    (MonadIO m) =>+    MiniObject                              -- _obj+    -> Word32                               -- quark+    -> Ptr ()                               -- data_+    -> GLib.DestroyNotify                   -- destroy+    -> m ()                                 -- result+miniObjectSetQdata _obj quark data_ destroy = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))+    destroy' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrdestroy) destroy)+    poke ptrdestroy destroy'+    gst_mini_object_set_qdata _obj' quark data_ destroy'+    touchManagedPtr _obj+    return ()++data MiniObjectSetQdataMethodInfo+instance (signature ~ (Word32 -> Ptr () -> GLib.DestroyNotify -> m ()), MonadIO m) => MethodInfo MiniObjectSetQdataMethodInfo MiniObject signature where+    overloadedMethod _ = miniObjectSetQdata++-- method MiniObject::steal_qdata+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_mini_object_steal_qdata" gst_mini_object_steal_qdata :: +    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"+    Word32 ->                               -- quark : TBasicType TUInt32+    IO ()+++miniObjectStealQdata ::+    (MonadIO m) =>+    MiniObject                              -- _obj+    -> Word32                               -- quark+    -> m ()                                 -- result+miniObjectStealQdata _obj quark = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_mini_object_steal_qdata _obj' quark+    touchManagedPtr _obj+    return ()++data MiniObjectStealQdataMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MiniObjectStealQdataMethodInfo MiniObject signature where+    overloadedMethod _ = miniObjectStealQdata++-- method MiniObject::unlock+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "LockFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_mini_object_unlock" gst_mini_object_unlock :: +    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"+    CUInt ->                                -- flags : TInterface "Gst" "LockFlags"+    IO ()+++miniObjectUnlock ::+    (MonadIO m) =>+    MiniObject                              -- _obj+    -> [LockFlags]                          -- flags+    -> m ()                                 -- result+miniObjectUnlock _obj flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = gflagsToWord flags+    gst_mini_object_unlock _obj' flags'+    touchManagedPtr _obj+    return ()++data MiniObjectUnlockMethodInfo+instance (signature ~ ([LockFlags] -> m ()), MonadIO m) => MethodInfo MiniObjectUnlockMethodInfo MiniObject signature where+    overloadedMethod _ = miniObjectUnlock++-- XXX Could not generate method MiniObject::replace+-- Error was : Not implemented: "Nullable inout structs not supported"+-- method MiniObject::take+-- method type : MemberFunction+-- Args : [Arg {argCName = "olddata", argType = TInterface "Gst" "MiniObject", direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "newdata", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_mini_object_take" gst_mini_object_take :: +    Ptr MiniObject ->                       -- olddata : TInterface "Gst" "MiniObject"+    Ptr MiniObject ->                       -- newdata : TInterface "Gst" "MiniObject"+    IO CInt+++miniObjectTake ::+    (MonadIO m) =>+    MiniObject                              -- olddata+    -> MiniObject                           -- newdata+    -> m (Bool,MiniObject)                  -- result+miniObjectTake olddata newdata = liftIO $ do+    let olddata' = unsafeManagedPtrGetPtr olddata+    olddata'' <- callocBytes 64 :: IO (Ptr MiniObject)+    memcpy olddata'' olddata' 64+    let newdata' = unsafeManagedPtrGetPtr newdata+    result <- gst_mini_object_take olddata'' newdata'+    let result' = (/= 0) result+    olddata''' <- (wrapPtr MiniObject) olddata''+    touchManagedPtr olddata+    touchManagedPtr newdata+    return (result', olddata''')++type family ResolveMiniObjectMethod (t :: Symbol) (o :: *) :: * where+    ResolveMiniObjectMethod "isWritable" o = MiniObjectIsWritableMethodInfo+    ResolveMiniObjectMethod "lock" o = MiniObjectLockMethodInfo+    ResolveMiniObjectMethod "stealQdata" o = MiniObjectStealQdataMethodInfo+    ResolveMiniObjectMethod "unlock" o = MiniObjectUnlockMethodInfo+    ResolveMiniObjectMethod "getQdata" o = MiniObjectGetQdataMethodInfo+    ResolveMiniObjectMethod "setQdata" o = MiniObjectSetQdataMethodInfo+    ResolveMiniObjectMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveMiniObjectMethod t MiniObject, MethodInfo info MiniObject p) => IsLabelProxy t (MiniObject -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveMiniObjectMethod t MiniObject, MethodInfo info MiniObject p) => IsLabel t (MiniObject -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/MiniObject.hs-boot view
@@ -0,0 +1,16 @@+module GI.Gst.Structs.MiniObject 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++newtype MiniObject = MiniObject (ForeignPtr MiniObject)+data MiniObjectGetQdataMethodInfo+data MiniObjectIsWritableMethodInfo+data MiniObjectLockMethodInfo+data MiniObjectSetQdataMethodInfo+data MiniObjectStealQdataMethodInfo+data MiniObjectUnlockMethodInfo
+ GI/Gst/Structs/PadProbeInfo.hs view
@@ -0,0 +1,243 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Info passed in the #GstPadProbeCallback.+-}++module GI.Gst.Structs.PadProbeInfo+    ( ++-- * Exported types+    PadProbeInfo(..)                        ,+    newZeroPadProbeInfo                     ,+    noPadProbeInfo                          ,+++ -- * Methods+-- ** padProbeInfoGetBuffer+    PadProbeInfoGetBufferMethodInfo         ,+    padProbeInfoGetBuffer                   ,+++-- ** padProbeInfoGetBufferList+    PadProbeInfoGetBufferListMethodInfo     ,+    padProbeInfoGetBufferList               ,+++-- ** padProbeInfoGetEvent+    PadProbeInfoGetEventMethodInfo          ,+    padProbeInfoGetEvent                    ,+++-- ** padProbeInfoGetQuery+    PadProbeInfoGetQueryMethodInfo          ,+    padProbeInfoGetQuery                    ,+++++ -- * Properties+-- ** Data+    padProbeInfoReadData                    ,+++-- ** Id+    padProbeInfoReadId                      ,+++-- ** Offset+    padProbeInfoReadOffset                  ,+++-- ** Size+    padProbeInfoReadSize                    ,+++-- ** Type+    padProbeInfoReadType                    ,+++++    ) 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 GI.Gst.Callbacks++newtype PadProbeInfo = PadProbeInfo (ForeignPtr PadProbeInfo)+-- | Construct a `PadProbeInfo` struct initialized to zero.+newZeroPadProbeInfo :: MonadIO m => m PadProbeInfo+newZeroPadProbeInfo = liftIO $ callocBytes 40 >>= wrapPtr PadProbeInfo++noPadProbeInfo :: Maybe PadProbeInfo+noPadProbeInfo = Nothing++padProbeInfoReadType :: PadProbeInfo -> IO [PadProbeType]+padProbeInfoReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = wordToGFlags val+    return val'++padProbeInfoReadId :: PadProbeInfo -> IO Word64+padProbeInfoReadId s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO Word64+    return val++padProbeInfoReadData :: PadProbeInfo -> IO (Ptr ())+padProbeInfoReadData s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr ())+    return val++padProbeInfoReadOffset :: PadProbeInfo -> IO Word64+padProbeInfoReadOffset s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO Word64+    return val++padProbeInfoReadSize :: PadProbeInfo -> IO Word32+padProbeInfoReadSize s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word32+    return val++-- method PadProbeInfo::get_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_probe_info_get_buffer" gst_pad_probe_info_get_buffer :: +    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"+    IO (Ptr Buffer)+++padProbeInfoGetBuffer ::+    (MonadIO m) =>+    PadProbeInfo                            -- _obj+    -> m Buffer                             -- result+padProbeInfoGetBuffer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_pad_probe_info_get_buffer _obj'+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_buffer" result+    result' <- (newBoxed Buffer) result+    touchManagedPtr _obj+    return result'++data PadProbeInfoGetBufferMethodInfo+instance (signature ~ (m Buffer), MonadIO m) => MethodInfo PadProbeInfoGetBufferMethodInfo PadProbeInfo signature where+    overloadedMethod _ = padProbeInfoGetBuffer++-- method PadProbeInfo::get_buffer_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "BufferList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_probe_info_get_buffer_list" gst_pad_probe_info_get_buffer_list :: +    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"+    IO (Ptr BufferList)+++padProbeInfoGetBufferList ::+    (MonadIO m) =>+    PadProbeInfo                            -- _obj+    -> m BufferList                         -- result+padProbeInfoGetBufferList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_pad_probe_info_get_buffer_list _obj'+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_buffer_list" result+    result' <- (newBoxed BufferList) result+    touchManagedPtr _obj+    return result'++data PadProbeInfoGetBufferListMethodInfo+instance (signature ~ (m BufferList), MonadIO m) => MethodInfo PadProbeInfoGetBufferListMethodInfo PadProbeInfo signature where+    overloadedMethod _ = padProbeInfoGetBufferList++-- method PadProbeInfo::get_event+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Event"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_probe_info_get_event" gst_pad_probe_info_get_event :: +    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"+    IO (Ptr Event)+++padProbeInfoGetEvent ::+    (MonadIO m) =>+    PadProbeInfo                            -- _obj+    -> m Event                              -- result+padProbeInfoGetEvent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_pad_probe_info_get_event _obj'+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_event" result+    result' <- (newBoxed Event) result+    touchManagedPtr _obj+    return result'++data PadProbeInfoGetEventMethodInfo+instance (signature ~ (m Event), MonadIO m) => MethodInfo PadProbeInfoGetEventMethodInfo PadProbeInfo signature where+    overloadedMethod _ = padProbeInfoGetEvent++-- method PadProbeInfo::get_query+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_pad_probe_info_get_query" gst_pad_probe_info_get_query :: +    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"+    IO (Ptr Query)+++padProbeInfoGetQuery ::+    (MonadIO m) =>+    PadProbeInfo                            -- _obj+    -> m Query                              -- result+padProbeInfoGetQuery _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_pad_probe_info_get_query _obj'+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_query" result+    result' <- (newBoxed Query) result+    touchManagedPtr _obj+    return result'++data PadProbeInfoGetQueryMethodInfo+instance (signature ~ (m Query), MonadIO m) => MethodInfo PadProbeInfoGetQueryMethodInfo PadProbeInfo signature where+    overloadedMethod _ = padProbeInfoGetQuery++type family ResolvePadProbeInfoMethod (t :: Symbol) (o :: *) :: * where+    ResolvePadProbeInfoMethod "getBuffer" o = PadProbeInfoGetBufferMethodInfo+    ResolvePadProbeInfoMethod "getBufferList" o = PadProbeInfoGetBufferListMethodInfo+    ResolvePadProbeInfoMethod "getEvent" o = PadProbeInfoGetEventMethodInfo+    ResolvePadProbeInfoMethod "getQuery" o = PadProbeInfoGetQueryMethodInfo+    ResolvePadProbeInfoMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePadProbeInfoMethod t PadProbeInfo, MethodInfo info PadProbeInfo p) => IsLabelProxy t (PadProbeInfo -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePadProbeInfoMethod t PadProbeInfo, MethodInfo info PadProbeInfo p) => IsLabel t (PadProbeInfo -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/PadProbeInfo.hs-boot view
@@ -0,0 +1,14 @@+module GI.Gst.Structs.PadProbeInfo 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++newtype PadProbeInfo = PadProbeInfo (ForeignPtr PadProbeInfo)+data PadProbeInfoGetBufferMethodInfo+data PadProbeInfoGetBufferListMethodInfo+data PadProbeInfoGetEventMethodInfo+data PadProbeInfoGetQueryMethodInfo
+ GI/Gst/Structs/ParamSpecFraction.hs view
@@ -0,0 +1,119 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A GParamSpec derived structure that contains the meta data for fractional+properties.+-}++module GI.Gst.Structs.ParamSpecFraction+    ( ++-- * Exported types+    ParamSpecFraction(..)                   ,+    newZeroParamSpecFraction                ,+    noParamSpecFraction                     ,+++ -- * Properties+-- ** DefDen+    paramSpecFractionReadDefDen             ,+++-- ** DefNum+    paramSpecFractionReadDefNum             ,+++-- ** MaxDen+    paramSpecFractionReadMaxDen             ,+++-- ** MaxNum+    paramSpecFractionReadMaxNum             ,+++-- ** MinDen+    paramSpecFractionReadMinDen             ,+++-- ** MinNum+    paramSpecFractionReadMinNum             ,+++-- ** ParentInstance+    paramSpecFractionReadParentInstance     ,+++++    ) 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 GI.Gst.Callbacks++newtype ParamSpecFraction = ParamSpecFraction (ForeignPtr ParamSpecFraction)+-- | Construct a `ParamSpecFraction` struct initialized to zero.+newZeroParamSpecFraction :: MonadIO m => m ParamSpecFraction+newZeroParamSpecFraction = liftIO $ callocBytes 96 >>= wrapPtr ParamSpecFraction++noParamSpecFraction :: Maybe ParamSpecFraction+noParamSpecFraction = Nothing++paramSpecFractionReadParentInstance :: ParamSpecFraction -> IO GParamSpec+paramSpecFractionReadParentInstance s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr GParamSpec)+    val' <- newGParamSpecFromPtr val+    return val'++paramSpecFractionReadMinNum :: ParamSpecFraction -> IO Int32+paramSpecFractionReadMinNum s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO Int32+    return val++paramSpecFractionReadMinDen :: ParamSpecFraction -> IO Int32+paramSpecFractionReadMinDen s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 76) :: IO Int32+    return val++paramSpecFractionReadMaxNum :: ParamSpecFraction -> IO Int32+paramSpecFractionReadMaxNum s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 80) :: IO Int32+    return val++paramSpecFractionReadMaxDen :: ParamSpecFraction -> IO Int32+paramSpecFractionReadMaxDen s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 84) :: IO Int32+    return val++paramSpecFractionReadDefNum :: ParamSpecFraction -> IO Int32+paramSpecFractionReadDefNum s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 88) :: IO Int32+    return val++paramSpecFractionReadDefDen :: ParamSpecFraction -> IO Int32+paramSpecFractionReadDefDen s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 92) :: IO Int32+    return val++type family ResolveParamSpecFractionMethod (t :: Symbol) (o :: *) :: * where+    ResolveParamSpecFractionMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveParamSpecFractionMethod t ParamSpecFraction, MethodInfo info ParamSpecFraction p) => IsLabelProxy t (ParamSpecFraction -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveParamSpecFractionMethod t ParamSpecFraction, MethodInfo info ParamSpecFraction p) => IsLabel t (ParamSpecFraction -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/ParamSpecFraction.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.ParamSpecFraction 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++newtype ParamSpecFraction = ParamSpecFraction (ForeignPtr ParamSpecFraction)
+ GI/Gst/Structs/ParentBufferMeta.hs view
@@ -0,0 +1,109 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The #GstParentBufferMeta is a #GstMeta which can be attached to a #GstBuffer+to hold a reference to another buffer that is only released when the child+#GstBuffer is released.++Typically, #GstParentBufferMeta is used when the child buffer is directly+using the #GstMemory of the parent buffer, and wants to prevent the parent+buffer from being returned to a buffer pool until the #GstMemory is available+for re-use.+-}++module GI.Gst.Structs.ParentBufferMeta+    ( ++-- * Exported types+    ParentBufferMeta(..)                    ,+    newZeroParentBufferMeta                 ,+    noParentBufferMeta                      ,+++ -- * Methods+-- ** parentBufferMetaGetInfo+    parentBufferMetaGetInfo                 ,+++++ -- * Properties+-- ** Buffer+    parentBufferMetaReadBuffer              ,+++-- ** Parent+    parentBufferMetaReadParent              ,+++++    ) 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 GI.Gst.Callbacks++newtype ParentBufferMeta = ParentBufferMeta (ForeignPtr ParentBufferMeta)+-- | Construct a `ParentBufferMeta` struct initialized to zero.+newZeroParentBufferMeta :: MonadIO m => m ParentBufferMeta+newZeroParentBufferMeta = liftIO $ callocBytes 24 >>= wrapPtr ParentBufferMeta++noParentBufferMeta :: Maybe ParentBufferMeta+noParentBufferMeta = Nothing++parentBufferMetaReadParent :: ParentBufferMeta -> IO Meta+parentBufferMetaReadParent s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Meta)+    val' <- (newPtr 16 Meta) val+    return val'++parentBufferMetaReadBuffer :: ParentBufferMeta -> IO Buffer+parentBufferMetaReadBuffer s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Buffer)+    val' <- (newBoxed Buffer) val+    return val'++-- method ParentBufferMeta::get_info+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_parent_buffer_meta_get_info" gst_parent_buffer_meta_get_info :: +    IO (Ptr MetaInfo)+++parentBufferMetaGetInfo ::+    (MonadIO m) =>+    m MetaInfo                              -- result+parentBufferMetaGetInfo  = liftIO $ do+    result <- gst_parent_buffer_meta_get_info+    checkUnexpectedReturnNULL "gst_parent_buffer_meta_get_info" result+    result' <- (newPtr 80 MetaInfo) result+    return result'++type family ResolveParentBufferMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveParentBufferMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveParentBufferMetaMethod t ParentBufferMeta, MethodInfo info ParentBufferMeta p) => IsLabelProxy t (ParentBufferMeta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveParentBufferMetaMethod t ParentBufferMeta, MethodInfo info ParentBufferMeta p) => IsLabel t (ParentBufferMeta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/ParentBufferMeta.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.ParentBufferMeta 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++newtype ParentBufferMeta = ParentBufferMeta (ForeignPtr ParentBufferMeta)
+ GI/Gst/Structs/ParseContext.hs view
@@ -0,0 +1,150 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Opaque structure.+-}++module GI.Gst.Structs.ParseContext+    ( ++-- * Exported types+    ParseContext(..)                        ,+    noParseContext                          ,+++ -- * Methods+-- ** parseContextFree+    ParseContextFreeMethodInfo              ,+    parseContextFree                        ,+++-- ** parseContextGetMissingElements+    ParseContextGetMissingElementsMethodInfo,+    parseContextGetMissingElements          ,+++-- ** parseContextNew+    parseContextNew                         ,+++++    ) 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 GI.Gst.Callbacks++newtype ParseContext = ParseContext (ForeignPtr ParseContext)+foreign import ccall "gst_parse_context_get_type" c_gst_parse_context_get_type :: +    IO GType++instance BoxedObject ParseContext where+    boxedType _ = c_gst_parse_context_get_type++noParseContext :: Maybe ParseContext+noParseContext = Nothing++-- method ParseContext::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "ParseContext"+-- throws : False+-- Skip return : False++foreign import ccall "gst_parse_context_new" gst_parse_context_new :: +    IO (Ptr ParseContext)+++parseContextNew ::+    (MonadIO m) =>+    m ParseContext                          -- result+parseContextNew  = liftIO $ do+    result <- gst_parse_context_new+    checkUnexpectedReturnNULL "gst_parse_context_new" result+    result' <- (wrapBoxed ParseContext) result+    return result'++-- method ParseContext::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_parse_context_free" gst_parse_context_free :: +    Ptr ParseContext ->                     -- _obj : TInterface "Gst" "ParseContext"+    IO ()+++parseContextFree ::+    (MonadIO m) =>+    ParseContext                            -- _obj+    -> m ()                                 -- result+parseContextFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_parse_context_free _obj'+    touchManagedPtr _obj+    return ()++data ParseContextFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo ParseContextFreeMethodInfo ParseContext signature where+    overloadedMethod _ = parseContextFree++-- method ParseContext::get_missing_elements+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_parse_context_get_missing_elements" gst_parse_context_get_missing_elements :: +    Ptr ParseContext ->                     -- _obj : TInterface "Gst" "ParseContext"+    IO (Ptr CString)+++parseContextGetMissingElements ::+    (MonadIO m) =>+    ParseContext                            -- _obj+    -> m [T.Text]                           -- result+parseContextGetMissingElements _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_parse_context_get_missing_elements _obj'+    checkUnexpectedReturnNULL "gst_parse_context_get_missing_elements" result+    result' <- unpackZeroTerminatedUTF8CArray result+    mapZeroTerminatedCArray freeMem result+    freeMem result+    touchManagedPtr _obj+    return result'++data ParseContextGetMissingElementsMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m) => MethodInfo ParseContextGetMissingElementsMethodInfo ParseContext signature where+    overloadedMethod _ = parseContextGetMissingElements++type family ResolveParseContextMethod (t :: Symbol) (o :: *) :: * where+    ResolveParseContextMethod "free" o = ParseContextFreeMethodInfo+    ResolveParseContextMethod "getMissingElements" o = ParseContextGetMissingElementsMethodInfo+    ResolveParseContextMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveParseContextMethod t ParseContext, MethodInfo info ParseContext p) => IsLabelProxy t (ParseContext -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveParseContextMethod t ParseContext, MethodInfo info ParseContext p) => IsLabel t (ParseContext -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/ParseContext.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gst.Structs.ParseContext 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++newtype ParseContext = ParseContext (ForeignPtr ParseContext)+instance BoxedObject ParseContext where+data ParseContextFreeMethodInfo+data ParseContextGetMissingElementsMethodInfo
+ GI/Gst/Structs/PluginDesc.hs view
@@ -0,0 +1,158 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A plugin should export a variable of this type called plugin_desc. The plugin+loader will use the data provided there to initialize the plugin.++The @licence parameter must be one of: LGPL, GPL, QPL, GPL/QPL, MPL,+BSD, MIT/X11, Proprietary, unknown.+-}++module GI.Gst.Structs.PluginDesc+    ( ++-- * Exported types+    PluginDesc(..)                          ,+    newZeroPluginDesc                       ,+    noPluginDesc                            ,+++ -- * Properties+-- ** Description+    pluginDescReadDescription               ,+++-- ** License+    pluginDescReadLicense                   ,+++-- ** MajorVersion+    pluginDescReadMajorVersion              ,+++-- ** MinorVersion+    pluginDescReadMinorVersion              ,+++-- ** Name+    pluginDescReadName                      ,+++-- ** Origin+    pluginDescReadOrigin                    ,+++-- ** Package+    pluginDescReadPackage                   ,+++-- ** ReleaseDatetime+    pluginDescReadReleaseDatetime           ,+++-- ** Source+    pluginDescReadSource                    ,+++-- ** Version+    pluginDescReadVersion                   ,+++++    ) 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 GI.Gst.Callbacks++newtype PluginDesc = PluginDesc (ForeignPtr PluginDesc)+-- | Construct a `PluginDesc` struct initialized to zero.+newZeroPluginDesc :: MonadIO m => m PluginDesc+newZeroPluginDesc = liftIO $ callocBytes 112 >>= wrapPtr PluginDesc++noPluginDesc :: Maybe PluginDesc+noPluginDesc = Nothing++pluginDescReadMajorVersion :: PluginDesc -> IO Int32+pluginDescReadMajorVersion s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++pluginDescReadMinorVersion :: PluginDesc -> IO Int32+pluginDescReadMinorVersion s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 4) :: IO Int32+    return val++pluginDescReadName :: PluginDesc -> IO T.Text+pluginDescReadName s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++pluginDescReadDescription :: PluginDesc -> IO T.Text+pluginDescReadDescription s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CString+    val' <- cstringToText val+    return val'++-- XXX Skipped getter for "PluginDesc:plugin_init" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++pluginDescReadVersion :: PluginDesc -> IO T.Text+pluginDescReadVersion s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO CString+    val' <- cstringToText val+    return val'++pluginDescReadLicense :: PluginDesc -> IO T.Text+pluginDescReadLicense s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO CString+    val' <- cstringToText val+    return val'++pluginDescReadSource :: PluginDesc -> IO T.Text+pluginDescReadSource s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO CString+    val' <- cstringToText val+    return val'++pluginDescReadPackage :: PluginDesc -> IO T.Text+pluginDescReadPackage s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO CString+    val' <- cstringToText val+    return val'++pluginDescReadOrigin :: PluginDesc -> IO T.Text+pluginDescReadOrigin s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO CString+    val' <- cstringToText val+    return val'++pluginDescReadReleaseDatetime :: PluginDesc -> IO T.Text+pluginDescReadReleaseDatetime s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO CString+    val' <- cstringToText val+    return val'++type family ResolvePluginDescMethod (t :: Symbol) (o :: *) :: * where+    ResolvePluginDescMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePluginDescMethod t PluginDesc, MethodInfo info PluginDesc p) => IsLabelProxy t (PluginDesc -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePluginDescMethod t PluginDesc, MethodInfo info PluginDesc p) => IsLabel t (PluginDesc -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/PluginDesc.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.PluginDesc 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++newtype PluginDesc = PluginDesc (ForeignPtr PluginDesc)
+ GI/Gst/Structs/Poll.hs view
@@ -0,0 +1,698 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #GstPoll keeps track of file descriptors much like fd_set (used with+select()) or a struct pollfd array (used with poll()). Once created with+gst_poll_new(), the set can be used to wait for file descriptors to be+readable and/or writable. It is possible to make this wait be controlled+by specifying %TRUE for the @controllable flag when creating the set (or+later calling gst_poll_set_controllable()).++New file descriptors are added to the set using gst_poll_add_fd(), and+removed using gst_poll_remove_fd(). Controlling which file descriptors+should be waited for to become readable and/or writable are done using+gst_poll_fd_ctl_read() and gst_poll_fd_ctl_write().++Use gst_poll_wait() to wait for the file descriptors to actually become+readable and/or writable, or to timeout if no file descriptor is available+in time. The wait can be controlled by calling gst_poll_restart() and+gst_poll_set_flushing().++Once the file descriptor set has been waited for, one can use+gst_poll_fd_has_closed() to see if the file descriptor has been closed,+gst_poll_fd_has_error() to see if it has generated an error,+gst_poll_fd_can_read() to see if it is possible to read from the file+descriptor, and gst_poll_fd_can_write() to see if it is possible to+write to it.+-}++module GI.Gst.Structs.Poll+    ( ++-- * Exported types+    Poll(..)                                ,+    noPoll                                  ,+++ -- * Methods+-- ** pollAddFd+    PollAddFdMethodInfo                     ,+    pollAddFd                               ,+++-- ** pollFdCanRead+    PollFdCanReadMethodInfo                 ,+    pollFdCanRead                           ,+++-- ** pollFdCanWrite+    PollFdCanWriteMethodInfo                ,+    pollFdCanWrite                          ,+++-- ** pollFdCtlRead+    PollFdCtlReadMethodInfo                 ,+    pollFdCtlRead                           ,+++-- ** pollFdCtlWrite+    PollFdCtlWriteMethodInfo                ,+    pollFdCtlWrite                          ,+++-- ** pollFdHasClosed+    PollFdHasClosedMethodInfo               ,+    pollFdHasClosed                         ,+++-- ** pollFdHasError+    PollFdHasErrorMethodInfo                ,+    pollFdHasError                          ,+++-- ** pollFdIgnored+    PollFdIgnoredMethodInfo                 ,+    pollFdIgnored                           ,+++-- ** pollFree+    PollFreeMethodInfo                      ,+    pollFree                                ,+++-- ** pollGetReadGpollfd+    PollGetReadGpollfdMethodInfo            ,+    pollGetReadGpollfd                      ,+++-- ** pollReadControl+    PollReadControlMethodInfo               ,+    pollReadControl                         ,+++-- ** pollRemoveFd+    PollRemoveFdMethodInfo                  ,+    pollRemoveFd                            ,+++-- ** pollRestart+    PollRestartMethodInfo                   ,+    pollRestart                             ,+++-- ** pollSetControllable+    PollSetControllableMethodInfo           ,+    pollSetControllable                     ,+++-- ** pollSetFlushing+    PollSetFlushingMethodInfo               ,+    pollSetFlushing                         ,+++-- ** pollWait+    PollWaitMethodInfo                      ,+    pollWait                                ,+++-- ** pollWriteControl+    PollWriteControlMethodInfo              ,+    pollWriteControl                        ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype Poll = Poll (ForeignPtr Poll)+noPoll :: Maybe Poll+noPoll = Nothing++-- method Poll::add_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_add_fd" gst_poll_add_fd :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    IO CInt+++pollAddFd ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> m Bool                               -- result+pollAddFd _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    result <- gst_poll_add_fd _obj' fd'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollAddFdMethodInfo+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollAddFdMethodInfo Poll signature where+    overloadedMethod _ = pollAddFd++-- method Poll::fd_can_read+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_can_read" gst_poll_fd_can_read :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    IO CInt+++pollFdCanRead ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> m Bool                               -- result+pollFdCanRead _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    result <- gst_poll_fd_can_read _obj' fd'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollFdCanReadMethodInfo+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdCanReadMethodInfo Poll signature where+    overloadedMethod _ = pollFdCanRead++-- method Poll::fd_can_write+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_can_write" gst_poll_fd_can_write :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    IO CInt+++pollFdCanWrite ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> m Bool                               -- result+pollFdCanWrite _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    result <- gst_poll_fd_can_write _obj' fd'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollFdCanWriteMethodInfo+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdCanWriteMethodInfo Poll signature where+    overloadedMethod _ = pollFdCanWrite++-- method Poll::fd_ctl_read+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_ctl_read" gst_poll_fd_ctl_read :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++pollFdCtlRead ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> Bool                                 -- active+    -> m Bool                               -- result+pollFdCtlRead _obj fd active = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    let active' = (fromIntegral . fromEnum) active+    result <- gst_poll_fd_ctl_read _obj' fd' active'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollFdCtlReadMethodInfo+instance (signature ~ (PollFD -> Bool -> m Bool), MonadIO m) => MethodInfo PollFdCtlReadMethodInfo Poll signature where+    overloadedMethod _ = pollFdCtlRead++-- method Poll::fd_ctl_write+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_ctl_write" gst_poll_fd_ctl_write :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    CInt ->                                 -- active : TBasicType TBoolean+    IO CInt+++pollFdCtlWrite ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> Bool                                 -- active+    -> m Bool                               -- result+pollFdCtlWrite _obj fd active = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    let active' = (fromIntegral . fromEnum) active+    result <- gst_poll_fd_ctl_write _obj' fd' active'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollFdCtlWriteMethodInfo+instance (signature ~ (PollFD -> Bool -> m Bool), MonadIO m) => MethodInfo PollFdCtlWriteMethodInfo Poll signature where+    overloadedMethod _ = pollFdCtlWrite++-- method Poll::fd_has_closed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_has_closed" gst_poll_fd_has_closed :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    IO CInt+++pollFdHasClosed ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> m Bool                               -- result+pollFdHasClosed _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    result <- gst_poll_fd_has_closed _obj' fd'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollFdHasClosedMethodInfo+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdHasClosedMethodInfo Poll signature where+    overloadedMethod _ = pollFdHasClosed++-- method Poll::fd_has_error+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_has_error" gst_poll_fd_has_error :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    IO CInt+++pollFdHasError ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> m Bool                               -- result+pollFdHasError _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    result <- gst_poll_fd_has_error _obj' fd'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollFdHasErrorMethodInfo+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdHasErrorMethodInfo Poll signature where+    overloadedMethod _ = pollFdHasError++-- method Poll::fd_ignored+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_ignored" gst_poll_fd_ignored :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    IO ()+++pollFdIgnored ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> m ()                                 -- result+pollFdIgnored _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    gst_poll_fd_ignored _obj' fd'+    touchManagedPtr _obj+    touchManagedPtr fd+    return ()++data PollFdIgnoredMethodInfo+instance (signature ~ (PollFD -> m ()), MonadIO m) => MethodInfo PollFdIgnoredMethodInfo Poll signature where+    overloadedMethod _ = pollFdIgnored++-- method Poll::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_free" gst_poll_free :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    IO ()+++pollFree ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> m ()                                 -- result+pollFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_poll_free _obj'+    touchManagedPtr _obj+    return ()++data PollFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo PollFreeMethodInfo Poll signature where+    overloadedMethod _ = pollFree++-- method Poll::get_read_gpollfd+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "GLib" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_get_read_gpollfd" gst_poll_get_read_gpollfd :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr GLib.PollFD ->                      -- fd : TInterface "GLib" "PollFD"+    IO ()+++pollGetReadGpollfd ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> GLib.PollFD                          -- fd+    -> m ()                                 -- result+pollGetReadGpollfd _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    gst_poll_get_read_gpollfd _obj' fd'+    touchManagedPtr _obj+    touchManagedPtr fd+    return ()++data PollGetReadGpollfdMethodInfo+instance (signature ~ (GLib.PollFD -> m ()), MonadIO m) => MethodInfo PollGetReadGpollfdMethodInfo Poll signature where+    overloadedMethod _ = pollGetReadGpollfd++-- method Poll::read_control+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_read_control" gst_poll_read_control :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    IO CInt+++pollReadControl ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> m Bool                               -- result+pollReadControl _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_poll_read_control _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PollReadControlMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo PollReadControlMethodInfo Poll signature where+    overloadedMethod _ = pollReadControl++-- method Poll::remove_fd+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_remove_fd" gst_poll_remove_fd :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"+    IO CInt+++pollRemoveFd ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> PollFD                               -- fd+    -> m Bool                               -- result+pollRemoveFd _obj fd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let fd' = unsafeManagedPtrGetPtr fd+    result <- gst_poll_remove_fd _obj' fd'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr fd+    return result'++data PollRemoveFdMethodInfo+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollRemoveFdMethodInfo Poll signature where+    overloadedMethod _ = pollRemoveFd++-- method Poll::restart+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_restart" gst_poll_restart :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    IO ()+++pollRestart ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> m ()                                 -- result+pollRestart _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_poll_restart _obj'+    touchManagedPtr _obj+    return ()++data PollRestartMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo PollRestartMethodInfo Poll signature where+    overloadedMethod _ = pollRestart++-- method Poll::set_controllable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "controllable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_set_controllable" gst_poll_set_controllable :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    CInt ->                                 -- controllable : TBasicType TBoolean+    IO CInt+++pollSetControllable ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> Bool                                 -- controllable+    -> m Bool                               -- result+pollSetControllable _obj controllable = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let controllable' = (fromIntegral . fromEnum) controllable+    result <- gst_poll_set_controllable _obj' controllable'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PollSetControllableMethodInfo+instance (signature ~ (Bool -> m Bool), MonadIO m) => MethodInfo PollSetControllableMethodInfo Poll signature where+    overloadedMethod _ = pollSetControllable++-- method Poll::set_flushing+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_set_flushing" gst_poll_set_flushing :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    CInt ->                                 -- flushing : TBasicType TBoolean+    IO ()+++pollSetFlushing ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> Bool                                 -- flushing+    -> m ()                                 -- result+pollSetFlushing _obj flushing = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flushing' = (fromIntegral . fromEnum) flushing+    gst_poll_set_flushing _obj' flushing'+    touchManagedPtr _obj+    return ()++data PollSetFlushingMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo PollSetFlushingMethodInfo Poll signature where+    overloadedMethod _ = pollSetFlushing++-- method Poll::wait+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_wait" gst_poll_wait :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    Word64 ->                               -- timeout : TBasicType TUInt64+    IO Int32+++pollWait ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> Word64                               -- timeout+    -> m Int32                              -- result+pollWait _obj timeout = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_poll_wait _obj' timeout+    touchManagedPtr _obj+    return result++data PollWaitMethodInfo+instance (signature ~ (Word64 -> m Int32), MonadIO m) => MethodInfo PollWaitMethodInfo Poll signature where+    overloadedMethod _ = pollWait++-- method Poll::write_control+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_write_control" gst_poll_write_control :: +    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"+    IO CInt+++pollWriteControl ::+    (MonadIO m) =>+    Poll                                    -- _obj+    -> m Bool                               -- result+pollWriteControl _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_poll_write_control _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data PollWriteControlMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo PollWriteControlMethodInfo Poll signature where+    overloadedMethod _ = pollWriteControl++type family ResolvePollMethod (t :: Symbol) (o :: *) :: * where+    ResolvePollMethod "addFd" o = PollAddFdMethodInfo+    ResolvePollMethod "fdCanRead" o = PollFdCanReadMethodInfo+    ResolvePollMethod "fdCanWrite" o = PollFdCanWriteMethodInfo+    ResolvePollMethod "fdCtlRead" o = PollFdCtlReadMethodInfo+    ResolvePollMethod "fdCtlWrite" o = PollFdCtlWriteMethodInfo+    ResolvePollMethod "fdHasClosed" o = PollFdHasClosedMethodInfo+    ResolvePollMethod "fdHasError" o = PollFdHasErrorMethodInfo+    ResolvePollMethod "fdIgnored" o = PollFdIgnoredMethodInfo+    ResolvePollMethod "free" o = PollFreeMethodInfo+    ResolvePollMethod "readControl" o = PollReadControlMethodInfo+    ResolvePollMethod "removeFd" o = PollRemoveFdMethodInfo+    ResolvePollMethod "restart" o = PollRestartMethodInfo+    ResolvePollMethod "wait" o = PollWaitMethodInfo+    ResolvePollMethod "writeControl" o = PollWriteControlMethodInfo+    ResolvePollMethod "getReadGpollfd" o = PollGetReadGpollfdMethodInfo+    ResolvePollMethod "setControllable" o = PollSetControllableMethodInfo+    ResolvePollMethod "setFlushing" o = PollSetFlushingMethodInfo+    ResolvePollMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePollMethod t Poll, MethodInfo info Poll p) => IsLabelProxy t (Poll -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePollMethod t Poll, MethodInfo info Poll p) => IsLabel t (Poll -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Poll.hs-boot view
@@ -0,0 +1,27 @@+module GI.Gst.Structs.Poll 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++newtype Poll = Poll (ForeignPtr Poll)+data PollAddFdMethodInfo+data PollFdCanReadMethodInfo+data PollFdCanWriteMethodInfo+data PollFdCtlReadMethodInfo+data PollFdCtlWriteMethodInfo+data PollFdHasClosedMethodInfo+data PollFdHasErrorMethodInfo+data PollFdIgnoredMethodInfo+data PollFreeMethodInfo+data PollGetReadGpollfdMethodInfo+data PollReadControlMethodInfo+data PollRemoveFdMethodInfo+data PollRestartMethodInfo+data PollSetControllableMethodInfo+data PollSetFlushingMethodInfo+data PollWaitMethodInfo+data PollWriteControlMethodInfo
+ GI/Gst/Structs/PollFD.hs view
@@ -0,0 +1,99 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A file descriptor object.+-}++module GI.Gst.Structs.PollFD+    ( ++-- * Exported types+    PollFD(..)                              ,+    newZeroPollFD                           ,+    noPollFD                                ,+++ -- * Methods+-- ** pollFDInit+    PollFDInitMethodInfo                    ,+    pollFDInit                              ,+++++ -- * Properties+-- ** Fd+    pollFDReadFd                            ,+++++    ) 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 GI.Gst.Callbacks++newtype PollFD = PollFD (ForeignPtr PollFD)+-- | Construct a `PollFD` struct initialized to zero.+newZeroPollFD :: MonadIO m => m PollFD+newZeroPollFD = liftIO $ callocBytes 8 >>= wrapPtr PollFD++noPollFD :: Maybe PollFD+noPollFD = Nothing++pollFDReadFd :: PollFD -> IO Int32+pollFDReadFd s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Int32+    return val++-- method PollFD::init+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_poll_fd_init" gst_poll_fd_init :: +    Ptr PollFD ->                           -- _obj : TInterface "Gst" "PollFD"+    IO ()+++pollFDInit ::+    (MonadIO m) =>+    PollFD                                  -- _obj+    -> m ()                                 -- result+pollFDInit _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_poll_fd_init _obj'+    touchManagedPtr _obj+    return ()++data PollFDInitMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo PollFDInitMethodInfo PollFD signature where+    overloadedMethod _ = pollFDInit++type family ResolvePollFDMethod (t :: Symbol) (o :: *) :: * where+    ResolvePollFDMethod "init" o = PollFDInitMethodInfo+    ResolvePollFDMethod l o = MethodResolutionFailed l o++instance (info ~ ResolvePollFDMethod t PollFD, MethodInfo info PollFD p) => IsLabelProxy t (PollFD -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolvePollFDMethod t PollFD, MethodInfo info PollFD p) => IsLabel t (PollFD -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/PollFD.hs-boot view
@@ -0,0 +1,11 @@+module GI.Gst.Structs.PollFD 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++newtype PollFD = PollFD (ForeignPtr PollFD)+data PollFDInitMethodInfo
+ GI/Gst/Structs/ProtectionMeta.hs view
@@ -0,0 +1,103 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Metadata type that holds information about a sample from a protection-protected+track, including the information needed to decrypt it (if it is encrypted).+-}++module GI.Gst.Structs.ProtectionMeta+    ( ++-- * Exported types+    ProtectionMeta(..)                      ,+    newZeroProtectionMeta                   ,+    noProtectionMeta                        ,+++ -- * Methods+-- ** protectionMetaGetInfo+    protectionMetaGetInfo                   ,+++++ -- * Properties+-- ** Info+    protectionMetaReadInfo                  ,+++-- ** Meta+    protectionMetaReadMeta                  ,+++++    ) 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 GI.Gst.Callbacks++newtype ProtectionMeta = ProtectionMeta (ForeignPtr ProtectionMeta)+-- | Construct a `ProtectionMeta` struct initialized to zero.+newZeroProtectionMeta :: MonadIO m => m ProtectionMeta+newZeroProtectionMeta = liftIO $ callocBytes 24 >>= wrapPtr ProtectionMeta++noProtectionMeta :: Maybe ProtectionMeta+noProtectionMeta = Nothing++protectionMetaReadMeta :: ProtectionMeta -> IO Meta+protectionMetaReadMeta s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Meta)+    val' <- (newPtr 16 Meta) val+    return val'++protectionMetaReadInfo :: ProtectionMeta -> IO Structure+protectionMetaReadInfo s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Structure)+    val' <- (newBoxed Structure) val+    return val'++-- method ProtectionMeta::get_info+-- method type : MemberFunction+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "MetaInfo"+-- throws : False+-- Skip return : False++foreign import ccall "gst_protection_meta_get_info" gst_protection_meta_get_info :: +    IO (Ptr MetaInfo)+++protectionMetaGetInfo ::+    (MonadIO m) =>+    m MetaInfo                              -- result+protectionMetaGetInfo  = liftIO $ do+    result <- gst_protection_meta_get_info+    checkUnexpectedReturnNULL "gst_protection_meta_get_info" result+    result' <- (newPtr 80 MetaInfo) result+    return result'++type family ResolveProtectionMetaMethod (t :: Symbol) (o :: *) :: * where+    ResolveProtectionMetaMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveProtectionMetaMethod t ProtectionMeta, MethodInfo info ProtectionMeta p) => IsLabelProxy t (ProtectionMeta -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveProtectionMetaMethod t ProtectionMeta, MethodInfo info ProtectionMeta p) => IsLabel t (ProtectionMeta -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/ProtectionMeta.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.ProtectionMeta 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++newtype ProtectionMeta = ProtectionMeta (ForeignPtr ProtectionMeta)
+ GI/Gst/Structs/Query.hs view
@@ -0,0 +1,3145 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Queries can be performed on pads (gst_pad_query()) and elements+(gst_element_query()). Please note that some queries might need a running+pipeline to work.++Queries can be created using the gst_query_new_*() functions.+Query values can be set using gst_query_set_*(), and parsed using+gst_query_parse_*() helpers.++The following example shows how to query the duration of a pipeline:+|[+  GstQuery *query;+  gboolean res;+  query = gst_query_new_duration (GST_FORMAT_TIME);+  res = gst_element_query (pipeline, query);+  if (res) {+    gint64 duration;+    gst_query_parse_duration (query, NULL, &amp;duration);+    g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration));+  } else {+    g_print ("duration query failed...");+  }+  gst_query_unref (query);+]|+-}++module GI.Gst.Structs.Query+    ( ++-- * Exported types+    Query(..)                               ,+    newZeroQuery                            ,+    noQuery                                 ,+++ -- * Methods+-- ** queryAddAllocationMeta+    QueryAddAllocationMetaMethodInfo        ,+    queryAddAllocationMeta                  ,+++-- ** queryAddAllocationParam+    QueryAddAllocationParamMethodInfo       ,+    queryAddAllocationParam                 ,+++-- ** queryAddAllocationPool+    QueryAddAllocationPoolMethodInfo        ,+    queryAddAllocationPool                  ,+++-- ** queryAddBufferingRange+    QueryAddBufferingRangeMethodInfo        ,+    queryAddBufferingRange                  ,+++-- ** queryAddSchedulingMode+    QueryAddSchedulingModeMethodInfo        ,+    queryAddSchedulingMode                  ,+++-- ** queryFindAllocationMeta+    QueryFindAllocationMetaMethodInfo       ,+    queryFindAllocationMeta                 ,+++-- ** queryGetNAllocationMetas+    QueryGetNAllocationMetasMethodInfo      ,+    queryGetNAllocationMetas                ,+++-- ** queryGetNAllocationParams+    QueryGetNAllocationParamsMethodInfo     ,+    queryGetNAllocationParams               ,+++-- ** queryGetNAllocationPools+    QueryGetNAllocationPoolsMethodInfo      ,+    queryGetNAllocationPools                ,+++-- ** queryGetNBufferingRanges+    QueryGetNBufferingRangesMethodInfo      ,+    queryGetNBufferingRanges                ,+++-- ** queryGetNSchedulingModes+    QueryGetNSchedulingModesMethodInfo      ,+    queryGetNSchedulingModes                ,+++-- ** queryGetStructure+    QueryGetStructureMethodInfo             ,+    queryGetStructure                       ,+++-- ** queryHasSchedulingMode+    QueryHasSchedulingModeMethodInfo        ,+    queryHasSchedulingMode                  ,+++-- ** queryHasSchedulingModeWithFlags+    QueryHasSchedulingModeWithFlagsMethodInfo,+    queryHasSchedulingModeWithFlags         ,+++-- ** queryNewAcceptCaps+    queryNewAcceptCaps                      ,+++-- ** queryNewAllocation+    queryNewAllocation                      ,+++-- ** queryNewBuffering+    queryNewBuffering                       ,+++-- ** queryNewCaps+    queryNewCaps                            ,+++-- ** queryNewContext+    queryNewContext                         ,+++-- ** queryNewConvert+    queryNewConvert                         ,+++-- ** queryNewCustom+    queryNewCustom                          ,+++-- ** queryNewDrain+    queryNewDrain                           ,+++-- ** queryNewDuration+    queryNewDuration                        ,+++-- ** queryNewFormats+    queryNewFormats                         ,+++-- ** queryNewLatency+    queryNewLatency                         ,+++-- ** queryNewPosition+    queryNewPosition                        ,+++-- ** queryNewScheduling+    queryNewScheduling                      ,+++-- ** queryNewSeeking+    queryNewSeeking                         ,+++-- ** queryNewSegment+    queryNewSegment                         ,+++-- ** queryNewUri+    queryNewUri                             ,+++-- ** queryParseAcceptCaps+    QueryParseAcceptCapsMethodInfo          ,+    queryParseAcceptCaps                    ,+++-- ** queryParseAcceptCapsResult+    QueryParseAcceptCapsResultMethodInfo    ,+    queryParseAcceptCapsResult              ,+++-- ** queryParseAllocation+    QueryParseAllocationMethodInfo          ,+    queryParseAllocation                    ,+++-- ** queryParseBufferingPercent+    QueryParseBufferingPercentMethodInfo    ,+    queryParseBufferingPercent              ,+++-- ** queryParseBufferingRange+    QueryParseBufferingRangeMethodInfo      ,+    queryParseBufferingRange                ,+++-- ** queryParseBufferingStats+    QueryParseBufferingStatsMethodInfo      ,+    queryParseBufferingStats                ,+++-- ** queryParseCaps+    QueryParseCapsMethodInfo                ,+    queryParseCaps                          ,+++-- ** queryParseCapsResult+    QueryParseCapsResultMethodInfo          ,+    queryParseCapsResult                    ,+++-- ** queryParseContext+    QueryParseContextMethodInfo             ,+    queryParseContext                       ,+++-- ** queryParseContextType+    QueryParseContextTypeMethodInfo         ,+    queryParseContextType                   ,+++-- ** queryParseConvert+    QueryParseConvertMethodInfo             ,+    queryParseConvert                       ,+++-- ** queryParseDuration+    QueryParseDurationMethodInfo            ,+    queryParseDuration                      ,+++-- ** queryParseLatency+    QueryParseLatencyMethodInfo             ,+    queryParseLatency                       ,+++-- ** queryParseNFormats+    QueryParseNFormatsMethodInfo            ,+    queryParseNFormats                      ,+++-- ** queryParseNthAllocationMeta+    QueryParseNthAllocationMetaMethodInfo   ,+    queryParseNthAllocationMeta             ,+++-- ** queryParseNthAllocationParam+    QueryParseNthAllocationParamMethodInfo  ,+    queryParseNthAllocationParam            ,+++-- ** queryParseNthAllocationPool+    QueryParseNthAllocationPoolMethodInfo   ,+    queryParseNthAllocationPool             ,+++-- ** queryParseNthBufferingRange+    QueryParseNthBufferingRangeMethodInfo   ,+    queryParseNthBufferingRange             ,+++-- ** queryParseNthFormat+    QueryParseNthFormatMethodInfo           ,+    queryParseNthFormat                     ,+++-- ** queryParseNthSchedulingMode+    QueryParseNthSchedulingModeMethodInfo   ,+    queryParseNthSchedulingMode             ,+++-- ** queryParsePosition+    QueryParsePositionMethodInfo            ,+    queryParsePosition                      ,+++-- ** queryParseScheduling+    QueryParseSchedulingMethodInfo          ,+    queryParseScheduling                    ,+++-- ** queryParseSeeking+    QueryParseSeekingMethodInfo             ,+    queryParseSeeking                       ,+++-- ** queryParseSegment+    QueryParseSegmentMethodInfo             ,+    queryParseSegment                       ,+++-- ** queryParseUri+    QueryParseUriMethodInfo                 ,+    queryParseUri                           ,+++-- ** queryParseUriRedirection+    QueryParseUriRedirectionMethodInfo      ,+    queryParseUriRedirection                ,+++-- ** queryParseUriRedirectionPermanent+    QueryParseUriRedirectionPermanentMethodInfo,+    queryParseUriRedirectionPermanent       ,+++-- ** queryRemoveNthAllocationMeta+    QueryRemoveNthAllocationMetaMethodInfo  ,+    queryRemoveNthAllocationMeta            ,+++-- ** queryRemoveNthAllocationParam+    QueryRemoveNthAllocationParamMethodInfo ,+    queryRemoveNthAllocationParam           ,+++-- ** queryRemoveNthAllocationPool+    QueryRemoveNthAllocationPoolMethodInfo  ,+    queryRemoveNthAllocationPool            ,+++-- ** querySetAcceptCapsResult+    QuerySetAcceptCapsResultMethodInfo      ,+    querySetAcceptCapsResult                ,+++-- ** querySetBufferingPercent+    QuerySetBufferingPercentMethodInfo      ,+    querySetBufferingPercent                ,+++-- ** querySetBufferingRange+    QuerySetBufferingRangeMethodInfo        ,+    querySetBufferingRange                  ,+++-- ** querySetBufferingStats+    QuerySetBufferingStatsMethodInfo        ,+    querySetBufferingStats                  ,+++-- ** querySetCapsResult+    QuerySetCapsResultMethodInfo            ,+    querySetCapsResult                      ,+++-- ** querySetContext+    QuerySetContextMethodInfo               ,+    querySetContext                         ,+++-- ** querySetConvert+    QuerySetConvertMethodInfo               ,+    querySetConvert                         ,+++-- ** querySetDuration+    QuerySetDurationMethodInfo              ,+    querySetDuration                        ,+++-- ** querySetFormatsv+    QuerySetFormatsvMethodInfo              ,+    querySetFormatsv                        ,+++-- ** querySetLatency+    QuerySetLatencyMethodInfo               ,+    querySetLatency                         ,+++-- ** querySetNthAllocationParam+    QuerySetNthAllocationParamMethodInfo    ,+    querySetNthAllocationParam              ,+++-- ** querySetNthAllocationPool+    QuerySetNthAllocationPoolMethodInfo     ,+    querySetNthAllocationPool               ,+++-- ** querySetPosition+    QuerySetPositionMethodInfo              ,+    querySetPosition                        ,+++-- ** querySetScheduling+    QuerySetSchedulingMethodInfo            ,+    querySetScheduling                      ,+++-- ** querySetSeeking+    QuerySetSeekingMethodInfo               ,+    querySetSeeking                         ,+++-- ** querySetSegment+    QuerySetSegmentMethodInfo               ,+    querySetSegment                         ,+++-- ** querySetUri+    QuerySetUriMethodInfo                   ,+    querySetUri                             ,+++-- ** querySetUriRedirection+    QuerySetUriRedirectionMethodInfo        ,+    querySetUriRedirection                  ,+++-- ** querySetUriRedirectionPermanent+    QuerySetUriRedirectionPermanentMethodInfo,+    querySetUriRedirectionPermanent         ,+++-- ** queryWritableStructure+    QueryWritableStructureMethodInfo        ,+    queryWritableStructure                  ,+++++ -- * Properties+-- ** MiniObject+    queryReadMiniObject                     ,+++-- ** Type+    queryReadType                           ,+++++    ) 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 GI.Gst.Callbacks++newtype Query = Query (ForeignPtr Query)+foreign import ccall "gst_query_get_type" c_gst_query_get_type :: +    IO GType++instance BoxedObject Query where+    boxedType _ = c_gst_query_get_type++-- | Construct a `Query` struct initialized to zero.+newZeroQuery :: MonadIO m => m Query+newZeroQuery = liftIO $ callocBoxedBytes 72 >>= wrapBoxed Query++noQuery :: Maybe Query+noQuery = Nothing++queryReadMiniObject :: Query -> IO MiniObject+queryReadMiniObject s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)+    val' <- (newPtr 64 MiniObject) val+    return val'++queryReadType :: Query -> IO QueryType+queryReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++-- method Query::new_accept_caps+-- method type : Constructor+-- Args : [Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_accept_caps" gst_query_new_accept_caps :: +    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO (Ptr Query)+++queryNewAcceptCaps ::+    (MonadIO m) =>+    Caps                                    -- caps+    -> m Query                              -- result+queryNewAcceptCaps caps = liftIO $ do+    let caps' = unsafeManagedPtrGetPtr caps+    result <- gst_query_new_accept_caps caps'+    checkUnexpectedReturnNULL "gst_query_new_accept_caps" result+    result' <- (wrapBoxed Query) result+    touchManagedPtr caps+    return result'++-- method Query::new_allocation+-- method type : Constructor+-- Args : [Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "need_pool", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_allocation" gst_query_new_allocation :: +    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    CInt ->                                 -- need_pool : TBasicType TBoolean+    IO (Ptr Query)+++queryNewAllocation ::+    (MonadIO m) =>+    Caps                                    -- caps+    -> Bool                                 -- needPool+    -> m Query                              -- result+queryNewAllocation caps needPool = liftIO $ do+    let caps' = unsafeManagedPtrGetPtr caps+    let needPool' = (fromIntegral . fromEnum) needPool+    result <- gst_query_new_allocation caps' needPool'+    checkUnexpectedReturnNULL "gst_query_new_allocation" result+    result' <- (wrapBoxed Query) result+    touchManagedPtr caps+    return result'++-- method Query::new_buffering+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_buffering" gst_query_new_buffering :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    IO (Ptr Query)+++queryNewBuffering ::+    (MonadIO m) =>+    Format                                  -- format+    -> m Query                              -- result+queryNewBuffering format = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- gst_query_new_buffering format'+    checkUnexpectedReturnNULL "gst_query_new_buffering" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_caps+-- method type : Constructor+-- Args : [Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_caps" gst_query_new_caps :: +    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"+    IO (Ptr Query)+++queryNewCaps ::+    (MonadIO m) =>+    Caps                                    -- filter+    -> m Query                              -- result+queryNewCaps filter = liftIO $ do+    let filter' = unsafeManagedPtrGetPtr filter+    result <- gst_query_new_caps filter'+    checkUnexpectedReturnNULL "gst_query_new_caps" result+    result' <- (wrapBoxed Query) result+    touchManagedPtr filter+    return result'++-- method Query::new_context+-- method type : Constructor+-- Args : [Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_context" gst_query_new_context :: +    CString ->                              -- context_type : TBasicType TUTF8+    IO (Ptr Query)+++queryNewContext ::+    (MonadIO m) =>+    T.Text                                  -- contextType+    -> m Query                              -- result+queryNewContext contextType = liftIO $ do+    contextType' <- textToCString contextType+    result <- gst_query_new_context contextType'+    checkUnexpectedReturnNULL "gst_query_new_context" result+    result' <- (wrapBoxed Query) result+    freeMem contextType'+    return result'++-- method Query::new_convert+-- method type : Constructor+-- Args : [Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_convert" gst_query_new_convert :: +    CUInt ->                                -- src_format : TInterface "Gst" "Format"+    Int64 ->                                -- value : TBasicType TInt64+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"+    IO (Ptr Query)+++queryNewConvert ::+    (MonadIO m) =>+    Format                                  -- srcFormat+    -> Int64                                -- value+    -> Format                               -- destFormat+    -> m Query                              -- result+queryNewConvert srcFormat value destFormat = liftIO $ do+    let srcFormat' = (fromIntegral . fromEnum) srcFormat+    let destFormat' = (fromIntegral . fromEnum) destFormat+    result <- gst_query_new_convert srcFormat' value destFormat'+    checkUnexpectedReturnNULL "gst_query_new_convert" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_custom+-- method type : Constructor+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "QueryType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_custom" gst_query_new_custom :: +    CUInt ->                                -- type : TInterface "Gst" "QueryType"+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"+    IO (Ptr Query)+++queryNewCustom ::+    (MonadIO m) =>+    QueryType                               -- type_+    -> Maybe (Structure)                    -- structure+    -> m Query                              -- result+queryNewCustom type_ structure = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    maybeStructure <- case structure of+        Nothing -> return nullPtr+        Just jStructure -> do+            jStructure' <- copyBoxed jStructure+            return jStructure'+    result <- gst_query_new_custom type_' maybeStructure+    checkUnexpectedReturnNULL "gst_query_new_custom" result+    result' <- (wrapBoxed Query) result+    whenJust structure touchManagedPtr+    return result'++-- method Query::new_drain+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_drain" gst_query_new_drain :: +    IO (Ptr Query)+++queryNewDrain ::+    (MonadIO m) =>+    m Query                                 -- result+queryNewDrain  = liftIO $ do+    result <- gst_query_new_drain+    checkUnexpectedReturnNULL "gst_query_new_drain" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_duration+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_duration" gst_query_new_duration :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    IO (Ptr Query)+++queryNewDuration ::+    (MonadIO m) =>+    Format                                  -- format+    -> m Query                              -- result+queryNewDuration format = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- gst_query_new_duration format'+    checkUnexpectedReturnNULL "gst_query_new_duration" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_formats+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_formats" gst_query_new_formats :: +    IO (Ptr Query)+++queryNewFormats ::+    (MonadIO m) =>+    m Query                                 -- result+queryNewFormats  = liftIO $ do+    result <- gst_query_new_formats+    checkUnexpectedReturnNULL "gst_query_new_formats" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_latency+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_latency" gst_query_new_latency :: +    IO (Ptr Query)+++queryNewLatency ::+    (MonadIO m) =>+    m Query                                 -- result+queryNewLatency  = liftIO $ do+    result <- gst_query_new_latency+    checkUnexpectedReturnNULL "gst_query_new_latency" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_position+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_position" gst_query_new_position :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    IO (Ptr Query)+++queryNewPosition ::+    (MonadIO m) =>+    Format                                  -- format+    -> m Query                              -- result+queryNewPosition format = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- gst_query_new_position format'+    checkUnexpectedReturnNULL "gst_query_new_position" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_scheduling+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_scheduling" gst_query_new_scheduling :: +    IO (Ptr Query)+++queryNewScheduling ::+    (MonadIO m) =>+    m Query                                 -- result+queryNewScheduling  = liftIO $ do+    result <- gst_query_new_scheduling+    checkUnexpectedReturnNULL "gst_query_new_scheduling" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_seeking+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_seeking" gst_query_new_seeking :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    IO (Ptr Query)+++queryNewSeeking ::+    (MonadIO m) =>+    Format                                  -- format+    -> m Query                              -- result+queryNewSeeking format = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- gst_query_new_seeking format'+    checkUnexpectedReturnNULL "gst_query_new_seeking" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_segment+-- method type : Constructor+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_segment" gst_query_new_segment :: +    CUInt ->                                -- format : TInterface "Gst" "Format"+    IO (Ptr Query)+++queryNewSegment ::+    (MonadIO m) =>+    Format                                  -- format+    -> m Query                              -- result+queryNewSegment format = liftIO $ do+    let format' = (fromIntegral . fromEnum) format+    result <- gst_query_new_segment format'+    checkUnexpectedReturnNULL "gst_query_new_segment" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::new_uri+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Query"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_new_uri" gst_query_new_uri :: +    IO (Ptr Query)+++queryNewUri ::+    (MonadIO m) =>+    m Query                                 -- result+queryNewUri  = liftIO $ do+    result <- gst_query_new_uri+    checkUnexpectedReturnNULL "gst_query_new_uri" result+    result' <- (wrapBoxed Query) result+    return result'++-- method Query::add_allocation_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_add_allocation_meta" gst_query_add_allocation_meta :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CGType ->                               -- api : TBasicType TGType+    Ptr Structure ->                        -- params : TInterface "Gst" "Structure"+    IO ()+++queryAddAllocationMeta ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> GType                                -- api+    -> Maybe (Structure)                    -- params+    -> m ()                                 -- result+queryAddAllocationMeta _obj api params = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let api' = gtypeToCGType api+    maybeParams <- case params of+        Nothing -> return nullPtr+        Just jParams -> do+            let jParams' = unsafeManagedPtrGetPtr jParams+            return jParams'+    gst_query_add_allocation_meta _obj' api' maybeParams+    touchManagedPtr _obj+    whenJust params touchManagedPtr+    return ()++data QueryAddAllocationMetaMethodInfo+instance (signature ~ (GType -> Maybe (Structure) -> m ()), MonadIO m) => MethodInfo QueryAddAllocationMetaMethodInfo Query signature where+    overloadedMethod _ = queryAddAllocationMeta++-- method Query::add_allocation_param+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_add_allocation_param" gst_query_add_allocation_param :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"+    IO ()+++queryAddAllocationParam ::+    (MonadIO m, AllocatorK a) =>+    Query                                   -- _obj+    -> Maybe (a)                            -- allocator+    -> Maybe (AllocationParams)             -- params+    -> m ()                                 -- result+queryAddAllocationParam _obj allocator params = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeAllocator <- case allocator of+        Nothing -> return nullPtr+        Just jAllocator -> do+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator+            return jAllocator'+    maybeParams <- case params of+        Nothing -> return nullPtr+        Just jParams -> do+            let jParams' = unsafeManagedPtrGetPtr jParams+            return jParams'+    gst_query_add_allocation_param _obj' maybeAllocator maybeParams+    touchManagedPtr _obj+    whenJust allocator touchManagedPtr+    whenJust params touchManagedPtr+    return ()++data QueryAddAllocationParamMethodInfo+instance (signature ~ (Maybe (a) -> Maybe (AllocationParams) -> m ()), MonadIO m, AllocatorK a) => MethodInfo QueryAddAllocationParamMethodInfo Query signature where+    overloadedMethod _ = queryAddAllocationParam++-- method Query::add_allocation_pool+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_add_allocation_pool" gst_query_add_allocation_pool :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr BufferPool ->                       -- pool : TInterface "Gst" "BufferPool"+    Word32 ->                               -- size : TBasicType TUInt32+    Word32 ->                               -- min_buffers : TBasicType TUInt32+    Word32 ->                               -- max_buffers : TBasicType TUInt32+    IO ()+++queryAddAllocationPool ::+    (MonadIO m, BufferPoolK a) =>+    Query                                   -- _obj+    -> Maybe (a)                            -- pool+    -> Word32                               -- size+    -> Word32                               -- minBuffers+    -> Word32                               -- maxBuffers+    -> m ()                                 -- result+queryAddAllocationPool _obj pool size minBuffers maxBuffers = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybePool <- case pool of+        Nothing -> return nullPtr+        Just jPool -> do+            let jPool' = unsafeManagedPtrCastPtr jPool+            return jPool'+    gst_query_add_allocation_pool _obj' maybePool size minBuffers maxBuffers+    touchManagedPtr _obj+    whenJust pool touchManagedPtr+    return ()++data QueryAddAllocationPoolMethodInfo+instance (signature ~ (Maybe (a) -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, BufferPoolK a) => MethodInfo QueryAddAllocationPoolMethodInfo Query signature where+    overloadedMethod _ = queryAddAllocationPool++-- method Query::add_buffering_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_add_buffering_range" gst_query_add_buffering_range :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Int64 ->                                -- start : TBasicType TInt64+    Int64 ->                                -- stop : TBasicType TInt64+    IO CInt+++queryAddBufferingRange ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Int64                                -- start+    -> Int64                                -- stop+    -> m Bool                               -- result+queryAddBufferingRange _obj start stop = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_add_buffering_range _obj' start stop+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data QueryAddBufferingRangeMethodInfo+instance (signature ~ (Int64 -> Int64 -> m Bool), MonadIO m) => MethodInfo QueryAddBufferingRangeMethodInfo Query signature where+    overloadedMethod _ = queryAddBufferingRange++-- method Query::add_scheduling_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_add_scheduling_mode" gst_query_add_scheduling_mode :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"+    IO ()+++queryAddSchedulingMode ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> PadMode                              -- mode+    -> m ()                                 -- result+queryAddSchedulingMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gst_query_add_scheduling_mode _obj' mode'+    touchManagedPtr _obj+    return ()++data QueryAddSchedulingModeMethodInfo+instance (signature ~ (PadMode -> m ()), MonadIO m) => MethodInfo QueryAddSchedulingModeMethodInfo Query signature where+    overloadedMethod _ = queryAddSchedulingMode++-- method Query::find_allocation_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_find_allocation_meta" gst_query_find_allocation_meta :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CGType ->                               -- api : TBasicType TGType+    Ptr Word32 ->                           -- index : TBasicType TUInt32+    IO CInt+++queryFindAllocationMeta ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> GType                                -- api+    -> m (Bool,Word32)                      -- result+queryFindAllocationMeta _obj api = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let api' = gtypeToCGType api+    index <- allocMem :: IO (Ptr Word32)+    result <- gst_query_find_allocation_meta _obj' api' index+    let result' = (/= 0) result+    index' <- peek index+    touchManagedPtr _obj+    freeMem index+    return (result', index')++data QueryFindAllocationMetaMethodInfo+instance (signature ~ (GType -> m (Bool,Word32)), MonadIO m) => MethodInfo QueryFindAllocationMetaMethodInfo Query signature where+    overloadedMethod _ = queryFindAllocationMeta++-- method Query::get_n_allocation_metas+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_get_n_allocation_metas" gst_query_get_n_allocation_metas :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    IO Word32+++queryGetNAllocationMetas ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m Word32                             -- result+queryGetNAllocationMetas _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_get_n_allocation_metas _obj'+    touchManagedPtr _obj+    return result++data QueryGetNAllocationMetasMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNAllocationMetasMethodInfo Query signature where+    overloadedMethod _ = queryGetNAllocationMetas++-- method Query::get_n_allocation_params+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_get_n_allocation_params" gst_query_get_n_allocation_params :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    IO Word32+++queryGetNAllocationParams ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m Word32                             -- result+queryGetNAllocationParams _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_get_n_allocation_params _obj'+    touchManagedPtr _obj+    return result++data QueryGetNAllocationParamsMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNAllocationParamsMethodInfo Query signature where+    overloadedMethod _ = queryGetNAllocationParams++-- method Query::get_n_allocation_pools+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_get_n_allocation_pools" gst_query_get_n_allocation_pools :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    IO Word32+++queryGetNAllocationPools ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m Word32                             -- result+queryGetNAllocationPools _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_get_n_allocation_pools _obj'+    touchManagedPtr _obj+    return result++data QueryGetNAllocationPoolsMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNAllocationPoolsMethodInfo Query signature where+    overloadedMethod _ = queryGetNAllocationPools++-- method Query::get_n_buffering_ranges+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_get_n_buffering_ranges" gst_query_get_n_buffering_ranges :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    IO Word32+++queryGetNBufferingRanges ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m Word32                             -- result+queryGetNBufferingRanges _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_get_n_buffering_ranges _obj'+    touchManagedPtr _obj+    return result++data QueryGetNBufferingRangesMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNBufferingRangesMethodInfo Query signature where+    overloadedMethod _ = queryGetNBufferingRanges++-- method Query::get_n_scheduling_modes+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_get_n_scheduling_modes" gst_query_get_n_scheduling_modes :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    IO Word32+++queryGetNSchedulingModes ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m Word32                             -- result+queryGetNSchedulingModes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_get_n_scheduling_modes _obj'+    touchManagedPtr _obj+    return result++data QueryGetNSchedulingModesMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNSchedulingModesMethodInfo Query signature where+    overloadedMethod _ = queryGetNSchedulingModes++-- method Query::get_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_get_structure" gst_query_get_structure :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    IO (Ptr Structure)+++queryGetStructure ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m Structure                          -- result+queryGetStructure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_get_structure _obj'+    checkUnexpectedReturnNULL "gst_query_get_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data QueryGetStructureMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo QueryGetStructureMethodInfo Query signature where+    overloadedMethod _ = queryGetStructure++-- method Query::has_scheduling_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_has_scheduling_mode" gst_query_has_scheduling_mode :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"+    IO CInt+++queryHasSchedulingMode ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> PadMode                              -- mode+    -> m Bool                               -- result+queryHasSchedulingMode _obj mode = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    result <- gst_query_has_scheduling_mode _obj' mode'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data QueryHasSchedulingModeMethodInfo+instance (signature ~ (PadMode -> m Bool), MonadIO m) => MethodInfo QueryHasSchedulingModeMethodInfo Query signature where+    overloadedMethod _ = queryHasSchedulingMode++-- method Query::has_scheduling_mode_with_flags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SchedulingFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_has_scheduling_mode_with_flags" gst_query_has_scheduling_mode_with_flags :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"+    CUInt ->                                -- flags : TInterface "Gst" "SchedulingFlags"+    IO CInt+++queryHasSchedulingModeWithFlags ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> PadMode                              -- mode+    -> [SchedulingFlags]                    -- flags+    -> m Bool                               -- result+queryHasSchedulingModeWithFlags _obj mode flags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    let flags' = gflagsToWord flags+    result <- gst_query_has_scheduling_mode_with_flags _obj' mode' flags'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data QueryHasSchedulingModeWithFlagsMethodInfo+instance (signature ~ (PadMode -> [SchedulingFlags] -> m Bool), MonadIO m) => MethodInfo QueryHasSchedulingModeWithFlagsMethodInfo Query signature where+    overloadedMethod _ = queryHasSchedulingModeWithFlags++-- method Query::parse_accept_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_accept_caps" gst_query_parse_accept_caps :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO ()+++queryParseAcceptCaps ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Caps)                             -- result+queryParseAcceptCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)+    gst_query_parse_accept_caps _obj' caps+    caps' <- (wrapBoxed Caps) caps+    touchManagedPtr _obj+    return caps'++data QueryParseAcceptCapsMethodInfo+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo QueryParseAcceptCapsMethodInfo Query signature where+    overloadedMethod _ = queryParseAcceptCaps++-- method Query::parse_accept_caps_result+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_accept_caps_result" gst_query_parse_accept_caps_result :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CInt ->                                 -- result : TBasicType TBoolean+    IO ()+++queryParseAcceptCapsResult ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Bool                                 -- result_+    -> m ()                                 -- result+queryParseAcceptCapsResult _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let result_' = (fromIntegral . fromEnum) result_+    gst_query_parse_accept_caps_result _obj' result_'+    touchManagedPtr _obj+    return ()++data QueryParseAcceptCapsResultMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo QueryParseAcceptCapsResultMethodInfo Query signature where+    overloadedMethod _ = queryParseAcceptCapsResult++-- method Query::parse_allocation+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "need_pool", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_allocation" gst_query_parse_allocation :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    Ptr CInt ->                             -- need_pool : TBasicType TBoolean+    IO ()+++queryParseAllocation ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Caps,Bool)                        -- result+queryParseAllocation _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)+    needPool <- allocMem :: IO (Ptr CInt)+    gst_query_parse_allocation _obj' caps needPool+    caps' <- (wrapBoxed Caps) caps+    needPool' <- peek needPool+    let needPool'' = (/= 0) needPool'+    touchManagedPtr _obj+    freeMem needPool+    return (caps', needPool'')++data QueryParseAllocationMethodInfo+instance (signature ~ (m (Caps,Bool)), MonadIO m) => MethodInfo QueryParseAllocationMethodInfo Query signature where+    overloadedMethod _ = queryParseAllocation++-- method Query::parse_buffering_percent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_buffering_percent" gst_query_parse_buffering_percent :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CInt ->                             -- busy : TBasicType TBoolean+    Ptr Int32 ->                            -- percent : TBasicType TInt32+    IO ()+++queryParseBufferingPercent ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Bool,Int32)                       -- result+queryParseBufferingPercent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    busy <- allocMem :: IO (Ptr CInt)+    percent <- allocMem :: IO (Ptr Int32)+    gst_query_parse_buffering_percent _obj' busy percent+    busy' <- peek busy+    let busy'' = (/= 0) busy'+    percent' <- peek percent+    touchManagedPtr _obj+    freeMem busy+    freeMem percent+    return (busy'', percent')++data QueryParseBufferingPercentMethodInfo+instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo QueryParseBufferingPercentMethodInfo Query signature where+    overloadedMethod _ = queryParseBufferingPercent++-- method Query::parse_buffering_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "estimated_total", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_buffering_range" gst_query_parse_buffering_range :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- start : TBasicType TInt64+    Ptr Int64 ->                            -- stop : TBasicType TInt64+    Ptr Int64 ->                            -- estimated_total : TBasicType TInt64+    IO ()+++queryParseBufferingRange ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Format,Int64,Int64,Int64)         -- result+queryParseBufferingRange _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    start <- allocMem :: IO (Ptr Int64)+    stop <- allocMem :: IO (Ptr Int64)+    estimatedTotal <- allocMem :: IO (Ptr Int64)+    gst_query_parse_buffering_range _obj' format start stop estimatedTotal+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    start' <- peek start+    stop' <- peek stop+    estimatedTotal' <- peek estimatedTotal+    touchManagedPtr _obj+    freeMem format+    freeMem start+    freeMem stop+    freeMem estimatedTotal+    return (format'', start', stop', estimatedTotal')++data QueryParseBufferingRangeMethodInfo+instance (signature ~ (m (Format,Int64,Int64,Int64)), MonadIO m) => MethodInfo QueryParseBufferingRangeMethodInfo Query signature where+    overloadedMethod _ = queryParseBufferingRange++-- method Query::parse_buffering_stats+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_buffering_stats" gst_query_parse_buffering_stats :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CUInt ->                            -- mode : TInterface "Gst" "BufferingMode"+    Ptr Int32 ->                            -- avg_in : TBasicType TInt32+    Ptr Int32 ->                            -- avg_out : TBasicType TInt32+    Ptr Int64 ->                            -- buffering_left : TBasicType TInt64+    IO ()+++queryParseBufferingStats ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (BufferingMode,Int32,Int32,Int64)  -- result+queryParseBufferingStats _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    mode <- allocMem :: IO (Ptr CUInt)+    avgIn <- allocMem :: IO (Ptr Int32)+    avgOut <- allocMem :: IO (Ptr Int32)+    bufferingLeft <- allocMem :: IO (Ptr Int64)+    gst_query_parse_buffering_stats _obj' mode avgIn avgOut bufferingLeft+    mode' <- peek mode+    let mode'' = (toEnum . fromIntegral) mode'+    avgIn' <- peek avgIn+    avgOut' <- peek avgOut+    bufferingLeft' <- peek bufferingLeft+    touchManagedPtr _obj+    freeMem mode+    freeMem avgIn+    freeMem avgOut+    freeMem bufferingLeft+    return (mode'', avgIn', avgOut', bufferingLeft')++data QueryParseBufferingStatsMethodInfo+instance (signature ~ (m (BufferingMode,Int32,Int32,Int64)), MonadIO m) => MethodInfo QueryParseBufferingStatsMethodInfo Query signature where+    overloadedMethod _ = queryParseBufferingStats++-- method Query::parse_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_caps" gst_query_parse_caps :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"+    IO ()+++queryParseCaps ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Caps)                             -- result+queryParseCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    filter <- callocBoxedBytes 64 :: IO (Ptr Caps)+    gst_query_parse_caps _obj' filter+    filter' <- (wrapBoxed Caps) filter+    touchManagedPtr _obj+    return filter'++data QueryParseCapsMethodInfo+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo QueryParseCapsMethodInfo Query signature where+    overloadedMethod _ = queryParseCaps++-- method Query::parse_caps_result+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_caps_result" gst_query_parse_caps_result :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO ()+++queryParseCapsResult ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Caps)                             -- result+queryParseCapsResult _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)+    gst_query_parse_caps_result _obj' caps+    caps' <- (wrapBoxed Caps) caps+    touchManagedPtr _obj+    return caps'++data QueryParseCapsResultMethodInfo+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo QueryParseCapsResultMethodInfo Query signature where+    overloadedMethod _ = queryParseCapsResult++-- method Query::parse_context+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_context" gst_query_parse_context :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr (Ptr Context) ->                    -- context : TInterface "Gst" "Context"+    IO ()+++queryParseContext ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Context)                          -- result+queryParseContext _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    context <- allocMem :: IO (Ptr (Ptr Context))+    gst_query_parse_context _obj' context+    context' <- peek context+    context'' <- (newBoxed Context) context'+    touchManagedPtr _obj+    freeMem context+    return context''++data QueryParseContextMethodInfo+instance (signature ~ (m (Context)), MonadIO m) => MethodInfo QueryParseContextMethodInfo Query signature where+    overloadedMethod _ = queryParseContext++-- method Query::parse_context_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_context_type" gst_query_parse_context_type :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CString ->                          -- context_type : TBasicType TUTF8+    IO CInt+++queryParseContextType ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Bool,T.Text)                      -- result+queryParseContextType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    contextType <- allocMem :: IO (Ptr CString)+    result <- gst_query_parse_context_type _obj' contextType+    let result' = (/= 0) result+    contextType' <- peek contextType+    contextType'' <- cstringToText contextType'+    touchManagedPtr _obj+    freeMem contextType+    return (result', contextType'')++data QueryParseContextTypeMethodInfo+instance (signature ~ (m (Bool,T.Text)), MonadIO m) => MethodInfo QueryParseContextTypeMethodInfo Query signature where+    overloadedMethod _ = queryParseContextType++-- method Query::parse_convert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_convert" gst_query_parse_convert :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CUInt ->                            -- src_format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- src_value : TBasicType TInt64+    Ptr CUInt ->                            -- dest_format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- dest_value : TBasicType TInt64+    IO ()+++queryParseConvert ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Format,Int64,Format,Int64)        -- result+queryParseConvert _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    srcFormat <- allocMem :: IO (Ptr CUInt)+    srcValue <- allocMem :: IO (Ptr Int64)+    destFormat <- allocMem :: IO (Ptr CUInt)+    destValue <- allocMem :: IO (Ptr Int64)+    gst_query_parse_convert _obj' srcFormat srcValue destFormat destValue+    srcFormat' <- peek srcFormat+    let srcFormat'' = (toEnum . fromIntegral) srcFormat'+    srcValue' <- peek srcValue+    destFormat' <- peek destFormat+    let destFormat'' = (toEnum . fromIntegral) destFormat'+    destValue' <- peek destValue+    touchManagedPtr _obj+    freeMem srcFormat+    freeMem srcValue+    freeMem destFormat+    freeMem destValue+    return (srcFormat'', srcValue', destFormat'', destValue')++data QueryParseConvertMethodInfo+instance (signature ~ (m (Format,Int64,Format,Int64)), MonadIO m) => MethodInfo QueryParseConvertMethodInfo Query signature where+    overloadedMethod _ = queryParseConvert++-- method Query::parse_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_duration" gst_query_parse_duration :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- duration : TBasicType TInt64+    IO ()+++queryParseDuration ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Format,Int64)                     -- result+queryParseDuration _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    duration <- allocMem :: IO (Ptr Int64)+    gst_query_parse_duration _obj' format duration+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    duration' <- peek duration+    touchManagedPtr _obj+    freeMem format+    freeMem duration+    return (format'', duration')++data QueryParseDurationMethodInfo+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo QueryParseDurationMethodInfo Query signature where+    overloadedMethod _ = queryParseDuration++-- method Query::parse_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_latency" gst_query_parse_latency :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CInt ->                             -- live : TBasicType TBoolean+    Ptr Word64 ->                           -- min_latency : TBasicType TUInt64+    Ptr Word64 ->                           -- max_latency : TBasicType TUInt64+    IO ()+++queryParseLatency ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Bool,Word64,Word64)               -- result+queryParseLatency _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    live <- allocMem :: IO (Ptr CInt)+    minLatency <- allocMem :: IO (Ptr Word64)+    maxLatency <- allocMem :: IO (Ptr Word64)+    gst_query_parse_latency _obj' live minLatency maxLatency+    live' <- peek live+    let live'' = (/= 0) live'+    minLatency' <- peek minLatency+    maxLatency' <- peek maxLatency+    touchManagedPtr _obj+    freeMem live+    freeMem minLatency+    freeMem maxLatency+    return (live'', minLatency', maxLatency')++data QueryParseLatencyMethodInfo+instance (signature ~ (m (Bool,Word64,Word64)), MonadIO m) => MethodInfo QueryParseLatencyMethodInfo Query signature where+    overloadedMethod _ = queryParseLatency++-- method Query::parse_n_formats+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_n_formats" gst_query_parse_n_formats :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Word32 ->                           -- n_formats : TBasicType TUInt32+    IO ()+++queryParseNFormats ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Word32)                           -- result+queryParseNFormats _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    nFormats <- allocMem :: IO (Ptr Word32)+    gst_query_parse_n_formats _obj' nFormats+    nFormats' <- peek nFormats+    touchManagedPtr _obj+    freeMem nFormats+    return nFormats'++data QueryParseNFormatsMethodInfo+instance (signature ~ (m (Word32)), MonadIO m) => MethodInfo QueryParseNFormatsMethodInfo Query signature where+    overloadedMethod _ = queryParseNFormats++-- method Query::parse_nth_allocation_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "Structure", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_nth_allocation_meta" gst_query_parse_nth_allocation_meta :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr Structure ->                        -- params : TInterface "Gst" "Structure"+    IO CGType+++queryParseNthAllocationMeta ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m (GType,Structure)                  -- result+queryParseNthAllocationMeta _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    params <- callocBoxedBytes 16 :: IO (Ptr Structure)+    result <- gst_query_parse_nth_allocation_meta _obj' index params+    let result' = GType result+    params' <- (wrapBoxed Structure) params+    touchManagedPtr _obj+    return (result', params')++data QueryParseNthAllocationMetaMethodInfo+instance (signature ~ (Word32 -> m (GType,Structure)), MonadIO m) => MethodInfo QueryParseNthAllocationMetaMethodInfo Query signature where+    overloadedMethod _ = queryParseNthAllocationMeta++-- method Query::parse_nth_allocation_param+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_nth_allocation_param" gst_query_parse_nth_allocation_param :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr (Ptr Allocator) ->                  -- allocator : TInterface "Gst" "Allocator"+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"+    IO ()+++queryParseNthAllocationParam ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m (Allocator,AllocationParams)       -- result+queryParseNthAllocationParam _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    allocator <- allocMem :: IO (Ptr (Ptr Allocator))+    params <- callocBoxedBytes 64 :: IO (Ptr AllocationParams)+    gst_query_parse_nth_allocation_param _obj' index allocator params+    allocator' <- peek allocator+    allocator'' <- (wrapObject Allocator) allocator'+    params' <- (wrapBoxed AllocationParams) params+    touchManagedPtr _obj+    freeMem allocator+    return (allocator'', params')++data QueryParseNthAllocationParamMethodInfo+instance (signature ~ (Word32 -> m (Allocator,AllocationParams)), MonadIO m) => MethodInfo QueryParseNthAllocationParamMethodInfo Query signature where+    overloadedMethod _ = queryParseNthAllocationParam++-- method Query::parse_nth_allocation_pool+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "BufferPool", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_nth_allocation_pool" gst_query_parse_nth_allocation_pool :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr (Ptr BufferPool) ->                 -- pool : TInterface "Gst" "BufferPool"+    Ptr Word32 ->                           -- size : TBasicType TUInt32+    Ptr Word32 ->                           -- min_buffers : TBasicType TUInt32+    Ptr Word32 ->                           -- max_buffers : TBasicType TUInt32+    IO ()+++queryParseNthAllocationPool ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m (BufferPool,Word32,Word32,Word32)  -- result+queryParseNthAllocationPool _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    pool <- allocMem :: IO (Ptr (Ptr BufferPool))+    size <- allocMem :: IO (Ptr Word32)+    minBuffers <- allocMem :: IO (Ptr Word32)+    maxBuffers <- allocMem :: IO (Ptr Word32)+    gst_query_parse_nth_allocation_pool _obj' index pool size minBuffers maxBuffers+    pool' <- peek pool+    pool'' <- (wrapObject BufferPool) pool'+    size' <- peek size+    minBuffers' <- peek minBuffers+    maxBuffers' <- peek maxBuffers+    touchManagedPtr _obj+    freeMem pool+    freeMem size+    freeMem minBuffers+    freeMem maxBuffers+    return (pool'', size', minBuffers', maxBuffers')++data QueryParseNthAllocationPoolMethodInfo+instance (signature ~ (Word32 -> m (BufferPool,Word32,Word32,Word32)), MonadIO m) => MethodInfo QueryParseNthAllocationPoolMethodInfo Query signature where+    overloadedMethod _ = queryParseNthAllocationPool++-- method Query::parse_nth_buffering_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_nth_buffering_range" gst_query_parse_nth_buffering_range :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr Int64 ->                            -- start : TBasicType TInt64+    Ptr Int64 ->                            -- stop : TBasicType TInt64+    IO CInt+++queryParseNthBufferingRange ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m (Bool,Int64,Int64)                 -- result+queryParseNthBufferingRange _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    start <- allocMem :: IO (Ptr Int64)+    stop <- allocMem :: IO (Ptr Int64)+    result <- gst_query_parse_nth_buffering_range _obj' index start stop+    let result' = (/= 0) result+    start' <- peek start+    stop' <- peek stop+    touchManagedPtr _obj+    freeMem start+    freeMem stop+    return (result', start', stop')++data QueryParseNthBufferingRangeMethodInfo+instance (signature ~ (Word32 -> m (Bool,Int64,Int64)), MonadIO m) => MethodInfo QueryParseNthBufferingRangeMethodInfo Query signature where+    overloadedMethod _ = queryParseNthBufferingRange++-- method Query::parse_nth_format+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nth", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_nth_format" gst_query_parse_nth_format :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Word32 ->                           -- nth : TBasicType TUInt32+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    IO ()+++queryParseNthFormat ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Word32,Format)                    -- result+queryParseNthFormat _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    nth <- allocMem :: IO (Ptr Word32)+    format <- allocMem :: IO (Ptr CUInt)+    gst_query_parse_nth_format _obj' nth format+    nth' <- peek nth+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    touchManagedPtr _obj+    freeMem nth+    freeMem format+    return (nth', format'')++data QueryParseNthFormatMethodInfo+instance (signature ~ (m (Word32,Format)), MonadIO m) => MethodInfo QueryParseNthFormatMethodInfo Query signature where+    overloadedMethod _ = queryParseNthFormat++-- method Query::parse_nth_scheduling_mode+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadMode"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_nth_scheduling_mode" gst_query_parse_nth_scheduling_mode :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    IO CUInt+++queryParseNthSchedulingMode ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m PadMode                            -- result+queryParseNthSchedulingMode _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_parse_nth_scheduling_mode _obj' index+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data QueryParseNthSchedulingModeMethodInfo+instance (signature ~ (Word32 -> m PadMode), MonadIO m) => MethodInfo QueryParseNthSchedulingModeMethodInfo Query signature where+    overloadedMethod _ = queryParseNthSchedulingMode++-- method Query::parse_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_position" gst_query_parse_position :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- cur : TBasicType TInt64+    IO ()+++queryParsePosition ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Format,Int64)                     -- result+queryParsePosition _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    cur <- allocMem :: IO (Ptr Int64)+    gst_query_parse_position _obj' format cur+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    cur' <- peek cur+    touchManagedPtr _obj+    freeMem format+    freeMem cur+    return (format'', cur')++data QueryParsePositionMethodInfo+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo QueryParsePositionMethodInfo Query signature where+    overloadedMethod _ = queryParsePosition++-- method Query::parse_scheduling+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SchedulingFlags", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minsize", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "align", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_scheduling" gst_query_parse_scheduling :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CUInt ->                            -- flags : TInterface "Gst" "SchedulingFlags"+    Ptr Int32 ->                            -- minsize : TBasicType TInt32+    Ptr Int32 ->                            -- maxsize : TBasicType TInt32+    Ptr Int32 ->                            -- align : TBasicType TInt32+    IO ()+++queryParseScheduling ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m ([SchedulingFlags],Int32,Int32,Int32)-- result+queryParseScheduling _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    flags <- allocMem :: IO (Ptr CUInt)+    minsize <- allocMem :: IO (Ptr Int32)+    maxsize <- allocMem :: IO (Ptr Int32)+    align <- allocMem :: IO (Ptr Int32)+    gst_query_parse_scheduling _obj' flags minsize maxsize align+    flags' <- peek flags+    let flags'' = wordToGFlags flags'+    minsize' <- peek minsize+    maxsize' <- peek maxsize+    align' <- peek align+    touchManagedPtr _obj+    freeMem flags+    freeMem minsize+    freeMem maxsize+    freeMem align+    return (flags'', minsize', maxsize', align')++data QueryParseSchedulingMethodInfo+instance (signature ~ (m ([SchedulingFlags],Int32,Int32,Int32)), MonadIO m) => MethodInfo QueryParseSchedulingMethodInfo Query signature where+    overloadedMethod _ = queryParseScheduling++-- method Query::parse_seeking+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "seekable", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "segment_start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "segment_end", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_seeking" gst_query_parse_seeking :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr CInt ->                             -- seekable : TBasicType TBoolean+    Ptr Int64 ->                            -- segment_start : TBasicType TInt64+    Ptr Int64 ->                            -- segment_end : TBasicType TInt64+    IO ()+++queryParseSeeking ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Format,Bool,Int64,Int64)          -- result+queryParseSeeking _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    format <- allocMem :: IO (Ptr CUInt)+    seekable <- allocMem :: IO (Ptr CInt)+    segmentStart <- allocMem :: IO (Ptr Int64)+    segmentEnd <- allocMem :: IO (Ptr Int64)+    gst_query_parse_seeking _obj' format seekable segmentStart segmentEnd+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    seekable' <- peek seekable+    let seekable'' = (/= 0) seekable'+    segmentStart' <- peek segmentStart+    segmentEnd' <- peek segmentEnd+    touchManagedPtr _obj+    freeMem format+    freeMem seekable+    freeMem segmentStart+    freeMem segmentEnd+    return (format'', seekable'', segmentStart', segmentEnd')++data QueryParseSeekingMethodInfo+instance (signature ~ (m (Format,Bool,Int64,Int64)), MonadIO m) => MethodInfo QueryParseSeekingMethodInfo Query signature where+    overloadedMethod _ = queryParseSeeking++-- method Query::parse_segment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_segment" gst_query_parse_segment :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CDouble ->                          -- rate : TBasicType TDouble+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"+    Ptr Int64 ->                            -- start_value : TBasicType TInt64+    Ptr Int64 ->                            -- stop_value : TBasicType TInt64+    IO ()+++queryParseSegment ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Double,Format,Int64,Int64)        -- result+queryParseSegment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    rate <- allocMem :: IO (Ptr CDouble)+    format <- allocMem :: IO (Ptr CUInt)+    startValue <- allocMem :: IO (Ptr Int64)+    stopValue <- allocMem :: IO (Ptr Int64)+    gst_query_parse_segment _obj' rate format startValue stopValue+    rate' <- peek rate+    let rate'' = realToFrac rate'+    format' <- peek format+    let format'' = (toEnum . fromIntegral) format'+    startValue' <- peek startValue+    stopValue' <- peek stopValue+    touchManagedPtr _obj+    freeMem rate+    freeMem format+    freeMem startValue+    freeMem stopValue+    return (rate'', format'', startValue', stopValue')++data QueryParseSegmentMethodInfo+instance (signature ~ (m (Double,Format,Int64,Int64)), MonadIO m) => MethodInfo QueryParseSegmentMethodInfo Query signature where+    overloadedMethod _ = queryParseSegment++-- method Query::parse_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_uri" gst_query_parse_uri :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CString ->                          -- uri : TBasicType TUTF8+    IO ()+++queryParseUri ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (T.Text)                           -- result+queryParseUri _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    uri <- allocMem :: IO (Ptr CString)+    gst_query_parse_uri _obj' uri+    uri' <- peek uri+    uri'' <- cstringToText uri'+    freeMem uri'+    touchManagedPtr _obj+    freeMem uri+    return uri''++data QueryParseUriMethodInfo+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo QueryParseUriMethodInfo Query signature where+    overloadedMethod _ = queryParseUri++-- method Query::parse_uri_redirection+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_uri_redirection" gst_query_parse_uri_redirection :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CString ->                          -- uri : TBasicType TUTF8+    IO ()+++queryParseUriRedirection ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (T.Text)                           -- result+queryParseUriRedirection _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    uri <- allocMem :: IO (Ptr CString)+    gst_query_parse_uri_redirection _obj' uri+    uri' <- peek uri+    uri'' <- cstringToText uri'+    freeMem uri'+    touchManagedPtr _obj+    freeMem uri+    return uri''++data QueryParseUriRedirectionMethodInfo+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo QueryParseUriRedirectionMethodInfo Query signature where+    overloadedMethod _ = queryParseUriRedirection++-- method Query::parse_uri_redirection_permanent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "permanent", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_parse_uri_redirection_permanent" gst_query_parse_uri_redirection_permanent :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr CInt ->                             -- permanent : TBasicType TBoolean+    IO ()+++queryParseUriRedirectionPermanent ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m (Bool)                             -- result+queryParseUriRedirectionPermanent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    permanent <- allocMem :: IO (Ptr CInt)+    gst_query_parse_uri_redirection_permanent _obj' permanent+    permanent' <- peek permanent+    let permanent'' = (/= 0) permanent'+    touchManagedPtr _obj+    freeMem permanent+    return permanent''++data QueryParseUriRedirectionPermanentMethodInfo+instance (signature ~ (m (Bool)), MonadIO m) => MethodInfo QueryParseUriRedirectionPermanentMethodInfo Query signature where+    overloadedMethod _ = queryParseUriRedirectionPermanent++-- method Query::remove_nth_allocation_meta+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_remove_nth_allocation_meta" gst_query_remove_nth_allocation_meta :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    IO ()+++queryRemoveNthAllocationMeta ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m ()                                 -- result+queryRemoveNthAllocationMeta _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_query_remove_nth_allocation_meta _obj' index+    touchManagedPtr _obj+    return ()++data QueryRemoveNthAllocationMetaMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo QueryRemoveNthAllocationMetaMethodInfo Query signature where+    overloadedMethod _ = queryRemoveNthAllocationMeta++-- method Query::remove_nth_allocation_param+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_remove_nth_allocation_param" gst_query_remove_nth_allocation_param :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    IO ()+++queryRemoveNthAllocationParam ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m ()                                 -- result+queryRemoveNthAllocationParam _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_query_remove_nth_allocation_param _obj' index+    touchManagedPtr _obj+    return ()++data QueryRemoveNthAllocationParamMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo QueryRemoveNthAllocationParamMethodInfo Query signature where+    overloadedMethod _ = queryRemoveNthAllocationParam++-- method Query::remove_nth_allocation_pool+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_remove_nth_allocation_pool" gst_query_remove_nth_allocation_pool :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    IO ()+++queryRemoveNthAllocationPool ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> m ()                                 -- result+queryRemoveNthAllocationPool _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_query_remove_nth_allocation_pool _obj' index+    touchManagedPtr _obj+    return ()++data QueryRemoveNthAllocationPoolMethodInfo+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo QueryRemoveNthAllocationPoolMethodInfo Query signature where+    overloadedMethod _ = queryRemoveNthAllocationPool++-- method Query::set_accept_caps_result+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_accept_caps_result" gst_query_set_accept_caps_result :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CInt ->                                 -- result : TBasicType TBoolean+    IO ()+++querySetAcceptCapsResult ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Bool                                 -- result_+    -> m ()                                 -- result+querySetAcceptCapsResult _obj result_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let result_' = (fromIntegral . fromEnum) result_+    gst_query_set_accept_caps_result _obj' result_'+    touchManagedPtr _obj+    return ()++data QuerySetAcceptCapsResultMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo QuerySetAcceptCapsResultMethodInfo Query signature where+    overloadedMethod _ = querySetAcceptCapsResult++-- method Query::set_buffering_percent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_buffering_percent" gst_query_set_buffering_percent :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CInt ->                                 -- busy : TBasicType TBoolean+    Int32 ->                                -- percent : TBasicType TInt32+    IO ()+++querySetBufferingPercent ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Bool                                 -- busy+    -> Int32                                -- percent+    -> m ()                                 -- result+querySetBufferingPercent _obj busy percent = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let busy' = (fromIntegral . fromEnum) busy+    gst_query_set_buffering_percent _obj' busy' percent+    touchManagedPtr _obj+    return ()++data QuerySetBufferingPercentMethodInfo+instance (signature ~ (Bool -> Int32 -> m ()), MonadIO m) => MethodInfo QuerySetBufferingPercentMethodInfo Query signature where+    overloadedMethod _ = querySetBufferingPercent++-- method Query::set_buffering_range+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "estimated_total", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_buffering_range" gst_query_set_buffering_range :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- start : TBasicType TInt64+    Int64 ->                                -- stop : TBasicType TInt64+    Int64 ->                                -- estimated_total : TBasicType TInt64+    IO ()+++querySetBufferingRange ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Format                               -- format+    -> Int64                                -- start+    -> Int64                                -- stop+    -> Int64                                -- estimatedTotal+    -> m ()                                 -- result+querySetBufferingRange _obj format start stop estimatedTotal = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_query_set_buffering_range _obj' format' start stop estimatedTotal+    touchManagedPtr _obj+    return ()++data QuerySetBufferingRangeMethodInfo+instance (signature ~ (Format -> Int64 -> Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetBufferingRangeMethodInfo Query signature where+    overloadedMethod _ = querySetBufferingRange++-- method Query::set_buffering_stats+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_buffering_stats" gst_query_set_buffering_stats :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- mode : TInterface "Gst" "BufferingMode"+    Int32 ->                                -- avg_in : TBasicType TInt32+    Int32 ->                                -- avg_out : TBasicType TInt32+    Int64 ->                                -- buffering_left : TBasicType TInt64+    IO ()+++querySetBufferingStats ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> BufferingMode                        -- mode+    -> Int32                                -- avgIn+    -> Int32                                -- avgOut+    -> Int64                                -- bufferingLeft+    -> m ()                                 -- result+querySetBufferingStats _obj mode avgIn avgOut bufferingLeft = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    gst_query_set_buffering_stats _obj' mode' avgIn avgOut bufferingLeft+    touchManagedPtr _obj+    return ()++data QuerySetBufferingStatsMethodInfo+instance (signature ~ (BufferingMode -> Int32 -> Int32 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetBufferingStatsMethodInfo Query signature where+    overloadedMethod _ = querySetBufferingStats++-- method Query::set_caps_result+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_caps_result" gst_query_set_caps_result :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO ()+++querySetCapsResult ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Caps                                 -- caps+    -> m ()                                 -- result+querySetCapsResult _obj caps = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    gst_query_set_caps_result _obj' caps'+    touchManagedPtr _obj+    touchManagedPtr caps+    return ()++data QuerySetCapsResultMethodInfo+instance (signature ~ (Caps -> m ()), MonadIO m) => MethodInfo QuerySetCapsResultMethodInfo Query signature where+    overloadedMethod _ = querySetCapsResult++-- method Query::set_context+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_context" gst_query_set_context :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Ptr Context ->                          -- context : TInterface "Gst" "Context"+    IO ()+++querySetContext ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Context                              -- context+    -> m ()                                 -- result+querySetContext _obj context = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let context' = unsafeManagedPtrGetPtr context+    gst_query_set_context _obj' context'+    touchManagedPtr _obj+    touchManagedPtr context+    return ()++data QuerySetContextMethodInfo+instance (signature ~ (Context -> m ()), MonadIO m) => MethodInfo QuerySetContextMethodInfo Query signature where+    overloadedMethod _ = querySetContext++-- method Query::set_convert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_convert" gst_query_set_convert :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- src_format : TInterface "Gst" "Format"+    Int64 ->                                -- src_value : TBasicType TInt64+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"+    Int64 ->                                -- dest_value : TBasicType TInt64+    IO ()+++querySetConvert ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Format                               -- srcFormat+    -> Int64                                -- srcValue+    -> Format                               -- destFormat+    -> Int64                                -- destValue+    -> m ()                                 -- result+querySetConvert _obj srcFormat srcValue destFormat destValue = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let srcFormat' = (fromIntegral . fromEnum) srcFormat+    let destFormat' = (fromIntegral . fromEnum) destFormat+    gst_query_set_convert _obj' srcFormat' srcValue destFormat' destValue+    touchManagedPtr _obj+    return ()++data QuerySetConvertMethodInfo+instance (signature ~ (Format -> Int64 -> Format -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetConvertMethodInfo Query signature where+    overloadedMethod _ = querySetConvert++-- method Query::set_duration+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_duration" gst_query_set_duration :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- duration : TBasicType TInt64+    IO ()+++querySetDuration ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Format                               -- format+    -> Int64                                -- duration+    -> m ()                                 -- result+querySetDuration _obj format duration = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_query_set_duration _obj' format' duration+    touchManagedPtr _obj+    return ()++data QuerySetDurationMethodInfo+instance (signature ~ (Format -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetDurationMethodInfo Query signature where+    overloadedMethod _ = querySetDuration++-- method Query::set_formatsv+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "formats", argType = TCArray False (-1) 1 (TInterface "Gst" "Format"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : [Arg {argCName = "n_formats", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_formatsv" gst_query_set_formatsv :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Int32 ->                                -- n_formats : TBasicType TInt32+    Ptr CUInt ->                            -- formats : TCArray False (-1) 1 (TInterface "Gst" "Format")+    IO ()+++querySetFormatsv ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> [Format]                             -- formats+    -> m ()                                 -- result+querySetFormatsv _obj formats = liftIO $ do+    let nFormats = fromIntegral $ length formats+    let _obj' = unsafeManagedPtrGetPtr _obj+    let formats' = map (fromIntegral . fromEnum) formats+    formats'' <- packStorableArray formats'+    gst_query_set_formatsv _obj' nFormats formats''+    touchManagedPtr _obj+    freeMem formats''+    return ()++data QuerySetFormatsvMethodInfo+instance (signature ~ ([Format] -> m ()), MonadIO m) => MethodInfo QuerySetFormatsvMethodInfo Query signature where+    overloadedMethod _ = querySetFormatsv++-- method Query::set_latency+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_latency" gst_query_set_latency :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CInt ->                                 -- live : TBasicType TBoolean+    Word64 ->                               -- min_latency : TBasicType TUInt64+    Word64 ->                               -- max_latency : TBasicType TUInt64+    IO ()+++querySetLatency ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Bool                                 -- live+    -> Word64                               -- minLatency+    -> Word64                               -- maxLatency+    -> m ()                                 -- result+querySetLatency _obj live minLatency maxLatency = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let live' = (fromIntegral . fromEnum) live+    gst_query_set_latency _obj' live' minLatency maxLatency+    touchManagedPtr _obj+    return ()++data QuerySetLatencyMethodInfo+instance (signature ~ (Bool -> Word64 -> Word64 -> m ()), MonadIO m) => MethodInfo QuerySetLatencyMethodInfo Query signature where+    overloadedMethod _ = querySetLatency++-- method Query::set_nth_allocation_param+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_nth_allocation_param" gst_query_set_nth_allocation_param :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"+    IO ()+++querySetNthAllocationParam ::+    (MonadIO m, AllocatorK a) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> Maybe (a)                            -- allocator+    -> Maybe (AllocationParams)             -- params+    -> m ()                                 -- result+querySetNthAllocationParam _obj index allocator params = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeAllocator <- case allocator of+        Nothing -> return nullPtr+        Just jAllocator -> do+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator+            return jAllocator'+    maybeParams <- case params of+        Nothing -> return nullPtr+        Just jParams -> do+            let jParams' = unsafeManagedPtrGetPtr jParams+            return jParams'+    gst_query_set_nth_allocation_param _obj' index maybeAllocator maybeParams+    touchManagedPtr _obj+    whenJust allocator touchManagedPtr+    whenJust params touchManagedPtr+    return ()++data QuerySetNthAllocationParamMethodInfo+instance (signature ~ (Word32 -> Maybe (a) -> Maybe (AllocationParams) -> m ()), MonadIO m, AllocatorK a) => MethodInfo QuerySetNthAllocationParamMethodInfo Query signature where+    overloadedMethod _ = querySetNthAllocationParam++-- method Query::set_nth_allocation_pool+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_nth_allocation_pool" gst_query_set_nth_allocation_pool :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr BufferPool ->                       -- pool : TInterface "Gst" "BufferPool"+    Word32 ->                               -- size : TBasicType TUInt32+    Word32 ->                               -- min_buffers : TBasicType TUInt32+    Word32 ->                               -- max_buffers : TBasicType TUInt32+    IO ()+++querySetNthAllocationPool ::+    (MonadIO m, BufferPoolK a) =>+    Query                                   -- _obj+    -> Word32                               -- index+    -> Maybe (a)                            -- pool+    -> Word32                               -- size+    -> Word32                               -- minBuffers+    -> Word32                               -- maxBuffers+    -> m ()                                 -- result+querySetNthAllocationPool _obj index pool size minBuffers maxBuffers = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybePool <- case pool of+        Nothing -> return nullPtr+        Just jPool -> do+            let jPool' = unsafeManagedPtrCastPtr jPool+            return jPool'+    gst_query_set_nth_allocation_pool _obj' index maybePool size minBuffers maxBuffers+    touchManagedPtr _obj+    whenJust pool touchManagedPtr+    return ()++data QuerySetNthAllocationPoolMethodInfo+instance (signature ~ (Word32 -> Maybe (a) -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, BufferPoolK a) => MethodInfo QuerySetNthAllocationPoolMethodInfo Query signature where+    overloadedMethod _ = querySetNthAllocationPool++-- method Query::set_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_position" gst_query_set_position :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- cur : TBasicType TInt64+    IO ()+++querySetPosition ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Format                               -- format+    -> Int64                                -- cur+    -> m ()                                 -- result+querySetPosition _obj format cur = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_query_set_position _obj' format' cur+    touchManagedPtr _obj+    return ()++data QuerySetPositionMethodInfo+instance (signature ~ (Format -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetPositionMethodInfo Query signature where+    overloadedMethod _ = querySetPosition++-- method Query::set_scheduling+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SchedulingFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minsize", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_scheduling" gst_query_set_scheduling :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- flags : TInterface "Gst" "SchedulingFlags"+    Int32 ->                                -- minsize : TBasicType TInt32+    Int32 ->                                -- maxsize : TBasicType TInt32+    Int32 ->                                -- align : TBasicType TInt32+    IO ()+++querySetScheduling ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> [SchedulingFlags]                    -- flags+    -> Int32                                -- minsize+    -> Int32                                -- maxsize+    -> Int32                                -- align+    -> m ()                                 -- result+querySetScheduling _obj flags minsize maxsize align = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let flags' = gflagsToWord flags+    gst_query_set_scheduling _obj' flags' minsize maxsize align+    touchManagedPtr _obj+    return ()++data QuerySetSchedulingMethodInfo+instance (signature ~ ([SchedulingFlags] -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m) => MethodInfo QuerySetSchedulingMethodInfo Query signature where+    overloadedMethod _ = querySetScheduling++-- method Query::set_seeking+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seekable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment_start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment_end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_seeking" gst_query_set_seeking :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    CInt ->                                 -- seekable : TBasicType TBoolean+    Int64 ->                                -- segment_start : TBasicType TInt64+    Int64 ->                                -- segment_end : TBasicType TInt64+    IO ()+++querySetSeeking ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Format                               -- format+    -> Bool                                 -- seekable+    -> Int64                                -- segmentStart+    -> Int64                                -- segmentEnd+    -> m ()                                 -- result+querySetSeeking _obj format seekable segmentStart segmentEnd = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    let seekable' = (fromIntegral . fromEnum) seekable+    gst_query_set_seeking _obj' format' seekable' segmentStart segmentEnd+    touchManagedPtr _obj+    return ()++data QuerySetSeekingMethodInfo+instance (signature ~ (Format -> Bool -> Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetSeekingMethodInfo Query signature where+    overloadedMethod _ = querySetSeeking++-- method Query::set_segment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_segment" gst_query_set_segment :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CDouble ->                              -- rate : TBasicType TDouble+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- start_value : TBasicType TInt64+    Int64 ->                                -- stop_value : TBasicType TInt64+    IO ()+++querySetSegment ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Double                               -- rate+    -> Format                               -- format+    -> Int64                                -- startValue+    -> Int64                                -- stopValue+    -> m ()                                 -- result+querySetSegment _obj rate format startValue stopValue = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let rate' = realToFrac rate+    let format' = (fromIntegral . fromEnum) format+    gst_query_set_segment _obj' rate' format' startValue stopValue+    touchManagedPtr _obj+    return ()++data QuerySetSegmentMethodInfo+instance (signature ~ (Double -> Format -> Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetSegmentMethodInfo Query signature where+    overloadedMethod _ = querySetSegment++-- method Query::set_uri+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_uri" gst_query_set_uri :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CString ->                              -- uri : TBasicType TUTF8+    IO ()+++querySetUri ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> T.Text                               -- uri+    -> m ()                                 -- result+querySetUri _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    uri' <- textToCString uri+    gst_query_set_uri _obj' uri'+    touchManagedPtr _obj+    freeMem uri'+    return ()++data QuerySetUriMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo QuerySetUriMethodInfo Query signature where+    overloadedMethod _ = querySetUri++-- method Query::set_uri_redirection+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_uri_redirection" gst_query_set_uri_redirection :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CString ->                              -- uri : TBasicType TUTF8+    IO ()+++querySetUriRedirection ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> T.Text                               -- uri+    -> m ()                                 -- result+querySetUriRedirection _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    uri' <- textToCString uri+    gst_query_set_uri_redirection _obj' uri'+    touchManagedPtr _obj+    freeMem uri'+    return ()++data QuerySetUriRedirectionMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo QuerySetUriRedirectionMethodInfo Query signature where+    overloadedMethod _ = querySetUriRedirection++-- method Query::set_uri_redirection_permanent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "permanent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_set_uri_redirection_permanent" gst_query_set_uri_redirection_permanent :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    CInt ->                                 -- permanent : TBasicType TBoolean+    IO ()+++querySetUriRedirectionPermanent ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> Bool                                 -- permanent+    -> m ()                                 -- result+querySetUriRedirectionPermanent _obj permanent = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let permanent' = (fromIntegral . fromEnum) permanent+    gst_query_set_uri_redirection_permanent _obj' permanent'+    touchManagedPtr _obj+    return ()++data QuerySetUriRedirectionPermanentMethodInfo+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo QuerySetUriRedirectionPermanentMethodInfo Query signature where+    overloadedMethod _ = querySetUriRedirectionPermanent++-- method Query::writable_structure+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_query_writable_structure" gst_query_writable_structure :: +    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"+    IO (Ptr Structure)+++queryWritableStructure ::+    (MonadIO m) =>+    Query                                   -- _obj+    -> m Structure                          -- result+queryWritableStructure _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_query_writable_structure _obj'+    checkUnexpectedReturnNULL "gst_query_writable_structure" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data QueryWritableStructureMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo QueryWritableStructureMethodInfo Query signature where+    overloadedMethod _ = queryWritableStructure++type family ResolveQueryMethod (t :: Symbol) (o :: *) :: * where+    ResolveQueryMethod "addAllocationMeta" o = QueryAddAllocationMetaMethodInfo+    ResolveQueryMethod "addAllocationParam" o = QueryAddAllocationParamMethodInfo+    ResolveQueryMethod "addAllocationPool" o = QueryAddAllocationPoolMethodInfo+    ResolveQueryMethod "addBufferingRange" o = QueryAddBufferingRangeMethodInfo+    ResolveQueryMethod "addSchedulingMode" o = QueryAddSchedulingModeMethodInfo+    ResolveQueryMethod "findAllocationMeta" o = QueryFindAllocationMetaMethodInfo+    ResolveQueryMethod "hasSchedulingMode" o = QueryHasSchedulingModeMethodInfo+    ResolveQueryMethod "hasSchedulingModeWithFlags" o = QueryHasSchedulingModeWithFlagsMethodInfo+    ResolveQueryMethod "parseAcceptCaps" o = QueryParseAcceptCapsMethodInfo+    ResolveQueryMethod "parseAcceptCapsResult" o = QueryParseAcceptCapsResultMethodInfo+    ResolveQueryMethod "parseAllocation" o = QueryParseAllocationMethodInfo+    ResolveQueryMethod "parseBufferingPercent" o = QueryParseBufferingPercentMethodInfo+    ResolveQueryMethod "parseBufferingRange" o = QueryParseBufferingRangeMethodInfo+    ResolveQueryMethod "parseBufferingStats" o = QueryParseBufferingStatsMethodInfo+    ResolveQueryMethod "parseCaps" o = QueryParseCapsMethodInfo+    ResolveQueryMethod "parseCapsResult" o = QueryParseCapsResultMethodInfo+    ResolveQueryMethod "parseContext" o = QueryParseContextMethodInfo+    ResolveQueryMethod "parseContextType" o = QueryParseContextTypeMethodInfo+    ResolveQueryMethod "parseConvert" o = QueryParseConvertMethodInfo+    ResolveQueryMethod "parseDuration" o = QueryParseDurationMethodInfo+    ResolveQueryMethod "parseLatency" o = QueryParseLatencyMethodInfo+    ResolveQueryMethod "parseNFormats" o = QueryParseNFormatsMethodInfo+    ResolveQueryMethod "parseNthAllocationMeta" o = QueryParseNthAllocationMetaMethodInfo+    ResolveQueryMethod "parseNthAllocationParam" o = QueryParseNthAllocationParamMethodInfo+    ResolveQueryMethod "parseNthAllocationPool" o = QueryParseNthAllocationPoolMethodInfo+    ResolveQueryMethod "parseNthBufferingRange" o = QueryParseNthBufferingRangeMethodInfo+    ResolveQueryMethod "parseNthFormat" o = QueryParseNthFormatMethodInfo+    ResolveQueryMethod "parseNthSchedulingMode" o = QueryParseNthSchedulingModeMethodInfo+    ResolveQueryMethod "parsePosition" o = QueryParsePositionMethodInfo+    ResolveQueryMethod "parseScheduling" o = QueryParseSchedulingMethodInfo+    ResolveQueryMethod "parseSeeking" o = QueryParseSeekingMethodInfo+    ResolveQueryMethod "parseSegment" o = QueryParseSegmentMethodInfo+    ResolveQueryMethod "parseUri" o = QueryParseUriMethodInfo+    ResolveQueryMethod "parseUriRedirection" o = QueryParseUriRedirectionMethodInfo+    ResolveQueryMethod "parseUriRedirectionPermanent" o = QueryParseUriRedirectionPermanentMethodInfo+    ResolveQueryMethod "removeNthAllocationMeta" o = QueryRemoveNthAllocationMetaMethodInfo+    ResolveQueryMethod "removeNthAllocationParam" o = QueryRemoveNthAllocationParamMethodInfo+    ResolveQueryMethod "removeNthAllocationPool" o = QueryRemoveNthAllocationPoolMethodInfo+    ResolveQueryMethod "writableStructure" o = QueryWritableStructureMethodInfo+    ResolveQueryMethod "getNAllocationMetas" o = QueryGetNAllocationMetasMethodInfo+    ResolveQueryMethod "getNAllocationParams" o = QueryGetNAllocationParamsMethodInfo+    ResolveQueryMethod "getNAllocationPools" o = QueryGetNAllocationPoolsMethodInfo+    ResolveQueryMethod "getNBufferingRanges" o = QueryGetNBufferingRangesMethodInfo+    ResolveQueryMethod "getNSchedulingModes" o = QueryGetNSchedulingModesMethodInfo+    ResolveQueryMethod "getStructure" o = QueryGetStructureMethodInfo+    ResolveQueryMethod "setAcceptCapsResult" o = QuerySetAcceptCapsResultMethodInfo+    ResolveQueryMethod "setBufferingPercent" o = QuerySetBufferingPercentMethodInfo+    ResolveQueryMethod "setBufferingRange" o = QuerySetBufferingRangeMethodInfo+    ResolveQueryMethod "setBufferingStats" o = QuerySetBufferingStatsMethodInfo+    ResolveQueryMethod "setCapsResult" o = QuerySetCapsResultMethodInfo+    ResolveQueryMethod "setContext" o = QuerySetContextMethodInfo+    ResolveQueryMethod "setConvert" o = QuerySetConvertMethodInfo+    ResolveQueryMethod "setDuration" o = QuerySetDurationMethodInfo+    ResolveQueryMethod "setFormatsv" o = QuerySetFormatsvMethodInfo+    ResolveQueryMethod "setLatency" o = QuerySetLatencyMethodInfo+    ResolveQueryMethod "setNthAllocationParam" o = QuerySetNthAllocationParamMethodInfo+    ResolveQueryMethod "setNthAllocationPool" o = QuerySetNthAllocationPoolMethodInfo+    ResolveQueryMethod "setPosition" o = QuerySetPositionMethodInfo+    ResolveQueryMethod "setScheduling" o = QuerySetSchedulingMethodInfo+    ResolveQueryMethod "setSeeking" o = QuerySetSeekingMethodInfo+    ResolveQueryMethod "setSegment" o = QuerySetSegmentMethodInfo+    ResolveQueryMethod "setUri" o = QuerySetUriMethodInfo+    ResolveQueryMethod "setUriRedirection" o = QuerySetUriRedirectionMethodInfo+    ResolveQueryMethod "setUriRedirectionPermanent" o = QuerySetUriRedirectionPermanentMethodInfo+    ResolveQueryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveQueryMethod t Query, MethodInfo info Query p) => IsLabelProxy t (Query -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveQueryMethod t Query, MethodInfo info Query p) => IsLabel t (Query -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Query.hs-boot view
@@ -0,0 +1,75 @@+module GI.Gst.Structs.Query 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++newtype Query = Query (ForeignPtr Query)+instance BoxedObject Query where+data QueryAddAllocationMetaMethodInfo+data QueryAddAllocationParamMethodInfo+data QueryAddAllocationPoolMethodInfo+data QueryAddBufferingRangeMethodInfo+data QueryAddSchedulingModeMethodInfo+data QueryFindAllocationMetaMethodInfo+data QueryGetNAllocationMetasMethodInfo+data QueryGetNAllocationParamsMethodInfo+data QueryGetNAllocationPoolsMethodInfo+data QueryGetNBufferingRangesMethodInfo+data QueryGetNSchedulingModesMethodInfo+data QueryGetStructureMethodInfo+data QueryHasSchedulingModeMethodInfo+data QueryHasSchedulingModeWithFlagsMethodInfo+data QueryParseAcceptCapsMethodInfo+data QueryParseAcceptCapsResultMethodInfo+data QueryParseAllocationMethodInfo+data QueryParseBufferingPercentMethodInfo+data QueryParseBufferingRangeMethodInfo+data QueryParseBufferingStatsMethodInfo+data QueryParseCapsMethodInfo+data QueryParseCapsResultMethodInfo+data QueryParseContextMethodInfo+data QueryParseContextTypeMethodInfo+data QueryParseConvertMethodInfo+data QueryParseDurationMethodInfo+data QueryParseLatencyMethodInfo+data QueryParseNFormatsMethodInfo+data QueryParseNthAllocationMetaMethodInfo+data QueryParseNthAllocationParamMethodInfo+data QueryParseNthAllocationPoolMethodInfo+data QueryParseNthBufferingRangeMethodInfo+data QueryParseNthFormatMethodInfo+data QueryParseNthSchedulingModeMethodInfo+data QueryParsePositionMethodInfo+data QueryParseSchedulingMethodInfo+data QueryParseSeekingMethodInfo+data QueryParseSegmentMethodInfo+data QueryParseUriMethodInfo+data QueryParseUriRedirectionMethodInfo+data QueryParseUriRedirectionPermanentMethodInfo+data QueryRemoveNthAllocationMetaMethodInfo+data QueryRemoveNthAllocationParamMethodInfo+data QueryRemoveNthAllocationPoolMethodInfo+data QuerySetAcceptCapsResultMethodInfo+data QuerySetBufferingPercentMethodInfo+data QuerySetBufferingRangeMethodInfo+data QuerySetBufferingStatsMethodInfo+data QuerySetCapsResultMethodInfo+data QuerySetContextMethodInfo+data QuerySetConvertMethodInfo+data QuerySetDurationMethodInfo+data QuerySetFormatsvMethodInfo+data QuerySetLatencyMethodInfo+data QuerySetNthAllocationParamMethodInfo+data QuerySetNthAllocationPoolMethodInfo+data QuerySetPositionMethodInfo+data QuerySetSchedulingMethodInfo+data QuerySetSeekingMethodInfo+data QuerySetSegmentMethodInfo+data QuerySetUriMethodInfo+data QuerySetUriRedirectionMethodInfo+data QuerySetUriRedirectionPermanentMethodInfo+data QueryWritableStructureMethodInfo
+ GI/Gst/Structs/Sample.hs view
@@ -0,0 +1,325 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #GstSample is a small object containing data, a type, timing and+extra arbitrary information.+-}++module GI.Gst.Structs.Sample+    ( ++-- * Exported types+    Sample(..)                              ,+    noSample                                ,+++ -- * Methods+-- ** sampleGetBuffer+    SampleGetBufferMethodInfo               ,+    sampleGetBuffer                         ,+++-- ** sampleGetBufferList+    SampleGetBufferListMethodInfo           ,+    sampleGetBufferList                     ,+++-- ** sampleGetCaps+    SampleGetCapsMethodInfo                 ,+    sampleGetCaps                           ,+++-- ** sampleGetInfo+    SampleGetInfoMethodInfo                 ,+    sampleGetInfo                           ,+++-- ** sampleGetSegment+    SampleGetSegmentMethodInfo              ,+    sampleGetSegment                        ,+++-- ** sampleNew+    sampleNew                               ,+++-- ** sampleSetBufferList+    SampleSetBufferListMethodInfo           ,+    sampleSetBufferList                     ,+++++    ) 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 GI.Gst.Callbacks++newtype Sample = Sample (ForeignPtr Sample)+foreign import ccall "gst_sample_get_type" c_gst_sample_get_type :: +    IO GType++instance BoxedObject Sample where+    boxedType _ = c_gst_sample_get_type++noSample :: Maybe Sample+noSample = Nothing++-- method Sample::new+-- method type : Constructor+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TInterface "Gst" "Sample"+-- throws : False+-- Skip return : False++foreign import ccall "gst_sample_new" gst_sample_new :: +    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"+    Ptr Structure ->                        -- info : TInterface "Gst" "Structure"+    IO (Ptr Sample)+++sampleNew ::+    (MonadIO m) =>+    Maybe (Buffer)                          -- buffer+    -> Maybe (Caps)                         -- caps+    -> Maybe (Segment)                      -- segment+    -> Maybe (Structure)                    -- info+    -> m Sample                             -- result+sampleNew buffer caps segment info = liftIO $ do+    maybeBuffer <- case buffer of+        Nothing -> return nullPtr+        Just jBuffer -> do+            let jBuffer' = unsafeManagedPtrGetPtr jBuffer+            return jBuffer'+    maybeCaps <- case caps of+        Nothing -> return nullPtr+        Just jCaps -> do+            let jCaps' = unsafeManagedPtrGetPtr jCaps+            return jCaps'+    maybeSegment <- case segment of+        Nothing -> return nullPtr+        Just jSegment -> do+            let jSegment' = unsafeManagedPtrGetPtr jSegment+            return jSegment'+    maybeInfo <- case info of+        Nothing -> return nullPtr+        Just jInfo -> do+            jInfo' <- copyBoxed jInfo+            return jInfo'+    result <- gst_sample_new maybeBuffer maybeCaps maybeSegment maybeInfo+    checkUnexpectedReturnNULL "gst_sample_new" result+    result' <- (wrapBoxed Sample) result+    whenJust buffer touchManagedPtr+    whenJust caps touchManagedPtr+    whenJust segment touchManagedPtr+    whenJust info touchManagedPtr+    return result'++-- method Sample::get_buffer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Buffer"+-- throws : False+-- Skip return : False++foreign import ccall "gst_sample_get_buffer" gst_sample_get_buffer :: +    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"+    IO (Ptr Buffer)+++sampleGetBuffer ::+    (MonadIO m) =>+    Sample                                  -- _obj+    -> m Buffer                             -- result+sampleGetBuffer _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_sample_get_buffer _obj'+    checkUnexpectedReturnNULL "gst_sample_get_buffer" result+    result' <- (newBoxed Buffer) result+    touchManagedPtr _obj+    return result'++data SampleGetBufferMethodInfo+instance (signature ~ (m Buffer), MonadIO m) => MethodInfo SampleGetBufferMethodInfo Sample signature where+    overloadedMethod _ = sampleGetBuffer++-- method Sample::get_buffer_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "BufferList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_sample_get_buffer_list" gst_sample_get_buffer_list :: +    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"+    IO (Ptr BufferList)+++sampleGetBufferList ::+    (MonadIO m) =>+    Sample                                  -- _obj+    -> m BufferList                         -- result+sampleGetBufferList _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_sample_get_buffer_list _obj'+    checkUnexpectedReturnNULL "gst_sample_get_buffer_list" result+    result' <- (newBoxed BufferList) result+    touchManagedPtr _obj+    return result'++data SampleGetBufferListMethodInfo+instance (signature ~ (m BufferList), MonadIO m) => MethodInfo SampleGetBufferListMethodInfo Sample signature where+    overloadedMethod _ = sampleGetBufferList++-- method Sample::get_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_sample_get_caps" gst_sample_get_caps :: +    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"+    IO (Ptr Caps)+++sampleGetCaps ::+    (MonadIO m) =>+    Sample                                  -- _obj+    -> m Caps                               -- result+sampleGetCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_sample_get_caps _obj'+    checkUnexpectedReturnNULL "gst_sample_get_caps" result+    result' <- (newBoxed Caps) result+    touchManagedPtr _obj+    return result'++data SampleGetCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m) => MethodInfo SampleGetCapsMethodInfo Sample signature where+    overloadedMethod _ = sampleGetCaps++-- method Sample::get_info+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_sample_get_info" gst_sample_get_info :: +    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"+    IO (Ptr Structure)+++sampleGetInfo ::+    (MonadIO m) =>+    Sample                                  -- _obj+    -> m Structure                          -- result+sampleGetInfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_sample_get_info _obj'+    checkUnexpectedReturnNULL "gst_sample_get_info" result+    result' <- (newBoxed Structure) result+    touchManagedPtr _obj+    return result'++data SampleGetInfoMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo SampleGetInfoMethodInfo Sample signature where+    overloadedMethod _ = sampleGetInfo++-- method Sample::get_segment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Segment"+-- throws : False+-- Skip return : False++foreign import ccall "gst_sample_get_segment" gst_sample_get_segment :: +    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"+    IO (Ptr Segment)+++sampleGetSegment ::+    (MonadIO m) =>+    Sample                                  -- _obj+    -> m Segment                            -- result+sampleGetSegment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_sample_get_segment _obj'+    checkUnexpectedReturnNULL "gst_sample_get_segment" result+    result' <- (newBoxed Segment) result+    touchManagedPtr _obj+    return result'++data SampleGetSegmentMethodInfo+instance (signature ~ (m Segment), MonadIO m) => MethodInfo SampleGetSegmentMethodInfo Sample signature where+    overloadedMethod _ = sampleGetSegment++-- method Sample::set_buffer_list+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer_list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_sample_set_buffer_list" gst_sample_set_buffer_list :: +    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"+    Ptr BufferList ->                       -- buffer_list : TInterface "Gst" "BufferList"+    IO ()+++sampleSetBufferList ::+    (MonadIO m) =>+    Sample                                  -- _obj+    -> BufferList                           -- bufferList+    -> m ()                                 -- result+sampleSetBufferList _obj bufferList = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let bufferList' = unsafeManagedPtrGetPtr bufferList+    gst_sample_set_buffer_list _obj' bufferList'+    touchManagedPtr _obj+    touchManagedPtr bufferList+    return ()++data SampleSetBufferListMethodInfo+instance (signature ~ (BufferList -> m ()), MonadIO m) => MethodInfo SampleSetBufferListMethodInfo Sample signature where+    overloadedMethod _ = sampleSetBufferList++type family ResolveSampleMethod (t :: Symbol) (o :: *) :: * where+    ResolveSampleMethod "getBuffer" o = SampleGetBufferMethodInfo+    ResolveSampleMethod "getBufferList" o = SampleGetBufferListMethodInfo+    ResolveSampleMethod "getCaps" o = SampleGetCapsMethodInfo+    ResolveSampleMethod "getInfo" o = SampleGetInfoMethodInfo+    ResolveSampleMethod "getSegment" o = SampleGetSegmentMethodInfo+    ResolveSampleMethod "setBufferList" o = SampleSetBufferListMethodInfo+    ResolveSampleMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveSampleMethod t Sample, MethodInfo info Sample p) => IsLabelProxy t (Sample -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveSampleMethod t Sample, MethodInfo info Sample p) => IsLabel t (Sample -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Sample.hs-boot view
@@ -0,0 +1,17 @@+module GI.Gst.Structs.Sample 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++newtype Sample = Sample (ForeignPtr Sample)+instance BoxedObject Sample where+data SampleGetBufferMethodInfo+data SampleGetBufferListMethodInfo+data SampleGetCapsMethodInfo+data SampleGetInfoMethodInfo+data SampleGetSegmentMethodInfo+data SampleSetBufferListMethodInfo
+ GI/Gst/Structs/Segment.hs view
@@ -0,0 +1,753 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++This helper structure holds the relevant values for tracking the region of+interest in a media file, called a segment.++The structure can be used for two purposes:+<itemizedlist>+  <listitem><para>performing seeks (handling seek events)</para></listitem>+  <listitem><para>tracking playback regions (handling newsegment events)</para></listitem>+</itemizedlist>++The segment is usually configured by the application with a seek event which+is propagated upstream and eventually handled by an element that performs the seek.++The configured segment is then propagated back downstream with a newsegment event.+This information is then used to clip media to the segment boundaries.++A segment structure is initialized with gst_segment_init(), which takes a #GstFormat+that will be used as the format of the segment values. The segment will be configured+with a start value of 0 and a stop/duration of -1, which is undefined. The default+rate and applied_rate is 1.0.++The public duration field contains the duration of the segment. When using+the segment for seeking, the start and time members should normally be left+to their default 0 value. The stop position is left to -1 unless explicitly+configured to a different value after a seek event.++The current position in the segment should be set by changing the position+member in the structure.++For elements that perform seeks, the current segment should be updated with the+gst_segment_do_seek() and the values from the seek event. This method will update+all the segment fields. The position field will contain the new playback position.+If the start_type was different from GST_SEEK_TYPE_NONE, playback continues from+the position position, possibly with updated flags or rate.++For elements that want to use #GstSegment to track the playback region,+update the segment fields with the information from the newsegment event.+The gst_segment_clip() method can be used to check and clip+the media data to the segment boundaries.++For elements that want to synchronize to the pipeline clock, gst_segment_to_running_time()+can be used to convert a timestamp to a value that can be used to synchronize+to the clock. This function takes into account the base as well as+any rate or applied_rate conversions.++For elements that need to perform operations on media data in stream_time,+gst_segment_to_stream_time() can be used to convert a timestamp and the segment+info to stream time (which is always between 0 and the duration of the stream).+-}++module GI.Gst.Structs.Segment+    ( ++-- * Exported types+    Segment(..)                             ,+    newZeroSegment                          ,+    noSegment                               ,+++ -- * Methods+-- ** segmentClip+    SegmentClipMethodInfo                   ,+    segmentClip                             ,+++-- ** segmentCopy+    SegmentCopyMethodInfo                   ,+    segmentCopy                             ,+++-- ** segmentCopyInto+    SegmentCopyIntoMethodInfo               ,+    segmentCopyInto                         ,+++-- ** segmentDoSeek+    SegmentDoSeekMethodInfo                 ,+    segmentDoSeek                           ,+++-- ** segmentFree+    SegmentFreeMethodInfo                   ,+    segmentFree                             ,+++-- ** segmentInit+    SegmentInitMethodInfo                   ,+    segmentInit                             ,+++-- ** segmentIsEqual+    SegmentIsEqualMethodInfo                ,+    segmentIsEqual                          ,+++-- ** segmentNew+    segmentNew                              ,+++-- ** segmentOffsetRunningTime+    SegmentOffsetRunningTimeMethodInfo      ,+    segmentOffsetRunningTime                ,+++-- ** segmentSetRunningTime+    SegmentSetRunningTimeMethodInfo         ,+    segmentSetRunningTime                   ,+++-- ** segmentToPosition+    SegmentToPositionMethodInfo             ,+    segmentToPosition                       ,+++-- ** segmentToRunningTime+    SegmentToRunningTimeMethodInfo          ,+    segmentToRunningTime                    ,+++-- ** segmentToRunningTimeFull+    SegmentToRunningTimeFullMethodInfo      ,+    segmentToRunningTimeFull                ,+++-- ** segmentToStreamTime+    SegmentToStreamTimeMethodInfo           ,+    segmentToStreamTime                     ,+++++ -- * Properties+-- ** AppliedRate+    segmentReadAppliedRate                  ,+++-- ** Base+    segmentReadBase                         ,+++-- ** Duration+    segmentReadDuration                     ,+++-- ** Flags+    segmentReadFlags                        ,+++-- ** Format+    segmentReadFormat                       ,+++-- ** Offset+    segmentReadOffset                       ,+++-- ** Position+    segmentReadPosition                     ,+++-- ** Rate+    segmentReadRate                         ,+++-- ** Start+    segmentReadStart                        ,+++-- ** Stop+    segmentReadStop                         ,+++-- ** Time+    segmentReadTime                         ,+++++    ) 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 GI.Gst.Callbacks++newtype Segment = Segment (ForeignPtr Segment)+foreign import ccall "gst_segment_get_type" c_gst_segment_get_type :: +    IO GType++instance BoxedObject Segment where+    boxedType _ = c_gst_segment_get_type++-- | Construct a `Segment` struct initialized to zero.+newZeroSegment :: MonadIO m => m Segment+newZeroSegment = liftIO $ callocBoxedBytes 120 >>= wrapBoxed Segment++noSegment :: Maybe Segment+noSegment = Nothing++segmentReadFlags :: Segment -> IO [SegmentFlags]+segmentReadFlags s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CUInt+    let val' = wordToGFlags val+    return val'++segmentReadRate :: Segment -> IO Double+segmentReadRate s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++segmentReadAppliedRate :: Segment -> IO Double+segmentReadAppliedRate s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO CDouble+    let val' = realToFrac val+    return val'++segmentReadFormat :: Segment -> IO Format+segmentReadFormat s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 24) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++segmentReadBase :: Segment -> IO Word64+segmentReadBase s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 32) :: IO Word64+    return val++segmentReadOffset :: Segment -> IO Word64+segmentReadOffset s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 40) :: IO Word64+    return val++segmentReadStart :: Segment -> IO Word64+segmentReadStart s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 48) :: IO Word64+    return val++segmentReadStop :: Segment -> IO Word64+segmentReadStop s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 56) :: IO Word64+    return val++segmentReadTime :: Segment -> IO Word64+segmentReadTime s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 64) :: IO Word64+    return val++segmentReadPosition :: Segment -> IO Word64+segmentReadPosition s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 72) :: IO Word64+    return val++segmentReadDuration :: Segment -> IO Word64+segmentReadDuration s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 80) :: IO Word64+    return val++-- method Segment::new+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "Segment"+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_new" gst_segment_new :: +    IO (Ptr Segment)+++segmentNew ::+    (MonadIO m) =>+    m Segment                               -- result+segmentNew  = liftIO $ do+    result <- gst_segment_new+    checkUnexpectedReturnNULL "gst_segment_new" result+    result' <- (wrapBoxed Segment) result+    return result'++-- method Segment::clip+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clip_start", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "clip_stop", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_clip" gst_segment_clip :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- start : TBasicType TUInt64+    Word64 ->                               -- stop : TBasicType TUInt64+    Ptr Word64 ->                           -- clip_start : TBasicType TUInt64+    Ptr Word64 ->                           -- clip_stop : TBasicType TUInt64+    IO CInt+++segmentClip ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> Word64                               -- start+    -> Word64                               -- stop+    -> m (Bool,Word64,Word64)               -- result+segmentClip _obj format start stop = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    clipStart <- allocMem :: IO (Ptr Word64)+    clipStop <- allocMem :: IO (Ptr Word64)+    result <- gst_segment_clip _obj' format' start stop clipStart clipStop+    let result' = (/= 0) result+    clipStart' <- peek clipStart+    clipStop' <- peek clipStop+    touchManagedPtr _obj+    freeMem clipStart+    freeMem clipStop+    return (result', clipStart', clipStop')++data SegmentClipMethodInfo+instance (signature ~ (Format -> Word64 -> Word64 -> m (Bool,Word64,Word64)), MonadIO m) => MethodInfo SegmentClipMethodInfo Segment signature where+    overloadedMethod _ = segmentClip++-- method Segment::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Segment"+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_copy" gst_segment_copy :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    IO (Ptr Segment)+++segmentCopy ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> m Segment                            -- result+segmentCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_segment_copy _obj'+    checkUnexpectedReturnNULL "gst_segment_copy" result+    result' <- (wrapBoxed Segment) result+    touchManagedPtr _obj+    return result'++data SegmentCopyMethodInfo+instance (signature ~ (m Segment), MonadIO m) => MethodInfo SegmentCopyMethodInfo Segment signature where+    overloadedMethod _ = segmentCopy++-- method Segment::copy_into+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_copy_into" gst_segment_copy_into :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    Ptr Segment ->                          -- dest : TInterface "Gst" "Segment"+    IO ()+++segmentCopyInto ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Segment                              -- dest+    -> m ()                                 -- result+segmentCopyInto _obj dest = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let dest' = unsafeManagedPtrGetPtr dest+    gst_segment_copy_into _obj' dest'+    touchManagedPtr _obj+    touchManagedPtr dest+    return ()++data SegmentCopyIntoMethodInfo+instance (signature ~ (Segment -> m ()), MonadIO m) => MethodInfo SegmentCopyIntoMethodInfo Segment signature where+    overloadedMethod _ = segmentCopyInto++-- method Segment::do_seek+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_do_seek" gst_segment_do_seek :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CDouble ->                              -- rate : TBasicType TDouble+    CUInt ->                                -- format : TInterface "Gst" "Format"+    CUInt ->                                -- flags : TInterface "Gst" "SeekFlags"+    CUInt ->                                -- start_type : TInterface "Gst" "SeekType"+    Word64 ->                               -- start : TBasicType TUInt64+    CUInt ->                                -- stop_type : TInterface "Gst" "SeekType"+    Word64 ->                               -- stop : TBasicType TUInt64+    CInt ->                                 -- update : TBasicType TBoolean+    IO CInt+++segmentDoSeek ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Double                               -- rate+    -> Format                               -- format+    -> [SeekFlags]                          -- flags+    -> SeekType                             -- startType+    -> Word64                               -- start+    -> SeekType                             -- stopType+    -> Word64                               -- stop+    -> Bool                                 -- update+    -> m Bool                               -- result+segmentDoSeek _obj rate format flags startType start stopType stop update = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let rate' = realToFrac rate+    let format' = (fromIntegral . fromEnum) format+    let flags' = gflagsToWord flags+    let startType' = (fromIntegral . fromEnum) startType+    let stopType' = (fromIntegral . fromEnum) stopType+    let update' = (fromIntegral . fromEnum) update+    result <- gst_segment_do_seek _obj' rate' format' flags' startType' start stopType' stop update'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data SegmentDoSeekMethodInfo+instance (signature ~ (Double -> Format -> [SeekFlags] -> SeekType -> Word64 -> SeekType -> Word64 -> Bool -> m Bool), MonadIO m) => MethodInfo SegmentDoSeekMethodInfo Segment signature where+    overloadedMethod _ = segmentDoSeek++-- method Segment::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_free" gst_segment_free :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    IO ()+++segmentFree ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> m ()                                 -- result+segmentFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_segment_free _obj'+    touchManagedPtr _obj+    return ()++data SegmentFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo SegmentFreeMethodInfo Segment signature where+    overloadedMethod _ = segmentFree++-- method Segment::init+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_init" gst_segment_init :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    IO ()+++segmentInit ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> m ()                                 -- result+segmentInit _obj format = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    gst_segment_init _obj' format'+    touchManagedPtr _obj+    return ()++data SegmentInitMethodInfo+instance (signature ~ (Format -> m ()), MonadIO m) => MethodInfo SegmentInitMethodInfo Segment signature where+    overloadedMethod _ = segmentInit++-- method Segment::is_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "s1", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_is_equal" gst_segment_is_equal :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    Ptr Segment ->                          -- s1 : TInterface "Gst" "Segment"+    IO CInt+++segmentIsEqual ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Segment                              -- s1+    -> m Bool                               -- result+segmentIsEqual _obj s1 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let s1' = unsafeManagedPtrGetPtr s1+    result <- gst_segment_is_equal _obj' s1'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr s1+    return result'++data SegmentIsEqualMethodInfo+instance (signature ~ (Segment -> m Bool), MonadIO m) => MethodInfo SegmentIsEqualMethodInfo Segment signature where+    overloadedMethod _ = segmentIsEqual++-- method Segment::offset_running_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_offset_running_time" gst_segment_offset_running_time :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Int64 ->                                -- offset : TBasicType TInt64+    IO CInt+++segmentOffsetRunningTime ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> Int64                                -- offset+    -> m Bool                               -- result+segmentOffsetRunningTime _obj format offset = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    result <- gst_segment_offset_running_time _obj' format' offset+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data SegmentOffsetRunningTimeMethodInfo+instance (signature ~ (Format -> Int64 -> m Bool), MonadIO m) => MethodInfo SegmentOffsetRunningTimeMethodInfo Segment signature where+    overloadedMethod _ = segmentOffsetRunningTime++-- method Segment::set_running_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_set_running_time" gst_segment_set_running_time :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- running_time : TBasicType TUInt64+    IO CInt+++segmentSetRunningTime ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> Word64                               -- runningTime+    -> m Bool                               -- result+segmentSetRunningTime _obj format runningTime = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    result <- gst_segment_set_running_time _obj' format' runningTime+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data SegmentSetRunningTimeMethodInfo+instance (signature ~ (Format -> Word64 -> m Bool), MonadIO m) => MethodInfo SegmentSetRunningTimeMethodInfo Segment signature where+    overloadedMethod _ = segmentSetRunningTime++-- method Segment::to_position+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_to_position" gst_segment_to_position :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- running_time : TBasicType TUInt64+    IO Word64+++segmentToPosition ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> Word64                               -- runningTime+    -> m Word64                             -- result+segmentToPosition _obj format runningTime = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    result <- gst_segment_to_position _obj' format' runningTime+    touchManagedPtr _obj+    return result++data SegmentToPositionMethodInfo+instance (signature ~ (Format -> Word64 -> m Word64), MonadIO m) => MethodInfo SegmentToPositionMethodInfo Segment signature where+    overloadedMethod _ = segmentToPosition++-- method Segment::to_running_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_to_running_time" gst_segment_to_running_time :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- position : TBasicType TUInt64+    IO Word64+++segmentToRunningTime ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> Word64                               -- position+    -> m Word64                             -- result+segmentToRunningTime _obj format position = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    result <- gst_segment_to_running_time _obj' format' position+    touchManagedPtr _obj+    return result++data SegmentToRunningTimeMethodInfo+instance (signature ~ (Format -> Word64 -> m Word64), MonadIO m) => MethodInfo SegmentToRunningTimeMethodInfo Segment signature where+    overloadedMethod _ = segmentToRunningTime++-- method Segment::to_running_time_full+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_to_running_time_full" gst_segment_to_running_time_full :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- position : TBasicType TUInt64+    Word64 ->                               -- running_time : TBasicType TUInt64+    IO Int32+++segmentToRunningTimeFull ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> Word64                               -- position+    -> Word64                               -- runningTime+    -> m Int32                              -- result+segmentToRunningTimeFull _obj format position runningTime = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    result <- gst_segment_to_running_time_full _obj' format' position runningTime+    touchManagedPtr _obj+    return result++data SegmentToRunningTimeFullMethodInfo+instance (signature ~ (Format -> Word64 -> Word64 -> m Int32), MonadIO m) => MethodInfo SegmentToRunningTimeFullMethodInfo Segment signature where+    overloadedMethod _ = segmentToRunningTimeFull++-- method Segment::to_stream_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_segment_to_stream_time" gst_segment_to_stream_time :: +    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"+    CUInt ->                                -- format : TInterface "Gst" "Format"+    Word64 ->                               -- position : TBasicType TUInt64+    IO Word64+++segmentToStreamTime ::+    (MonadIO m) =>+    Segment                                 -- _obj+    -> Format                               -- format+    -> Word64                               -- position+    -> m Word64                             -- result+segmentToStreamTime _obj format position = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let format' = (fromIntegral . fromEnum) format+    result <- gst_segment_to_stream_time _obj' format' position+    touchManagedPtr _obj+    return result++data SegmentToStreamTimeMethodInfo+instance (signature ~ (Format -> Word64 -> m Word64), MonadIO m) => MethodInfo SegmentToStreamTimeMethodInfo Segment signature where+    overloadedMethod _ = segmentToStreamTime++type family ResolveSegmentMethod (t :: Symbol) (o :: *) :: * where+    ResolveSegmentMethod "clip" o = SegmentClipMethodInfo+    ResolveSegmentMethod "copy" o = SegmentCopyMethodInfo+    ResolveSegmentMethod "copyInto" o = SegmentCopyIntoMethodInfo+    ResolveSegmentMethod "doSeek" o = SegmentDoSeekMethodInfo+    ResolveSegmentMethod "free" o = SegmentFreeMethodInfo+    ResolveSegmentMethod "init" o = SegmentInitMethodInfo+    ResolveSegmentMethod "isEqual" o = SegmentIsEqualMethodInfo+    ResolveSegmentMethod "offsetRunningTime" o = SegmentOffsetRunningTimeMethodInfo+    ResolveSegmentMethod "toPosition" o = SegmentToPositionMethodInfo+    ResolveSegmentMethod "toRunningTime" o = SegmentToRunningTimeMethodInfo+    ResolveSegmentMethod "toRunningTimeFull" o = SegmentToRunningTimeFullMethodInfo+    ResolveSegmentMethod "toStreamTime" o = SegmentToStreamTimeMethodInfo+    ResolveSegmentMethod "setRunningTime" o = SegmentSetRunningTimeMethodInfo+    ResolveSegmentMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveSegmentMethod t Segment, MethodInfo info Segment p) => IsLabelProxy t (Segment -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveSegmentMethod t Segment, MethodInfo info Segment p) => IsLabel t (Segment -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Segment.hs-boot view
@@ -0,0 +1,24 @@+module GI.Gst.Structs.Segment 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++newtype Segment = Segment (ForeignPtr Segment)+instance BoxedObject Segment where+data SegmentClipMethodInfo+data SegmentCopyMethodInfo+data SegmentCopyIntoMethodInfo+data SegmentDoSeekMethodInfo+data SegmentFreeMethodInfo+data SegmentInitMethodInfo+data SegmentIsEqualMethodInfo+data SegmentOffsetRunningTimeMethodInfo+data SegmentSetRunningTimeMethodInfo+data SegmentToPositionMethodInfo+data SegmentToRunningTimeMethodInfo+data SegmentToRunningTimeFullMethodInfo+data SegmentToStreamTimeMethodInfo
+ GI/Gst/Structs/StaticCaps.hs view
@@ -0,0 +1,147 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Datastructure to initialize #GstCaps from a string description usually+used in conjunction with GST_STATIC_CAPS() and gst_static_caps_get() to+instantiate a #GstCaps.+-}++module GI.Gst.Structs.StaticCaps+    ( ++-- * Exported types+    StaticCaps(..)                          ,+    newZeroStaticCaps                       ,+    noStaticCaps                            ,+++ -- * Methods+-- ** staticCapsCleanup+    StaticCapsCleanupMethodInfo             ,+    staticCapsCleanup                       ,+++-- ** staticCapsGet+    StaticCapsGetMethodInfo                 ,+    staticCapsGet                           ,+++++ -- * Properties+-- ** Caps+    staticCapsReadCaps                      ,+++-- ** String+    staticCapsReadString                    ,+++++    ) 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 GI.Gst.Callbacks++newtype StaticCaps = StaticCaps (ForeignPtr StaticCaps)+-- | Construct a `StaticCaps` struct initialized to zero.+newZeroStaticCaps :: MonadIO m => m StaticCaps+newZeroStaticCaps = liftIO $ callocBytes 48 >>= wrapPtr StaticCaps++noStaticCaps :: Maybe StaticCaps+noStaticCaps = Nothing++staticCapsReadCaps :: StaticCaps -> IO Caps+staticCapsReadCaps s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Caps)+    val' <- (newBoxed Caps) val+    return val'++staticCapsReadString :: StaticCaps -> IO T.Text+staticCapsReadString s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CString+    val' <- cstringToText val+    return val'++-- method StaticCaps::cleanup+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticCaps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_static_caps_cleanup" gst_static_caps_cleanup :: +    Ptr StaticCaps ->                       -- _obj : TInterface "Gst" "StaticCaps"+    IO ()+++staticCapsCleanup ::+    (MonadIO m) =>+    StaticCaps                              -- _obj+    -> m ()                                 -- result+staticCapsCleanup _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_static_caps_cleanup _obj'+    touchManagedPtr _obj+    return ()++data StaticCapsCleanupMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo StaticCapsCleanupMethodInfo StaticCaps signature where+    overloadedMethod _ = staticCapsCleanup++-- method StaticCaps::get+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticCaps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_static_caps_get" gst_static_caps_get :: +    Ptr StaticCaps ->                       -- _obj : TInterface "Gst" "StaticCaps"+    IO (Ptr Caps)+++staticCapsGet ::+    (MonadIO m) =>+    StaticCaps                              -- _obj+    -> m Caps                               -- result+staticCapsGet _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_static_caps_get _obj'+    checkUnexpectedReturnNULL "gst_static_caps_get" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data StaticCapsGetMethodInfo+instance (signature ~ (m Caps), MonadIO m) => MethodInfo StaticCapsGetMethodInfo StaticCaps signature where+    overloadedMethod _ = staticCapsGet++type family ResolveStaticCapsMethod (t :: Symbol) (o :: *) :: * where+    ResolveStaticCapsMethod "cleanup" o = StaticCapsCleanupMethodInfo+    ResolveStaticCapsMethod "get" o = StaticCapsGetMethodInfo+    ResolveStaticCapsMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveStaticCapsMethod t StaticCaps, MethodInfo info StaticCaps p) => IsLabelProxy t (StaticCaps -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveStaticCapsMethod t StaticCaps, MethodInfo info StaticCaps p) => IsLabel t (StaticCaps -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/StaticCaps.hs-boot view
@@ -0,0 +1,12 @@+module GI.Gst.Structs.StaticCaps 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++newtype StaticCaps = StaticCaps (ForeignPtr StaticCaps)+data StaticCapsCleanupMethodInfo+data StaticCapsGetMethodInfo
+ GI/Gst/Structs/StaticPadTemplate.hs view
@@ -0,0 +1,167 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure describing the #GstStaticPadTemplate.+-}++module GI.Gst.Structs.StaticPadTemplate+    ( ++-- * Exported types+    StaticPadTemplate(..)                   ,+    newZeroStaticPadTemplate                ,+    noStaticPadTemplate                     ,+++ -- * Methods+-- ** staticPadTemplateGet+    StaticPadTemplateGetMethodInfo          ,+    staticPadTemplateGet                    ,+++-- ** staticPadTemplateGetCaps+    StaticPadTemplateGetCapsMethodInfo      ,+    staticPadTemplateGetCaps                ,+++++ -- * Properties+-- ** Direction+    staticPadTemplateReadDirection          ,+++-- ** NameTemplate+    staticPadTemplateReadNameTemplate       ,+++-- ** Presence+    staticPadTemplateReadPresence           ,+++-- ** StaticCaps+    staticPadTemplateReadStaticCaps         ,+++++    ) 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 GI.Gst.Callbacks++newtype StaticPadTemplate = StaticPadTemplate (ForeignPtr StaticPadTemplate)+-- | Construct a `StaticPadTemplate` struct initialized to zero.+newZeroStaticPadTemplate :: MonadIO m => m StaticPadTemplate+newZeroStaticPadTemplate = liftIO $ callocBytes 64 >>= wrapPtr StaticPadTemplate++noStaticPadTemplate :: Maybe StaticPadTemplate+noStaticPadTemplate = Nothing++staticPadTemplateReadNameTemplate :: StaticPadTemplate -> IO T.Text+staticPadTemplateReadNameTemplate s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CString+    val' <- cstringToText val+    return val'++staticPadTemplateReadDirection :: StaticPadTemplate -> IO PadDirection+staticPadTemplateReadDirection s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++staticPadTemplateReadPresence :: StaticPadTemplate -> IO PadPresence+staticPadTemplateReadPresence s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 12) :: IO CUInt+    let val' = (toEnum . fromIntegral) val+    return val'++staticPadTemplateReadStaticCaps :: StaticPadTemplate -> IO StaticCaps+staticPadTemplateReadStaticCaps s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr StaticCaps)+    val' <- (newPtr 48 StaticCaps) val+    return val'++-- method StaticPadTemplate::get+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticPadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "PadTemplate"+-- throws : False+-- Skip return : False++foreign import ccall "gst_static_pad_template_get" gst_static_pad_template_get :: +    Ptr StaticPadTemplate ->                -- _obj : TInterface "Gst" "StaticPadTemplate"+    IO (Ptr PadTemplate)+++staticPadTemplateGet ::+    (MonadIO m) =>+    StaticPadTemplate                       -- _obj+    -> m PadTemplate                        -- result+staticPadTemplateGet _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_static_pad_template_get _obj'+    checkUnexpectedReturnNULL "gst_static_pad_template_get" result+    result' <- (wrapObject PadTemplate) result+    touchManagedPtr _obj+    return result'++data StaticPadTemplateGetMethodInfo+instance (signature ~ (m PadTemplate), MonadIO m) => MethodInfo StaticPadTemplateGetMethodInfo StaticPadTemplate signature where+    overloadedMethod _ = staticPadTemplateGet++-- method StaticPadTemplate::get_caps+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticPadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Caps"+-- throws : False+-- Skip return : False++foreign import ccall "gst_static_pad_template_get_caps" gst_static_pad_template_get_caps :: +    Ptr StaticPadTemplate ->                -- _obj : TInterface "Gst" "StaticPadTemplate"+    IO (Ptr Caps)+++staticPadTemplateGetCaps ::+    (MonadIO m) =>+    StaticPadTemplate                       -- _obj+    -> m Caps                               -- result+staticPadTemplateGetCaps _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_static_pad_template_get_caps _obj'+    checkUnexpectedReturnNULL "gst_static_pad_template_get_caps" result+    result' <- (wrapBoxed Caps) result+    touchManagedPtr _obj+    return result'++data StaticPadTemplateGetCapsMethodInfo+instance (signature ~ (m Caps), MonadIO m) => MethodInfo StaticPadTemplateGetCapsMethodInfo StaticPadTemplate signature where+    overloadedMethod _ = staticPadTemplateGetCaps++type family ResolveStaticPadTemplateMethod (t :: Symbol) (o :: *) :: * where+    ResolveStaticPadTemplateMethod "get" o = StaticPadTemplateGetMethodInfo+    ResolveStaticPadTemplateMethod "getCaps" o = StaticPadTemplateGetCapsMethodInfo+    ResolveStaticPadTemplateMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, MethodInfo info StaticPadTemplate p) => IsLabelProxy t (StaticPadTemplate -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, MethodInfo info StaticPadTemplate p) => IsLabel t (StaticPadTemplate -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/StaticPadTemplate.hs-boot view
@@ -0,0 +1,12 @@+module GI.Gst.Structs.StaticPadTemplate 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++newtype StaticPadTemplate = StaticPadTemplate (ForeignPtr StaticPadTemplate)+data StaticPadTemplateGetMethodInfo+data StaticPadTemplateGetCapsMethodInfo
+ GI/Gst/Structs/Structure.hs view
@@ -0,0 +1,2182 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #GstStructure is a collection of key/value pairs. The keys are expressed+as GQuarks and the values can be of any GType.++In addition to the key/value pairs, a #GstStructure also has a name. The name+starts with a letter and can be filled by letters, numbers and any of "/-_.:".++#GstStructure is used by various GStreamer subsystems to store information+in a flexible and extensible way. A #GstStructure does not have a refcount+because it usually is part of a higher level object such as #GstCaps,+#GstMessage, #GstEvent, #GstQuery. It provides a means to enforce mutability+using the refcount of the parent with the gst_structure_set_parent_refcount()+method.++A #GstStructure can be created with gst_structure_new_empty() or+gst_structure_new(), which both take a name and an optional set of+key/value pairs along with the types of the values.++Field values can be changed with gst_structure_set_value() or+gst_structure_set().++Field values can be retrieved with gst_structure_get_value() or the more+convenient gst_structure_get_*() functions.++Fields can be removed with gst_structure_remove_field() or+gst_structure_remove_fields().++Strings in structures must be ASCII or UTF-8 encoded. Other encodings are+not allowed. Strings may be %NULL however.++Be aware that the current #GstCaps / #GstStructure serialization into string+has limited support for nested #GstCaps / #GstStructure fields. It can only+support one level of nesting. Using more levels will lead to unexpected+behavior when using serialization features, such as gst_caps_to_string() or+gst_value_serialize() and their counterparts.+-}++module GI.Gst.Structs.Structure+    ( ++-- * Exported types+    Structure(..)                           ,+    newZeroStructure                        ,+    noStructure                             ,+++ -- * Methods+-- ** structureCanIntersect+    StructureCanIntersectMethodInfo         ,+    structureCanIntersect                   ,+++-- ** structureCopy+    StructureCopyMethodInfo                 ,+    structureCopy                           ,+++-- ** structureFilterAndMapInPlace+    StructureFilterAndMapInPlaceMethodInfo  ,+    structureFilterAndMapInPlace            ,+++-- ** structureFixate+    StructureFixateMethodInfo               ,+    structureFixate                         ,+++-- ** structureFixateField+    StructureFixateFieldMethodInfo          ,+    structureFixateField                    ,+++-- ** structureFixateFieldBoolean+    StructureFixateFieldBooleanMethodInfo   ,+    structureFixateFieldBoolean             ,+++-- ** structureFixateFieldNearestDouble+    StructureFixateFieldNearestDoubleMethodInfo,+    structureFixateFieldNearestDouble       ,+++-- ** structureFixateFieldNearestFraction+    StructureFixateFieldNearestFractionMethodInfo,+    structureFixateFieldNearestFraction     ,+++-- ** structureFixateFieldNearestInt+    StructureFixateFieldNearestIntMethodInfo,+    structureFixateFieldNearestInt          ,+++-- ** structureFixateFieldString+    StructureFixateFieldStringMethodInfo    ,+    structureFixateFieldString              ,+++-- ** structureForeach+    StructureForeachMethodInfo              ,+    structureForeach                        ,+++-- ** structureFree+    StructureFreeMethodInfo                 ,+    structureFree                           ,+++-- ** structureFromString+    structureFromString                     ,+++-- ** structureGetBoolean+    StructureGetBooleanMethodInfo           ,+    structureGetBoolean                     ,+++-- ** structureGetClockTime+    StructureGetClockTimeMethodInfo         ,+    structureGetClockTime                   ,+++-- ** structureGetDate+    StructureGetDateMethodInfo              ,+    structureGetDate                        ,+++-- ** structureGetDateTime+    StructureGetDateTimeMethodInfo          ,+    structureGetDateTime                    ,+++-- ** structureGetDouble+    StructureGetDoubleMethodInfo            ,+    structureGetDouble                      ,+++-- ** structureGetEnum+    StructureGetEnumMethodInfo              ,+    structureGetEnum                        ,+++-- ** structureGetFieldType+    StructureGetFieldTypeMethodInfo         ,+    structureGetFieldType                   ,+++-- ** structureGetFlagset+    StructureGetFlagsetMethodInfo           ,+    structureGetFlagset                     ,+++-- ** structureGetFraction+    StructureGetFractionMethodInfo          ,+    structureGetFraction                    ,+++-- ** structureGetInt+    StructureGetIntMethodInfo               ,+    structureGetInt                         ,+++-- ** structureGetInt64+    StructureGetInt64MethodInfo             ,+    structureGetInt64                       ,+++-- ** structureGetName+    StructureGetNameMethodInfo              ,+    structureGetName                        ,+++-- ** structureGetNameId+    StructureGetNameIdMethodInfo            ,+    structureGetNameId                      ,+++-- ** structureGetString+    StructureGetStringMethodInfo            ,+    structureGetString                      ,+++-- ** structureGetUint+    StructureGetUintMethodInfo              ,+    structureGetUint                        ,+++-- ** structureGetUint64+    StructureGetUint64MethodInfo            ,+    structureGetUint64                      ,+++-- ** structureGetValue+    StructureGetValueMethodInfo             ,+    structureGetValue                       ,+++-- ** structureHasField+    StructureHasFieldMethodInfo             ,+    structureHasField                       ,+++-- ** structureHasFieldTyped+    StructureHasFieldTypedMethodInfo        ,+    structureHasFieldTyped                  ,+++-- ** structureHasName+    StructureHasNameMethodInfo              ,+    structureHasName                        ,+++-- ** structureIdGetValue+    StructureIdGetValueMethodInfo           ,+    structureIdGetValue                     ,+++-- ** structureIdHasField+    StructureIdHasFieldMethodInfo           ,+    structureIdHasField                     ,+++-- ** structureIdHasFieldTyped+    StructureIdHasFieldTypedMethodInfo      ,+    structureIdHasFieldTyped                ,+++-- ** structureIdSetValue+    StructureIdSetValueMethodInfo           ,+    structureIdSetValue                     ,+++-- ** structureIdTakeValue+    StructureIdTakeValueMethodInfo          ,+    structureIdTakeValue                    ,+++-- ** structureIntersect+    StructureIntersectMethodInfo            ,+    structureIntersect                      ,+++-- ** structureIsEqual+    StructureIsEqualMethodInfo              ,+    structureIsEqual                        ,+++-- ** structureIsSubset+    StructureIsSubsetMethodInfo             ,+    structureIsSubset                       ,+++-- ** structureMapInPlace+    StructureMapInPlaceMethodInfo           ,+    structureMapInPlace                     ,+++-- ** structureNFields+    StructureNFieldsMethodInfo              ,+    structureNFields                        ,+++-- ** structureNewEmpty+    structureNewEmpty                       ,+++-- ** structureNewFromString+    structureNewFromString                  ,+++-- ** structureNewIdEmpty+    structureNewIdEmpty                     ,+++-- ** structureNthFieldName+    StructureNthFieldNameMethodInfo         ,+    structureNthFieldName                   ,+++-- ** structureRemoveAllFields+    StructureRemoveAllFieldsMethodInfo      ,+    structureRemoveAllFields                ,+++-- ** structureRemoveField+    StructureRemoveFieldMethodInfo          ,+    structureRemoveField                    ,+++-- ** structureSetName+    StructureSetNameMethodInfo              ,+    structureSetName                        ,+++-- ** structureSetParentRefcount+    StructureSetParentRefcountMethodInfo    ,+    structureSetParentRefcount              ,+++-- ** structureSetValue+    StructureSetValueMethodInfo             ,+    structureSetValue                       ,+++-- ** structureTakeValue+    StructureTakeValueMethodInfo            ,+    structureTakeValue                      ,+++-- ** structureToString+    StructureToStringMethodInfo             ,+    structureToString                       ,+++++ -- * Properties+-- ** Type+    structureReadType                       ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype Structure = Structure (ForeignPtr Structure)+foreign import ccall "gst_structure_get_type" c_gst_structure_get_type :: +    IO GType++instance BoxedObject Structure where+    boxedType _ = c_gst_structure_get_type++-- | Construct a `Structure` struct initialized to zero.+newZeroStructure :: MonadIO m => m Structure+newZeroStructure = liftIO $ callocBoxedBytes 16 >>= wrapBoxed Structure++noStructure :: Maybe Structure+noStructure = Nothing++structureReadType :: Structure -> IO GType+structureReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CGType+    let val' = GType val+    return val'++-- method Structure::new_empty+-- method type : Constructor+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_new_empty" gst_structure_new_empty :: +    CString ->                              -- name : TBasicType TUTF8+    IO (Ptr Structure)+++structureNewEmpty ::+    (MonadIO m) =>+    T.Text                                  -- name+    -> m Structure                          -- result+structureNewEmpty name = liftIO $ do+    name' <- textToCString name+    result <- gst_structure_new_empty name'+    checkUnexpectedReturnNULL "gst_structure_new_empty" result+    result' <- (wrapBoxed Structure) result+    freeMem name'+    return result'++-- method Structure::new_from_string+-- method type : Constructor+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_new_from_string" gst_structure_new_from_string :: +    CString ->                              -- string : TBasicType TUTF8+    IO (Ptr Structure)+++structureNewFromString ::+    (MonadIO m) =>+    T.Text                                  -- string+    -> m Structure                          -- result+structureNewFromString string = liftIO $ do+    string' <- textToCString string+    result <- gst_structure_new_from_string string'+    checkUnexpectedReturnNULL "gst_structure_new_from_string" result+    result' <- (wrapBoxed Structure) result+    freeMem string'+    return result'++-- method Structure::new_id_empty+-- method type : Constructor+-- Args : [Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_new_id_empty" gst_structure_new_id_empty :: +    Word32 ->                               -- quark : TBasicType TUInt32+    IO (Ptr Structure)+++structureNewIdEmpty ::+    (MonadIO m) =>+    Word32                                  -- quark+    -> m Structure                          -- result+structureNewIdEmpty quark = liftIO $ do+    result <- gst_structure_new_id_empty quark+    checkUnexpectedReturnNULL "gst_structure_new_id_empty" result+    result' <- (wrapBoxed Structure) result+    return result'++-- method Structure::can_intersect+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "struct2", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_can_intersect" gst_structure_can_intersect :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Ptr Structure ->                        -- struct2 : TInterface "Gst" "Structure"+    IO CInt+++structureCanIntersect ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Structure                            -- struct2+    -> m Bool                               -- result+structureCanIntersect _obj struct2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let struct2' = unsafeManagedPtrGetPtr struct2+    result <- gst_structure_can_intersect _obj' struct2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr struct2+    return result'++data StructureCanIntersectMethodInfo+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo StructureCanIntersectMethodInfo Structure signature where+    overloadedMethod _ = structureCanIntersect++-- method Structure::copy+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_copy" gst_structure_copy :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO (Ptr Structure)+++structureCopy ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m Structure                          -- result+structureCopy _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_copy _obj'+    checkUnexpectedReturnNULL "gst_structure_copy" result+    result' <- (wrapBoxed Structure) result+    touchManagedPtr _obj+    return result'++data StructureCopyMethodInfo+instance (signature ~ (m Structure), MonadIO m) => MethodInfo StructureCopyMethodInfo Structure signature where+    overloadedMethod _ = structureCopy++-- method Structure::filter_and_map_in_place+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "StructureFilterMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_filter_and_map_in_place" gst_structure_filter_and_map_in_place :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    FunPtr StructureFilterMapFuncC ->       -- func : TInterface "Gst" "StructureFilterMapFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++structureFilterAndMapInPlace ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> StructureFilterMapFunc               -- func+    -> m ()                                 -- result+structureFilterAndMapInPlace _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkStructureFilterMapFunc (structureFilterMapFuncWrapper Nothing func)+    let userData = nullPtr+    gst_structure_filter_and_map_in_place _obj' func' userData+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++data StructureFilterAndMapInPlaceMethodInfo+instance (signature ~ (StructureFilterMapFunc -> m ()), MonadIO m) => MethodInfo StructureFilterAndMapInPlaceMethodInfo Structure signature where+    overloadedMethod _ = structureFilterAndMapInPlace++-- method Structure::fixate+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_fixate" gst_structure_fixate :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO ()+++structureFixate ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m ()                                 -- result+structureFixate _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_structure_fixate _obj'+    touchManagedPtr _obj+    return ()++data StructureFixateMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo StructureFixateMethodInfo Structure signature where+    overloadedMethod _ = structureFixate++-- method Structure::fixate_field+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_fixate_field" gst_structure_fixate_field :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- field_name : TBasicType TUTF8+    IO CInt+++structureFixateField ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldName+    -> m Bool                               -- result+structureFixateField _obj fieldName = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldName' <- textToCString fieldName+    result <- gst_structure_fixate_field _obj' fieldName'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldName'+    return result'++data StructureFixateFieldMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldMethodInfo Structure signature where+    overloadedMethod _ = structureFixateField++-- method Structure::fixate_field_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_fixate_field_boolean" gst_structure_fixate_field_boolean :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- field_name : TBasicType TUTF8+    CInt ->                                 -- target : TBasicType TBoolean+    IO CInt+++structureFixateFieldBoolean ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldName+    -> Bool                                 -- target+    -> m Bool                               -- result+structureFixateFieldBoolean _obj fieldName target = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldName' <- textToCString fieldName+    let target' = (fromIntegral . fromEnum) target+    result <- gst_structure_fixate_field_boolean _obj' fieldName' target'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldName'+    return result'++data StructureFixateFieldBooleanMethodInfo+instance (signature ~ (T.Text -> Bool -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldBooleanMethodInfo Structure signature where+    overloadedMethod _ = structureFixateFieldBoolean++-- method Structure::fixate_field_nearest_double+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_fixate_field_nearest_double" gst_structure_fixate_field_nearest_double :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- field_name : TBasicType TUTF8+    CDouble ->                              -- target : TBasicType TDouble+    IO CInt+++structureFixateFieldNearestDouble ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldName+    -> Double                               -- target+    -> m Bool                               -- result+structureFixateFieldNearestDouble _obj fieldName target = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldName' <- textToCString fieldName+    let target' = realToFrac target+    result <- gst_structure_fixate_field_nearest_double _obj' fieldName' target'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldName'+    return result'++data StructureFixateFieldNearestDoubleMethodInfo+instance (signature ~ (T.Text -> Double -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldNearestDoubleMethodInfo Structure signature where+    overloadedMethod _ = structureFixateFieldNearestDouble++-- method Structure::fixate_field_nearest_fraction+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_numerator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_denominator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_fixate_field_nearest_fraction" gst_structure_fixate_field_nearest_fraction :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- field_name : TBasicType TUTF8+    Int32 ->                                -- target_numerator : TBasicType TInt32+    Int32 ->                                -- target_denominator : TBasicType TInt32+    IO CInt+++structureFixateFieldNearestFraction ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldName+    -> Int32                                -- targetNumerator+    -> Int32                                -- targetDenominator+    -> m Bool                               -- result+structureFixateFieldNearestFraction _obj fieldName targetNumerator targetDenominator = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldName' <- textToCString fieldName+    result <- gst_structure_fixate_field_nearest_fraction _obj' fieldName' targetNumerator targetDenominator+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldName'+    return result'++data StructureFixateFieldNearestFractionMethodInfo+instance (signature ~ (T.Text -> Int32 -> Int32 -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldNearestFractionMethodInfo Structure signature where+    overloadedMethod _ = structureFixateFieldNearestFraction++-- method Structure::fixate_field_nearest_int+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_fixate_field_nearest_int" gst_structure_fixate_field_nearest_int :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- field_name : TBasicType TUTF8+    Int32 ->                                -- target : TBasicType TInt32+    IO CInt+++structureFixateFieldNearestInt ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldName+    -> Int32                                -- target+    -> m Bool                               -- result+structureFixateFieldNearestInt _obj fieldName target = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldName' <- textToCString fieldName+    result <- gst_structure_fixate_field_nearest_int _obj' fieldName' target+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldName'+    return result'++data StructureFixateFieldNearestIntMethodInfo+instance (signature ~ (T.Text -> Int32 -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldNearestIntMethodInfo Structure signature where+    overloadedMethod _ = structureFixateFieldNearestInt++-- method Structure::fixate_field_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_fixate_field_string" gst_structure_fixate_field_string :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- field_name : TBasicType TUTF8+    CString ->                              -- target : TBasicType TUTF8+    IO CInt+++structureFixateFieldString ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldName+    -> T.Text                               -- target+    -> m Bool                               -- result+structureFixateFieldString _obj fieldName target = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldName' <- textToCString fieldName+    target' <- textToCString target+    result <- gst_structure_fixate_field_string _obj' fieldName' target'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldName'+    freeMem target'+    return result'++data StructureFixateFieldStringMethodInfo+instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldStringMethodInfo Structure signature where+    overloadedMethod _ = structureFixateFieldString++-- method Structure::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "StructureForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_foreach" gst_structure_foreach :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    FunPtr StructureForeachFuncC ->         -- func : TInterface "Gst" "StructureForeachFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++structureForeach ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> StructureForeachFunc                 -- func+    -> m Bool                               -- result+structureForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkStructureForeachFunc (structureForeachFuncWrapper Nothing func)+    let userData = nullPtr+    result <- gst_structure_foreach _obj' func' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return result'++data StructureForeachMethodInfo+instance (signature ~ (StructureForeachFunc -> m Bool), MonadIO m) => MethodInfo StructureForeachMethodInfo Structure signature where+    overloadedMethod _ = structureForeach++-- method Structure::free+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_free" gst_structure_free :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO ()+++structureFree ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m ()                                 -- result+structureFree _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_structure_free _obj'+    touchManagedPtr _obj+    return ()++data StructureFreeMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo StructureFreeMethodInfo Structure signature where+    overloadedMethod _ = structureFree++-- method Structure::get_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_boolean" gst_structure_get_boolean :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr CInt ->                             -- value : TBasicType TBoolean+    IO CInt+++structureGetBoolean ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Bool)                        -- result+structureGetBoolean _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr CInt)+    result <- gst_structure_get_boolean _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = (/= 0) value'+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value'')++data StructureGetBooleanMethodInfo+instance (signature ~ (T.Text -> m (Bool,Bool)), MonadIO m) => MethodInfo StructureGetBooleanMethodInfo Structure signature where+    overloadedMethod _ = structureGetBoolean++-- method Structure::get_clock_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_clock_time" gst_structure_get_clock_time :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr Word64 ->                           -- value : TBasicType TUInt64+    IO CInt+++structureGetClockTime ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Word64)                      -- result+structureGetClockTime _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr Word64)+    result <- gst_structure_get_clock_time _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value')++data StructureGetClockTimeMethodInfo+instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => MethodInfo StructureGetClockTimeMethodInfo Structure signature where+    overloadedMethod _ = structureGetClockTime++-- method Structure::get_date+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GLib" "Date", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_date" gst_structure_get_date :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr GLib.Date ->                        -- value : TInterface "GLib" "Date"+    IO CInt+++structureGetDate ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,GLib.Date)                   -- result+structureGetDate _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- callocBoxedBytes 24 :: IO (Ptr GLib.Date)+    result <- gst_structure_get_date _obj' fieldname' value+    let result' = (/= 0) result+    value' <- (wrapBoxed GLib.Date) value+    touchManagedPtr _obj+    freeMem fieldname'+    return (result', value')++data StructureGetDateMethodInfo+instance (signature ~ (T.Text -> m (Bool,GLib.Date)), MonadIO m) => MethodInfo StructureGetDateMethodInfo Structure signature where+    overloadedMethod _ = structureGetDate++-- method Structure::get_date_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "Gst" "DateTime", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_date_time" gst_structure_get_date_time :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr (Ptr DateTime) ->                   -- value : TInterface "Gst" "DateTime"+    IO CInt+++structureGetDateTime ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,DateTime)                    -- result+structureGetDateTime _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr (Ptr DateTime))+    result <- gst_structure_get_date_time _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- (wrapBoxed DateTime) value'+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value'')++data StructureGetDateTimeMethodInfo+instance (signature ~ (T.Text -> m (Bool,DateTime)), MonadIO m) => MethodInfo StructureGetDateTimeMethodInfo Structure signature where+    overloadedMethod _ = structureGetDateTime++-- method Structure::get_double+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_double" gst_structure_get_double :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr CDouble ->                          -- value : TBasicType TDouble+    IO CInt+++structureGetDouble ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Double)                      -- result+structureGetDouble _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr CDouble)+    result <- gst_structure_get_double _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = realToFrac value'+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value'')++data StructureGetDoubleMethodInfo+instance (signature ~ (T.Text -> m (Bool,Double)), MonadIO m) => MethodInfo StructureGetDoubleMethodInfo Structure signature where+    overloadedMethod _ = structureGetDouble++-- method Structure::get_enum+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enumtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_enum" gst_structure_get_enum :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    CGType ->                               -- enumtype : TBasicType TGType+    Ptr Int32 ->                            -- value : TBasicType TInt32+    IO CInt+++structureGetEnum ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> GType                                -- enumtype+    -> m (Bool,Int32)                       -- result+structureGetEnum _obj fieldname enumtype = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    let enumtype' = gtypeToCGType enumtype+    value <- allocMem :: IO (Ptr Int32)+    result <- gst_structure_get_enum _obj' fieldname' enumtype' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value')++data StructureGetEnumMethodInfo+instance (signature ~ (T.Text -> GType -> m (Bool,Int32)), MonadIO m) => MethodInfo StructureGetEnumMethodInfo Structure signature where+    overloadedMethod _ = structureGetEnum++-- method Structure::get_field_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TGType+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_field_type" gst_structure_get_field_type :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    IO CGType+++structureGetFieldType ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m GType                              -- result+structureGetFieldType _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    result <- gst_structure_get_field_type _obj' fieldname'+    let result' = GType result+    touchManagedPtr _obj+    freeMem fieldname'+    return result'++data StructureGetFieldTypeMethodInfo+instance (signature ~ (T.Text -> m GType), MonadIO m) => MethodInfo StructureGetFieldTypeMethodInfo Structure signature where+    overloadedMethod _ = structureGetFieldType++-- method Structure::get_flagset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_flags", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "value_mask", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_flagset" gst_structure_get_flagset :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr Word32 ->                           -- value_flags : TBasicType TUInt32+    Ptr Word32 ->                           -- value_mask : TBasicType TUInt32+    IO CInt+++structureGetFlagset ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Word32,Word32)               -- result+structureGetFlagset _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    valueFlags <- allocMem :: IO (Ptr Word32)+    valueMask <- allocMem :: IO (Ptr Word32)+    result <- gst_structure_get_flagset _obj' fieldname' valueFlags valueMask+    let result' = (/= 0) result+    valueFlags' <- peek valueFlags+    valueMask' <- peek valueMask+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem valueFlags+    freeMem valueMask+    return (result', valueFlags', valueMask')++data StructureGetFlagsetMethodInfo+instance (signature ~ (T.Text -> m (Bool,Word32,Word32)), MonadIO m) => MethodInfo StructureGetFlagsetMethodInfo Structure signature where+    overloadedMethod _ = structureGetFlagset++-- method Structure::get_fraction+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_numerator", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "value_denominator", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_fraction" gst_structure_get_fraction :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr Int32 ->                            -- value_numerator : TBasicType TInt32+    Ptr Int32 ->                            -- value_denominator : TBasicType TInt32+    IO CInt+++structureGetFraction ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Int32,Int32)                 -- result+structureGetFraction _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    valueNumerator <- allocMem :: IO (Ptr Int32)+    valueDenominator <- allocMem :: IO (Ptr Int32)+    result <- gst_structure_get_fraction _obj' fieldname' valueNumerator valueDenominator+    let result' = (/= 0) result+    valueNumerator' <- peek valueNumerator+    valueDenominator' <- peek valueDenominator+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem valueNumerator+    freeMem valueDenominator+    return (result', valueNumerator', valueDenominator')++data StructureGetFractionMethodInfo+instance (signature ~ (T.Text -> m (Bool,Int32,Int32)), MonadIO m) => MethodInfo StructureGetFractionMethodInfo Structure signature where+    overloadedMethod _ = structureGetFraction++-- method Structure::get_int+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_int" gst_structure_get_int :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr Int32 ->                            -- value : TBasicType TInt32+    IO CInt+++structureGetInt ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Int32)                       -- result+structureGetInt _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr Int32)+    result <- gst_structure_get_int _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value')++data StructureGetIntMethodInfo+instance (signature ~ (T.Text -> m (Bool,Int32)), MonadIO m) => MethodInfo StructureGetIntMethodInfo Structure signature where+    overloadedMethod _ = structureGetInt++-- method Structure::get_int64+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_int64" gst_structure_get_int64 :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr Int64 ->                            -- value : TBasicType TInt64+    IO CInt+++structureGetInt64 ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Int64)                       -- result+structureGetInt64 _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr Int64)+    result <- gst_structure_get_int64 _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value')++data StructureGetInt64MethodInfo+instance (signature ~ (T.Text -> m (Bool,Int64)), MonadIO m) => MethodInfo StructureGetInt64MethodInfo Structure signature where+    overloadedMethod _ = structureGetInt64++-- method Structure::get_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_name" gst_structure_get_name :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO CString+++structureGetName ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m T.Text                             -- result+structureGetName _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_get_name _obj'+    checkUnexpectedReturnNULL "gst_structure_get_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data StructureGetNameMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo StructureGetNameMethodInfo Structure signature where+    overloadedMethod _ = structureGetName++-- method Structure::get_name_id+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_name_id" gst_structure_get_name_id :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO Word32+++structureGetNameId ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m Word32                             -- result+structureGetNameId _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_get_name_id _obj'+    touchManagedPtr _obj+    return result++data StructureGetNameIdMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo StructureGetNameIdMethodInfo Structure signature where+    overloadedMethod _ = structureGetNameId++-- method Structure::get_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_string" gst_structure_get_string :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    IO CString+++structureGetString ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m T.Text                             -- result+structureGetString _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    result <- gst_structure_get_string _obj' fieldname'+    checkUnexpectedReturnNULL "gst_structure_get_string" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem fieldname'+    return result'++data StructureGetStringMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m) => MethodInfo StructureGetStringMethodInfo Structure signature where+    overloadedMethod _ = structureGetString++-- method Structure::get_uint+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_uint" gst_structure_get_uint :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr Word32 ->                           -- value : TBasicType TUInt32+    IO CInt+++structureGetUint ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Word32)                      -- result+structureGetUint _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr Word32)+    result <- gst_structure_get_uint _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value')++data StructureGetUintMethodInfo+instance (signature ~ (T.Text -> m (Bool,Word32)), MonadIO m) => MethodInfo StructureGetUintMethodInfo Structure signature where+    overloadedMethod _ = structureGetUint++-- method Structure::get_uint64+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_uint64" gst_structure_get_uint64 :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr Word64 ->                           -- value : TBasicType TUInt64+    IO CInt+++structureGetUint64 ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m (Bool,Word64)                      -- result+structureGetUint64 _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value <- allocMem :: IO (Ptr Word64)+    result <- gst_structure_get_uint64 _obj' fieldname' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem fieldname'+    freeMem value+    return (result', value')++data StructureGetUint64MethodInfo+instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => MethodInfo StructureGetUint64MethodInfo Structure signature where+    overloadedMethod _ = structureGetUint64++-- method Structure::get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_get_value" gst_structure_get_value :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    IO (Ptr GValue)+++structureGetValue ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m GValue                             -- result+structureGetValue _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    result <- gst_structure_get_value _obj' fieldname'+    checkUnexpectedReturnNULL "gst_structure_get_value" result+    result' <- (newBoxed GValue) result+    touchManagedPtr _obj+    freeMem fieldname'+    return result'++data StructureGetValueMethodInfo+instance (signature ~ (T.Text -> m GValue), MonadIO m) => MethodInfo StructureGetValueMethodInfo Structure signature where+    overloadedMethod _ = structureGetValue++-- method Structure::has_field+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_has_field" gst_structure_has_field :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    IO CInt+++structureHasField ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m Bool                               -- result+structureHasField _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    result <- gst_structure_has_field _obj' fieldname'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldname'+    return result'++data StructureHasFieldMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo StructureHasFieldMethodInfo Structure signature where+    overloadedMethod _ = structureHasField++-- method Structure::has_field_typed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_has_field_typed" gst_structure_has_field_typed :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    CGType ->                               -- type : TBasicType TGType+    IO CInt+++structureHasFieldTyped ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> GType                                -- type_+    -> m Bool                               -- result+structureHasFieldTyped _obj fieldname type_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    let type_' = gtypeToCGType type_+    result <- gst_structure_has_field_typed _obj' fieldname' type_'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem fieldname'+    return result'++data StructureHasFieldTypedMethodInfo+instance (signature ~ (T.Text -> GType -> m Bool), MonadIO m) => MethodInfo StructureHasFieldTypedMethodInfo Structure signature where+    overloadedMethod _ = structureHasFieldTyped++-- method Structure::has_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_has_name" gst_structure_has_name :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- name : TBasicType TUTF8+    IO CInt+++structureHasName ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- name+    -> m Bool                               -- result+structureHasName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    result <- gst_structure_has_name _obj' name'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem name'+    return result'++data StructureHasNameMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo StructureHasNameMethodInfo Structure signature where+    overloadedMethod _ = structureHasName++-- method Structure::id_get_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_id_get_value" gst_structure_id_get_value :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Word32 ->                               -- field : TBasicType TUInt32+    IO (Ptr GValue)+++structureIdGetValue ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Word32                               -- field+    -> m GValue                             -- result+structureIdGetValue _obj field = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_id_get_value _obj' field+    checkUnexpectedReturnNULL "gst_structure_id_get_value" result+    result' <- (newBoxed GValue) result+    touchManagedPtr _obj+    return result'++data StructureIdGetValueMethodInfo+instance (signature ~ (Word32 -> m GValue), MonadIO m) => MethodInfo StructureIdGetValueMethodInfo Structure signature where+    overloadedMethod _ = structureIdGetValue++-- method Structure::id_has_field+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_id_has_field" gst_structure_id_has_field :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Word32 ->                               -- field : TBasicType TUInt32+    IO CInt+++structureIdHasField ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Word32                               -- field+    -> m Bool                               -- result+structureIdHasField _obj field = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_id_has_field _obj' field+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data StructureIdHasFieldMethodInfo+instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo StructureIdHasFieldMethodInfo Structure signature where+    overloadedMethod _ = structureIdHasField++-- method Structure::id_has_field_typed+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_id_has_field_typed" gst_structure_id_has_field_typed :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Word32 ->                               -- field : TBasicType TUInt32+    CGType ->                               -- type : TBasicType TGType+    IO CInt+++structureIdHasFieldTyped ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Word32                               -- field+    -> GType                                -- type_+    -> m Bool                               -- result+structureIdHasFieldTyped _obj field type_ = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let type_' = gtypeToCGType type_+    result <- gst_structure_id_has_field_typed _obj' field type_'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data StructureIdHasFieldTypedMethodInfo+instance (signature ~ (Word32 -> GType -> m Bool), MonadIO m) => MethodInfo StructureIdHasFieldTypedMethodInfo Structure signature where+    overloadedMethod _ = structureIdHasFieldTyped++-- method Structure::id_set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_id_set_value" gst_structure_id_set_value :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Word32 ->                               -- field : TBasicType TUInt32+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++structureIdSetValue ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Word32                               -- field+    -> GValue                               -- value+    -> m ()                                 -- result+structureIdSetValue _obj field value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let value' = unsafeManagedPtrGetPtr value+    gst_structure_id_set_value _obj' field value'+    touchManagedPtr _obj+    touchManagedPtr value+    return ()++data StructureIdSetValueMethodInfo+instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => MethodInfo StructureIdSetValueMethodInfo Structure signature where+    overloadedMethod _ = structureIdSetValue++-- method Structure::id_take_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_id_take_value" gst_structure_id_take_value :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Word32 ->                               -- field : TBasicType TUInt32+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++structureIdTakeValue ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Word32                               -- field+    -> GValue                               -- value+    -> m ()                                 -- result+structureIdTakeValue _obj field value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    value' <- copyBoxed value+    gst_structure_id_take_value _obj' field value'+    touchManagedPtr _obj+    touchManagedPtr value+    return ()++data StructureIdTakeValueMethodInfo+instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => MethodInfo StructureIdTakeValueMethodInfo Structure signature where+    overloadedMethod _ = structureIdTakeValue++-- method Structure::intersect+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "struct2", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_intersect" gst_structure_intersect :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Ptr Structure ->                        -- struct2 : TInterface "Gst" "Structure"+    IO (Ptr Structure)+++structureIntersect ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Structure                            -- struct2+    -> m Structure                          -- result+structureIntersect _obj struct2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let struct2' = unsafeManagedPtrGetPtr struct2+    result <- gst_structure_intersect _obj' struct2'+    checkUnexpectedReturnNULL "gst_structure_intersect" result+    result' <- (wrapBoxed Structure) result+    touchManagedPtr _obj+    touchManagedPtr struct2+    return result'++data StructureIntersectMethodInfo+instance (signature ~ (Structure -> m Structure), MonadIO m) => MethodInfo StructureIntersectMethodInfo Structure signature where+    overloadedMethod _ = structureIntersect++-- method Structure::is_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure2", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_is_equal" gst_structure_is_equal :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Ptr Structure ->                        -- structure2 : TInterface "Gst" "Structure"+    IO CInt+++structureIsEqual ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Structure                            -- structure2+    -> m Bool                               -- result+structureIsEqual _obj structure2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let structure2' = unsafeManagedPtrGetPtr structure2+    result <- gst_structure_is_equal _obj' structure2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr structure2+    return result'++data StructureIsEqualMethodInfo+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo StructureIsEqualMethodInfo Structure signature where+    overloadedMethod _ = structureIsEqual++-- method Structure::is_subset+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "superset", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_is_subset" gst_structure_is_subset :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Ptr Structure ->                        -- superset : TInterface "Gst" "Structure"+    IO CInt+++structureIsSubset ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Structure                            -- superset+    -> m Bool                               -- result+structureIsSubset _obj superset = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let superset' = unsafeManagedPtrGetPtr superset+    result <- gst_structure_is_subset _obj' superset'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr superset+    return result'++data StructureIsSubsetMethodInfo+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo StructureIsSubsetMethodInfo Structure signature where+    overloadedMethod _ = structureIsSubset++-- method Structure::map_in_place+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "StructureMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_map_in_place" gst_structure_map_in_place :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    FunPtr StructureMapFuncC ->             -- func : TInterface "Gst" "StructureMapFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO CInt+++structureMapInPlace ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> StructureMapFunc                     -- func+    -> m Bool                               -- result+structureMapInPlace _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkStructureMapFunc (structureMapFuncWrapper Nothing func)+    let userData = nullPtr+    result <- gst_structure_map_in_place _obj' func' userData+    let result' = (/= 0) result+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return result'++data StructureMapInPlaceMethodInfo+instance (signature ~ (StructureMapFunc -> m Bool), MonadIO m) => MethodInfo StructureMapInPlaceMethodInfo Structure signature where+    overloadedMethod _ = structureMapInPlace++-- method Structure::n_fields+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_n_fields" gst_structure_n_fields :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO Int32+++structureNFields ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m Int32                              -- result+structureNFields _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_n_fields _obj'+    touchManagedPtr _obj+    return result++data StructureNFieldsMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo StructureNFieldsMethodInfo Structure signature where+    overloadedMethod _ = structureNFields++-- method Structure::nth_field_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_nth_field_name" gst_structure_nth_field_name :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Word32 ->                               -- index : TBasicType TUInt32+    IO CString+++structureNthFieldName ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Word32                               -- index+    -> m T.Text                             -- result+structureNthFieldName _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_nth_field_name _obj' index+    checkUnexpectedReturnNULL "gst_structure_nth_field_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data StructureNthFieldNameMethodInfo+instance (signature ~ (Word32 -> m T.Text), MonadIO m) => MethodInfo StructureNthFieldNameMethodInfo Structure signature where+    overloadedMethod _ = structureNthFieldName++-- method Structure::remove_all_fields+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_remove_all_fields" gst_structure_remove_all_fields :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO ()+++structureRemoveAllFields ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m ()                                 -- result+structureRemoveAllFields _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_structure_remove_all_fields _obj'+    touchManagedPtr _obj+    return ()++data StructureRemoveAllFieldsMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo StructureRemoveAllFieldsMethodInfo Structure signature where+    overloadedMethod _ = structureRemoveAllFields++-- method Structure::remove_field+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_remove_field" gst_structure_remove_field :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    IO ()+++structureRemoveField ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> m ()                                 -- result+structureRemoveField _obj fieldname = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    gst_structure_remove_field _obj' fieldname'+    touchManagedPtr _obj+    freeMem fieldname'+    return ()++data StructureRemoveFieldMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo StructureRemoveFieldMethodInfo Structure signature where+    overloadedMethod _ = structureRemoveField++-- method Structure::set_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_set_name" gst_structure_set_name :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- name : TBasicType TUTF8+    IO ()+++structureSetName ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- name+    -> m ()                                 -- result+structureSetName _obj name = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    name' <- textToCString name+    gst_structure_set_name _obj' name'+    touchManagedPtr _obj+    freeMem name'+    return ()++data StructureSetNameMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo StructureSetNameMethodInfo Structure signature where+    overloadedMethod _ = structureSetName++-- method Structure::set_parent_refcount+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refcount", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_set_parent_refcount" gst_structure_set_parent_refcount :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    Int32 ->                                -- refcount : TBasicType TInt32+    IO CInt+++structureSetParentRefcount ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> Int32                                -- refcount+    -> m Bool                               -- result+structureSetParentRefcount _obj refcount = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_set_parent_refcount _obj' refcount+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data StructureSetParentRefcountMethodInfo+instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo StructureSetParentRefcountMethodInfo Structure signature where+    overloadedMethod _ = structureSetParentRefcount++-- method Structure::set_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_set_value" gst_structure_set_value :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++structureSetValue ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> GValue                               -- value+    -> m ()                                 -- result+structureSetValue _obj fieldname value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    let value' = unsafeManagedPtrGetPtr value+    gst_structure_set_value _obj' fieldname' value'+    touchManagedPtr _obj+    touchManagedPtr value+    freeMem fieldname'+    return ()++data StructureSetValueMethodInfo+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => MethodInfo StructureSetValueMethodInfo Structure signature where+    overloadedMethod _ = structureSetValue++-- method Structure::take_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_take_value" gst_structure_take_value :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    CString ->                              -- fieldname : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++structureTakeValue ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> T.Text                               -- fieldname+    -> GValue                               -- value+    -> m ()                                 -- result+structureTakeValue _obj fieldname value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    fieldname' <- textToCString fieldname+    value' <- copyBoxed value+    gst_structure_take_value _obj' fieldname' value'+    touchManagedPtr _obj+    touchManagedPtr value+    freeMem fieldname'+    return ()++data StructureTakeValueMethodInfo+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => MethodInfo StructureTakeValueMethodInfo Structure signature where+    overloadedMethod _ = structureTakeValue++-- method Structure::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_to_string" gst_structure_to_string :: +    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"+    IO CString+++structureToString ::+    (MonadIO m) =>+    Structure                               -- _obj+    -> m T.Text                             -- result+structureToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_structure_to_string _obj'+    checkUnexpectedReturnNULL "gst_structure_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data StructureToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo StructureToStringMethodInfo Structure signature where+    overloadedMethod _ = structureToString++-- method Structure::from_string+-- method type : MemberFunction+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Structure"+-- throws : False+-- Skip return : False++foreign import ccall "gst_structure_from_string" gst_structure_from_string :: +    CString ->                              -- string : TBasicType TUTF8+    Ptr CString ->                          -- end : TBasicType TUTF8+    IO (Ptr Structure)+++structureFromString ::+    (MonadIO m) =>+    T.Text                                  -- string+    -> m (Structure,T.Text)                 -- result+structureFromString string = liftIO $ do+    string' <- textToCString string+    end <- allocMem :: IO (Ptr CString)+    result <- gst_structure_from_string string' end+    checkUnexpectedReturnNULL "gst_structure_from_string" result+    result' <- (wrapBoxed Structure) result+    end' <- peek end+    end'' <- cstringToText end'+    freeMem string'+    freeMem end+    return (result', end'')++type family ResolveStructureMethod (t :: Symbol) (o :: *) :: * where+    ResolveStructureMethod "canIntersect" o = StructureCanIntersectMethodInfo+    ResolveStructureMethod "copy" o = StructureCopyMethodInfo+    ResolveStructureMethod "filterAndMapInPlace" o = StructureFilterAndMapInPlaceMethodInfo+    ResolveStructureMethod "fixate" o = StructureFixateMethodInfo+    ResolveStructureMethod "fixateField" o = StructureFixateFieldMethodInfo+    ResolveStructureMethod "fixateFieldBoolean" o = StructureFixateFieldBooleanMethodInfo+    ResolveStructureMethod "fixateFieldNearestDouble" o = StructureFixateFieldNearestDoubleMethodInfo+    ResolveStructureMethod "fixateFieldNearestFraction" o = StructureFixateFieldNearestFractionMethodInfo+    ResolveStructureMethod "fixateFieldNearestInt" o = StructureFixateFieldNearestIntMethodInfo+    ResolveStructureMethod "fixateFieldString" o = StructureFixateFieldStringMethodInfo+    ResolveStructureMethod "foreach" o = StructureForeachMethodInfo+    ResolveStructureMethod "free" o = StructureFreeMethodInfo+    ResolveStructureMethod "hasField" o = StructureHasFieldMethodInfo+    ResolveStructureMethod "hasFieldTyped" o = StructureHasFieldTypedMethodInfo+    ResolveStructureMethod "hasName" o = StructureHasNameMethodInfo+    ResolveStructureMethod "idGetValue" o = StructureIdGetValueMethodInfo+    ResolveStructureMethod "idHasField" o = StructureIdHasFieldMethodInfo+    ResolveStructureMethod "idHasFieldTyped" o = StructureIdHasFieldTypedMethodInfo+    ResolveStructureMethod "idSetValue" o = StructureIdSetValueMethodInfo+    ResolveStructureMethod "idTakeValue" o = StructureIdTakeValueMethodInfo+    ResolveStructureMethod "intersect" o = StructureIntersectMethodInfo+    ResolveStructureMethod "isEqual" o = StructureIsEqualMethodInfo+    ResolveStructureMethod "isSubset" o = StructureIsSubsetMethodInfo+    ResolveStructureMethod "mapInPlace" o = StructureMapInPlaceMethodInfo+    ResolveStructureMethod "nFields" o = StructureNFieldsMethodInfo+    ResolveStructureMethod "nthFieldName" o = StructureNthFieldNameMethodInfo+    ResolveStructureMethod "removeAllFields" o = StructureRemoveAllFieldsMethodInfo+    ResolveStructureMethod "removeField" o = StructureRemoveFieldMethodInfo+    ResolveStructureMethod "takeValue" o = StructureTakeValueMethodInfo+    ResolveStructureMethod "toString" o = StructureToStringMethodInfo+    ResolveStructureMethod "getBoolean" o = StructureGetBooleanMethodInfo+    ResolveStructureMethod "getClockTime" o = StructureGetClockTimeMethodInfo+    ResolveStructureMethod "getDate" o = StructureGetDateMethodInfo+    ResolveStructureMethod "getDateTime" o = StructureGetDateTimeMethodInfo+    ResolveStructureMethod "getDouble" o = StructureGetDoubleMethodInfo+    ResolveStructureMethod "getEnum" o = StructureGetEnumMethodInfo+    ResolveStructureMethod "getFieldType" o = StructureGetFieldTypeMethodInfo+    ResolveStructureMethod "getFlagset" o = StructureGetFlagsetMethodInfo+    ResolveStructureMethod "getFraction" o = StructureGetFractionMethodInfo+    ResolveStructureMethod "getInt" o = StructureGetIntMethodInfo+    ResolveStructureMethod "getInt64" o = StructureGetInt64MethodInfo+    ResolveStructureMethod "getName" o = StructureGetNameMethodInfo+    ResolveStructureMethod "getNameId" o = StructureGetNameIdMethodInfo+    ResolveStructureMethod "getString" o = StructureGetStringMethodInfo+    ResolveStructureMethod "getUint" o = StructureGetUintMethodInfo+    ResolveStructureMethod "getUint64" o = StructureGetUint64MethodInfo+    ResolveStructureMethod "getValue" o = StructureGetValueMethodInfo+    ResolveStructureMethod "setName" o = StructureSetNameMethodInfo+    ResolveStructureMethod "setParentRefcount" o = StructureSetParentRefcountMethodInfo+    ResolveStructureMethod "setValue" o = StructureSetValueMethodInfo+    ResolveStructureMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveStructureMethod t Structure, MethodInfo info Structure p) => IsLabelProxy t (Structure -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveStructureMethod t Structure, MethodInfo info Structure p) => IsLabel t (Structure -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Structure.hs-boot view
@@ -0,0 +1,61 @@+module GI.Gst.Structs.Structure 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++newtype Structure = Structure (ForeignPtr Structure)+instance BoxedObject Structure where+data StructureCanIntersectMethodInfo+data StructureCopyMethodInfo+data StructureFilterAndMapInPlaceMethodInfo+data StructureFixateMethodInfo+data StructureFixateFieldMethodInfo+data StructureFixateFieldBooleanMethodInfo+data StructureFixateFieldNearestDoubleMethodInfo+data StructureFixateFieldNearestFractionMethodInfo+data StructureFixateFieldNearestIntMethodInfo+data StructureFixateFieldStringMethodInfo+data StructureForeachMethodInfo+data StructureFreeMethodInfo+data StructureGetBooleanMethodInfo+data StructureGetClockTimeMethodInfo+data StructureGetDateMethodInfo+data StructureGetDateTimeMethodInfo+data StructureGetDoubleMethodInfo+data StructureGetEnumMethodInfo+data StructureGetFieldTypeMethodInfo+data StructureGetFlagsetMethodInfo+data StructureGetFractionMethodInfo+data StructureGetIntMethodInfo+data StructureGetInt64MethodInfo+data StructureGetNameMethodInfo+data StructureGetNameIdMethodInfo+data StructureGetStringMethodInfo+data StructureGetUintMethodInfo+data StructureGetUint64MethodInfo+data StructureGetValueMethodInfo+data StructureHasFieldMethodInfo+data StructureHasFieldTypedMethodInfo+data StructureHasNameMethodInfo+data StructureIdGetValueMethodInfo+data StructureIdHasFieldMethodInfo+data StructureIdHasFieldTypedMethodInfo+data StructureIdSetValueMethodInfo+data StructureIdTakeValueMethodInfo+data StructureIntersectMethodInfo+data StructureIsEqualMethodInfo+data StructureIsSubsetMethodInfo+data StructureMapInPlaceMethodInfo+data StructureNFieldsMethodInfo+data StructureNthFieldNameMethodInfo+data StructureRemoveAllFieldsMethodInfo+data StructureRemoveFieldMethodInfo+data StructureSetNameMethodInfo+data StructureSetParentRefcountMethodInfo+data StructureSetValueMethodInfo+data StructureTakeValueMethodInfo+data StructureToStringMethodInfo
+ GI/Gst/Structs/TagList.hs view
@@ -0,0 +1,1785 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++List of tags and values used to describe media metadata.++Strings in structures must be ASCII or UTF-8 encoded. Other encodings are+not allowed. Strings must not be empty or %NULL.+-}++module GI.Gst.Structs.TagList+    ( ++-- * Exported types+    TagList(..)                             ,+    newZeroTagList                          ,+    noTagList                               ,+++ -- * Methods+-- ** tagListAddValue+    TagListAddValueMethodInfo               ,+    tagListAddValue                         ,+++-- ** tagListCopyValue+    tagListCopyValue                        ,+++-- ** tagListForeach+    TagListForeachMethodInfo                ,+    tagListForeach                          ,+++-- ** tagListGetBoolean+    TagListGetBooleanMethodInfo             ,+    tagListGetBoolean                       ,+++-- ** tagListGetBooleanIndex+    TagListGetBooleanIndexMethodInfo        ,+    tagListGetBooleanIndex                  ,+++-- ** tagListGetDate+    TagListGetDateMethodInfo                ,+    tagListGetDate                          ,+++-- ** tagListGetDateIndex+    TagListGetDateIndexMethodInfo           ,+    tagListGetDateIndex                     ,+++-- ** tagListGetDateTime+    TagListGetDateTimeMethodInfo            ,+    tagListGetDateTime                      ,+++-- ** tagListGetDateTimeIndex+    TagListGetDateTimeIndexMethodInfo       ,+    tagListGetDateTimeIndex                 ,+++-- ** tagListGetDouble+    TagListGetDoubleMethodInfo              ,+    tagListGetDouble                        ,+++-- ** tagListGetDoubleIndex+    TagListGetDoubleIndexMethodInfo         ,+    tagListGetDoubleIndex                   ,+++-- ** tagListGetFloat+    TagListGetFloatMethodInfo               ,+    tagListGetFloat                         ,+++-- ** tagListGetFloatIndex+    TagListGetFloatIndexMethodInfo          ,+    tagListGetFloatIndex                    ,+++-- ** tagListGetInt+    TagListGetIntMethodInfo                 ,+    tagListGetInt                           ,+++-- ** tagListGetInt64+    TagListGetInt64MethodInfo               ,+    tagListGetInt64                         ,+++-- ** tagListGetInt64Index+    TagListGetInt64IndexMethodInfo          ,+    tagListGetInt64Index                    ,+++-- ** tagListGetIntIndex+    TagListGetIntIndexMethodInfo            ,+    tagListGetIntIndex                      ,+++-- ** tagListGetPointer+    TagListGetPointerMethodInfo             ,+    tagListGetPointer                       ,+++-- ** tagListGetPointerIndex+    TagListGetPointerIndexMethodInfo        ,+    tagListGetPointerIndex                  ,+++-- ** tagListGetSample+    TagListGetSampleMethodInfo              ,+    tagListGetSample                        ,+++-- ** tagListGetSampleIndex+    TagListGetSampleIndexMethodInfo         ,+    tagListGetSampleIndex                   ,+++-- ** tagListGetScope+    TagListGetScopeMethodInfo               ,+    tagListGetScope                         ,+++-- ** tagListGetString+    TagListGetStringMethodInfo              ,+    tagListGetString                        ,+++-- ** tagListGetStringIndex+    TagListGetStringIndexMethodInfo         ,+    tagListGetStringIndex                   ,+++-- ** tagListGetTagSize+    TagListGetTagSizeMethodInfo             ,+    tagListGetTagSize                       ,+++-- ** tagListGetUint+    TagListGetUintMethodInfo                ,+    tagListGetUint                          ,+++-- ** tagListGetUint64+    TagListGetUint64MethodInfo              ,+    tagListGetUint64                        ,+++-- ** tagListGetUint64Index+    TagListGetUint64IndexMethodInfo         ,+    tagListGetUint64Index                   ,+++-- ** tagListGetUintIndex+    TagListGetUintIndexMethodInfo           ,+    tagListGetUintIndex                     ,+++-- ** tagListGetValueIndex+    TagListGetValueIndexMethodInfo          ,+    tagListGetValueIndex                    ,+++-- ** tagListInsert+    TagListInsertMethodInfo                 ,+    tagListInsert                           ,+++-- ** tagListIsEmpty+    TagListIsEmptyMethodInfo                ,+    tagListIsEmpty                          ,+++-- ** tagListIsEqual+    TagListIsEqualMethodInfo                ,+    tagListIsEqual                          ,+++-- ** tagListMerge+    TagListMergeMethodInfo                  ,+    tagListMerge                            ,+++-- ** tagListNTags+    TagListNTagsMethodInfo                  ,+    tagListNTags                            ,+++-- ** tagListNewEmpty+    tagListNewEmpty                         ,+++-- ** tagListNewFromString+    tagListNewFromString                    ,+++-- ** tagListNthTagName+    TagListNthTagNameMethodInfo             ,+    tagListNthTagName                       ,+++-- ** tagListPeekStringIndex+    TagListPeekStringIndexMethodInfo        ,+    tagListPeekStringIndex                  ,+++-- ** tagListRemoveTag+    TagListRemoveTagMethodInfo              ,+    tagListRemoveTag                        ,+++-- ** tagListSetScope+    TagListSetScopeMethodInfo               ,+    tagListSetScope                         ,+++-- ** tagListToString+    TagListToStringMethodInfo               ,+    tagListToString                         ,+++++ -- * Properties+-- ** MiniObject+    tagListReadMiniObject                   ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype TagList = TagList (ForeignPtr TagList)+foreign import ccall "gst_tag_list_get_type" c_gst_tag_list_get_type :: +    IO GType++instance BoxedObject TagList where+    boxedType _ = c_gst_tag_list_get_type++-- | Construct a `TagList` struct initialized to zero.+newZeroTagList :: MonadIO m => m TagList+newZeroTagList = liftIO $ callocBoxedBytes 64 >>= wrapBoxed TagList++noTagList :: Maybe TagList+noTagList = Nothing++tagListReadMiniObject :: TagList -> IO MiniObject+tagListReadMiniObject s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)+    val' <- (newPtr 64 MiniObject) val+    return val'++-- method TagList::new_empty+-- method type : Constructor+-- Args : []+-- Lengths : []+-- returnType : TInterface "Gst" "TagList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_new_empty" gst_tag_list_new_empty :: +    IO (Ptr TagList)+++tagListNewEmpty ::+    (MonadIO m) =>+    m TagList                               -- result+tagListNewEmpty  = liftIO $ do+    result <- gst_tag_list_new_empty+    checkUnexpectedReturnNULL "gst_tag_list_new_empty" result+    result' <- (wrapBoxed TagList) result+    return result'++-- method TagList::new_from_string+-- method type : Constructor+-- Args : [Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_new_from_string" gst_tag_list_new_from_string :: +    CString ->                              -- str : TBasicType TUTF8+    IO (Ptr TagList)+++tagListNewFromString ::+    (MonadIO m) =>+    T.Text                                  -- str+    -> m TagList                            -- result+tagListNewFromString str = liftIO $ do+    str' <- textToCString str+    result <- gst_tag_list_new_from_string str'+    checkUnexpectedReturnNULL "gst_tag_list_new_from_string" result+    result' <- (wrapBoxed TagList) result+    freeMem str'+    return result'++-- method TagList::add_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_add_value" gst_tag_list_add_value :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"+    IO ()+++tagListAddValue ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> TagMergeMode                         -- mode+    -> T.Text                               -- tag+    -> GValue                               -- value+    -> m ()                                 -- result+tagListAddValue _obj mode tag value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let mode' = (fromIntegral . fromEnum) mode+    tag' <- textToCString tag+    let value' = unsafeManagedPtrGetPtr value+    gst_tag_list_add_value _obj' mode' tag' value'+    touchManagedPtr _obj+    touchManagedPtr value+    freeMem tag'+    return ()++data TagListAddValueMethodInfo+instance (signature ~ (TagMergeMode -> T.Text -> GValue -> m ()), MonadIO m) => MethodInfo TagListAddValueMethodInfo TagList signature where+    overloadedMethod _ = tagListAddValue++-- method TagList::foreach+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TagForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_foreach" gst_tag_list_foreach :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    FunPtr TagForeachFuncC ->               -- func : TInterface "Gst" "TagForeachFunc"+    Ptr () ->                               -- user_data : TBasicType TVoid+    IO ()+++tagListForeach ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> TagForeachFunc                       -- func+    -> m ()                                 -- result+tagListForeach _obj func = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    func' <- mkTagForeachFunc (tagForeachFuncWrapper Nothing func)+    let userData = nullPtr+    gst_tag_list_foreach _obj' func' userData+    safeFreeFunPtr $ castFunPtrToPtr func'+    touchManagedPtr _obj+    return ()++data TagListForeachMethodInfo+instance (signature ~ (TagForeachFunc -> m ()), MonadIO m) => MethodInfo TagListForeachMethodInfo TagList signature where+    overloadedMethod _ = tagListForeach++-- method TagList::get_boolean+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_boolean" gst_tag_list_get_boolean :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr CInt ->                             -- value : TBasicType TBoolean+    IO CInt+++tagListGetBoolean ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,Bool)                        -- result+tagListGetBoolean _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CInt)+    result <- gst_tag_list_get_boolean _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = (/= 0) value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetBooleanMethodInfo+instance (signature ~ (T.Text -> m (Bool,Bool)), MonadIO m) => MethodInfo TagListGetBooleanMethodInfo TagList signature where+    overloadedMethod _ = tagListGetBoolean++-- method TagList::get_boolean_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_boolean_index" gst_tag_list_get_boolean_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr CInt ->                             -- value : TBasicType TBoolean+    IO CInt+++tagListGetBooleanIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Bool)                        -- result+tagListGetBooleanIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CInt)+    result <- gst_tag_list_get_boolean_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = (/= 0) value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetBooleanIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Bool)), MonadIO m) => MethodInfo TagListGetBooleanIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetBooleanIndex++-- method TagList::get_date+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GLib" "Date", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_date" gst_tag_list_get_date :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr GLib.Date ->                        -- value : TInterface "GLib" "Date"+    IO CInt+++tagListGetDate ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,GLib.Date)                   -- result+tagListGetDate _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- callocBoxedBytes 24 :: IO (Ptr GLib.Date)+    result <- gst_tag_list_get_date _obj' tag' value+    let result' = (/= 0) result+    value' <- (wrapBoxed GLib.Date) value+    touchManagedPtr _obj+    freeMem tag'+    return (result', value')++data TagListGetDateMethodInfo+instance (signature ~ (T.Text -> m (Bool,GLib.Date)), MonadIO m) => MethodInfo TagListGetDateMethodInfo TagList signature where+    overloadedMethod _ = tagListGetDate++-- method TagList::get_date_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GLib" "Date", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_date_index" gst_tag_list_get_date_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr GLib.Date ->                        -- value : TInterface "GLib" "Date"+    IO CInt+++tagListGetDateIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,GLib.Date)                   -- result+tagListGetDateIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- callocBoxedBytes 24 :: IO (Ptr GLib.Date)+    result <- gst_tag_list_get_date_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- (wrapBoxed GLib.Date) value+    touchManagedPtr _obj+    freeMem tag'+    return (result', value')++data TagListGetDateIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,GLib.Date)), MonadIO m) => MethodInfo TagListGetDateIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetDateIndex++-- method TagList::get_date_time+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "Gst" "DateTime", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_date_time" gst_tag_list_get_date_time :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr (Ptr DateTime) ->                   -- value : TInterface "Gst" "DateTime"+    IO CInt+++tagListGetDateTime ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,DateTime)                    -- result+tagListGetDateTime _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr (Ptr DateTime))+    result <- gst_tag_list_get_date_time _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- (wrapBoxed DateTime) value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetDateTimeMethodInfo+instance (signature ~ (T.Text -> m (Bool,DateTime)), MonadIO m) => MethodInfo TagListGetDateTimeMethodInfo TagList signature where+    overloadedMethod _ = tagListGetDateTime++-- method TagList::get_date_time_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "Gst" "DateTime", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_date_time_index" gst_tag_list_get_date_time_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr (Ptr DateTime) ->                   -- value : TInterface "Gst" "DateTime"+    IO CInt+++tagListGetDateTimeIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,DateTime)                    -- result+tagListGetDateTimeIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr (Ptr DateTime))+    result <- gst_tag_list_get_date_time_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- (wrapBoxed DateTime) value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetDateTimeIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,DateTime)), MonadIO m) => MethodInfo TagListGetDateTimeIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetDateTimeIndex++-- method TagList::get_double+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_double" gst_tag_list_get_double :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr CDouble ->                          -- value : TBasicType TDouble+    IO CInt+++tagListGetDouble ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,Double)                      -- result+tagListGetDouble _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CDouble)+    result <- gst_tag_list_get_double _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = realToFrac value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetDoubleMethodInfo+instance (signature ~ (T.Text -> m (Bool,Double)), MonadIO m) => MethodInfo TagListGetDoubleMethodInfo TagList signature where+    overloadedMethod _ = tagListGetDouble++-- method TagList::get_double_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_double_index" gst_tag_list_get_double_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr CDouble ->                          -- value : TBasicType TDouble+    IO CInt+++tagListGetDoubleIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Double)                      -- result+tagListGetDoubleIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CDouble)+    result <- gst_tag_list_get_double_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = realToFrac value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetDoubleIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Double)), MonadIO m) => MethodInfo TagListGetDoubleIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetDoubleIndex++-- method TagList::get_float+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_float" gst_tag_list_get_float :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr CFloat ->                           -- value : TBasicType TFloat+    IO CInt+++tagListGetFloat ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,Float)                       -- result+tagListGetFloat _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CFloat)+    result <- gst_tag_list_get_float _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = realToFrac value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetFloatMethodInfo+instance (signature ~ (T.Text -> m (Bool,Float)), MonadIO m) => MethodInfo TagListGetFloatMethodInfo TagList signature where+    overloadedMethod _ = tagListGetFloat++-- method TagList::get_float_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_float_index" gst_tag_list_get_float_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr CFloat ->                           -- value : TBasicType TFloat+    IO CInt+++tagListGetFloatIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Float)                       -- result+tagListGetFloatIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CFloat)+    result <- gst_tag_list_get_float_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    let value'' = realToFrac value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetFloatIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Float)), MonadIO m) => MethodInfo TagListGetFloatIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetFloatIndex++-- method TagList::get_int+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_int" gst_tag_list_get_int :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr Int32 ->                            -- value : TBasicType TInt32+    IO CInt+++tagListGetInt ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,Int32)                       -- result+tagListGetInt _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr Int32)+    result <- gst_tag_list_get_int _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetIntMethodInfo+instance (signature ~ (T.Text -> m (Bool,Int32)), MonadIO m) => MethodInfo TagListGetIntMethodInfo TagList signature where+    overloadedMethod _ = tagListGetInt++-- method TagList::get_int64+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_int64" gst_tag_list_get_int64 :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Int64 ->                                -- value : TBasicType TInt64+    IO CInt+++tagListGetInt64 ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Int64                                -- value+    -> m Bool                               -- result+tagListGetInt64 _obj tag value = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    result <- gst_tag_list_get_int64 _obj' tag' value+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem tag'+    return result'++data TagListGetInt64MethodInfo+instance (signature ~ (T.Text -> Int64 -> m Bool), MonadIO m) => MethodInfo TagListGetInt64MethodInfo TagList signature where+    overloadedMethod _ = tagListGetInt64++-- method TagList::get_int64_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_int64_index" gst_tag_list_get_int64_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr Int64 ->                            -- value : TBasicType TInt64+    IO CInt+++tagListGetInt64Index ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Int64)                       -- result+tagListGetInt64Index _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr Int64)+    result <- gst_tag_list_get_int64_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetInt64IndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Int64)), MonadIO m) => MethodInfo TagListGetInt64IndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetInt64Index++-- method TagList::get_int_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_int_index" gst_tag_list_get_int_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr Int32 ->                            -- value : TBasicType TInt32+    IO CInt+++tagListGetIntIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Int32)                       -- result+tagListGetIntIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr Int32)+    result <- gst_tag_list_get_int_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetIntIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Int32)), MonadIO m) => MethodInfo TagListGetIntIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetIntIndex++-- method TagList::get_pointer+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TVoid, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_pointer" gst_tag_list_get_pointer :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr (Ptr ()) ->                         -- value : TBasicType TVoid+    IO CInt+++tagListGetPointer ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,(Ptr ()))                    -- result+tagListGetPointer _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr (Ptr ()))+    result <- gst_tag_list_get_pointer _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetPointerMethodInfo+instance (signature ~ (T.Text -> m (Bool,(Ptr ()))), MonadIO m) => MethodInfo TagListGetPointerMethodInfo TagList signature where+    overloadedMethod _ = tagListGetPointer++-- method TagList::get_pointer_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TVoid, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_pointer_index" gst_tag_list_get_pointer_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr (Ptr ()) ->                         -- value : TBasicType TVoid+    IO CInt+++tagListGetPointerIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,(Ptr ()))                    -- result+tagListGetPointerIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr (Ptr ()))+    result <- gst_tag_list_get_pointer_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetPointerIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,(Ptr ()))), MonadIO m) => MethodInfo TagListGetPointerIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetPointerIndex++-- method TagList::get_sample+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sample", argType = TInterface "Gst" "Sample", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_sample" gst_tag_list_get_sample :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr (Ptr Sample) ->                     -- sample : TInterface "Gst" "Sample"+    IO CInt+++tagListGetSample ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,Sample)                      -- result+tagListGetSample _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    sample <- allocMem :: IO (Ptr (Ptr Sample))+    result <- gst_tag_list_get_sample _obj' tag' sample+    let result' = (/= 0) result+    sample' <- peek sample+    sample'' <- (wrapBoxed Sample) sample'+    touchManagedPtr _obj+    freeMem tag'+    freeMem sample+    return (result', sample'')++data TagListGetSampleMethodInfo+instance (signature ~ (T.Text -> m (Bool,Sample)), MonadIO m) => MethodInfo TagListGetSampleMethodInfo TagList signature where+    overloadedMethod _ = tagListGetSample++-- method TagList::get_sample_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sample", argType = TInterface "Gst" "Sample", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_sample_index" gst_tag_list_get_sample_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr (Ptr Sample) ->                     -- sample : TInterface "Gst" "Sample"+    IO CInt+++tagListGetSampleIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Sample)                      -- result+tagListGetSampleIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    sample <- allocMem :: IO (Ptr (Ptr Sample))+    result <- gst_tag_list_get_sample_index _obj' tag' index sample+    let result' = (/= 0) result+    sample' <- peek sample+    sample'' <- (wrapBoxed Sample) sample'+    touchManagedPtr _obj+    freeMem tag'+    freeMem sample+    return (result', sample'')++data TagListGetSampleIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Sample)), MonadIO m) => MethodInfo TagListGetSampleIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetSampleIndex++-- method TagList::get_scope+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagScope"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_scope" gst_tag_list_get_scope :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    IO CUInt+++tagListGetScope ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> m TagScope                           -- result+tagListGetScope _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_tag_list_get_scope _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data TagListGetScopeMethodInfo+instance (signature ~ (m TagScope), MonadIO m) => MethodInfo TagListGetScopeMethodInfo TagList signature where+    overloadedMethod _ = tagListGetScope++-- method TagList::get_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_string" gst_tag_list_get_string :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt+++tagListGetString ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,T.Text)                      -- result+tagListGetString _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CString)+    result <- gst_tag_list_get_string _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- cstringToText value'+    freeMem value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetStringMethodInfo+instance (signature ~ (T.Text -> m (Bool,T.Text)), MonadIO m) => MethodInfo TagListGetStringMethodInfo TagList signature where+    overloadedMethod _ = tagListGetString++-- method TagList::get_string_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_string_index" gst_tag_list_get_string_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt+++tagListGetStringIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,T.Text)                      -- result+tagListGetStringIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CString)+    result <- gst_tag_list_get_string_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- cstringToText value'+    freeMem value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListGetStringIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,T.Text)), MonadIO m) => MethodInfo TagListGetStringIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetStringIndex++-- method TagList::get_tag_size+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_tag_size" gst_tag_list_get_tag_size :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    IO Word32+++tagListGetTagSize ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m Word32                             -- result+tagListGetTagSize _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    result <- gst_tag_list_get_tag_size _obj' tag'+    touchManagedPtr _obj+    freeMem tag'+    return result++data TagListGetTagSizeMethodInfo+instance (signature ~ (T.Text -> m Word32), MonadIO m) => MethodInfo TagListGetTagSizeMethodInfo TagList signature where+    overloadedMethod _ = tagListGetTagSize++-- method TagList::get_uint+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_uint" gst_tag_list_get_uint :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr Word32 ->                           -- value : TBasicType TUInt32+    IO CInt+++tagListGetUint ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,Word32)                      -- result+tagListGetUint _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr Word32)+    result <- gst_tag_list_get_uint _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetUintMethodInfo+instance (signature ~ (T.Text -> m (Bool,Word32)), MonadIO m) => MethodInfo TagListGetUintMethodInfo TagList signature where+    overloadedMethod _ = tagListGetUint++-- method TagList::get_uint64+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_uint64" gst_tag_list_get_uint64 :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Ptr Word64 ->                           -- value : TBasicType TUInt64+    IO CInt+++tagListGetUint64 ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m (Bool,Word64)                      -- result+tagListGetUint64 _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr Word64)+    result <- gst_tag_list_get_uint64 _obj' tag' value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetUint64MethodInfo+instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => MethodInfo TagListGetUint64MethodInfo TagList signature where+    overloadedMethod _ = tagListGetUint64++-- method TagList::get_uint64_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_uint64_index" gst_tag_list_get_uint64_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr Word64 ->                           -- value : TBasicType TUInt64+    IO CInt+++tagListGetUint64Index ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Word64)                      -- result+tagListGetUint64Index _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr Word64)+    result <- gst_tag_list_get_uint64_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetUint64IndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Word64)), MonadIO m) => MethodInfo TagListGetUint64IndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetUint64Index++-- method TagList::get_uint_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_uint_index" gst_tag_list_get_uint_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr Word32 ->                           -- value : TBasicType TUInt32+    IO CInt+++tagListGetUintIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,Word32)                      -- result+tagListGetUintIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr Word32)+    result <- gst_tag_list_get_uint_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value')++data TagListGetUintIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,Word32)), MonadIO m) => MethodInfo TagListGetUintIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetUintIndex++-- method TagList::get_value_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "GObject" "Value"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_get_value_index" gst_tag_list_get_value_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    IO (Ptr GValue)+++tagListGetValueIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m GValue                             -- result+tagListGetValueIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    result <- gst_tag_list_get_value_index _obj' tag' index+    checkUnexpectedReturnNULL "gst_tag_list_get_value_index" result+    result' <- (newBoxed GValue) result+    touchManagedPtr _obj+    freeMem tag'+    return result'++data TagListGetValueIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m GValue), MonadIO m) => MethodInfo TagListGetValueIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListGetValueIndex++-- method TagList::insert+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_insert" gst_tag_list_insert :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    Ptr TagList ->                          -- from : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO ()+++tagListInsert ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> TagList                              -- from+    -> TagMergeMode                         -- mode+    -> m ()                                 -- result+tagListInsert _obj from mode = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let from' = unsafeManagedPtrGetPtr from+    let mode' = (fromIntegral . fromEnum) mode+    gst_tag_list_insert _obj' from' mode'+    touchManagedPtr _obj+    touchManagedPtr from+    return ()++data TagListInsertMethodInfo+instance (signature ~ (TagList -> TagMergeMode -> m ()), MonadIO m) => MethodInfo TagListInsertMethodInfo TagList signature where+    overloadedMethod _ = tagListInsert++-- method TagList::is_empty+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_is_empty" gst_tag_list_is_empty :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    IO CInt+++tagListIsEmpty ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> m Bool                               -- result+tagListIsEmpty _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_tag_list_is_empty _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TagListIsEmptyMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo TagListIsEmptyMethodInfo TagList signature where+    overloadedMethod _ = tagListIsEmpty++-- method TagList::is_equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list2", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_is_equal" gst_tag_list_is_equal :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    Ptr TagList ->                          -- list2 : TInterface "Gst" "TagList"+    IO CInt+++tagListIsEqual ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> TagList                              -- list2+    -> m Bool                               -- result+tagListIsEqual _obj list2 = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let list2' = unsafeManagedPtrGetPtr list2+    result <- gst_tag_list_is_equal _obj' list2'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr list2+    return result'++data TagListIsEqualMethodInfo+instance (signature ~ (TagList -> m Bool), MonadIO m) => MethodInfo TagListIsEqualMethodInfo TagList signature where+    overloadedMethod _ = tagListIsEqual++-- method TagList::merge+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list2", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_merge" gst_tag_list_merge :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    Ptr TagList ->                          -- list2 : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO (Ptr TagList)+++tagListMerge ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> Maybe (TagList)                      -- list2+    -> TagMergeMode                         -- mode+    -> m TagList                            -- result+tagListMerge _obj list2 mode = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeList2 <- case list2 of+        Nothing -> return nullPtr+        Just jList2 -> do+            let jList2' = unsafeManagedPtrGetPtr jList2+            return jList2'+    let mode' = (fromIntegral . fromEnum) mode+    result <- gst_tag_list_merge _obj' maybeList2 mode'+    checkUnexpectedReturnNULL "gst_tag_list_merge" result+    result' <- (wrapBoxed TagList) result+    touchManagedPtr _obj+    whenJust list2 touchManagedPtr+    return result'++data TagListMergeMethodInfo+instance (signature ~ (Maybe (TagList) -> TagMergeMode -> m TagList), MonadIO m) => MethodInfo TagListMergeMethodInfo TagList signature where+    overloadedMethod _ = tagListMerge++-- method TagList::n_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_n_tags" gst_tag_list_n_tags :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    IO Int32+++tagListNTags ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> m Int32                              -- result+tagListNTags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_tag_list_n_tags _obj'+    touchManagedPtr _obj+    return result++data TagListNTagsMethodInfo+instance (signature ~ (m Int32), MonadIO m) => MethodInfo TagListNTagsMethodInfo TagList signature where+    overloadedMethod _ = tagListNTags++-- method TagList::nth_tag_name+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_nth_tag_name" gst_tag_list_nth_tag_name :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    Word32 ->                               -- index : TBasicType TUInt32+    IO CString+++tagListNthTagName ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> Word32                               -- index+    -> m T.Text                             -- result+tagListNthTagName _obj index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_tag_list_nth_tag_name _obj' index+    checkUnexpectedReturnNULL "gst_tag_list_nth_tag_name" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data TagListNthTagNameMethodInfo+instance (signature ~ (Word32 -> m T.Text), MonadIO m) => MethodInfo TagListNthTagNameMethodInfo TagList signature where+    overloadedMethod _ = tagListNthTagName++-- method TagList::peek_string_index+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_peek_string_index" gst_tag_list_peek_string_index :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    Word32 ->                               -- index : TBasicType TUInt32+    Ptr CString ->                          -- value : TBasicType TUTF8+    IO CInt+++tagListPeekStringIndex ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> Word32                               -- index+    -> m (Bool,T.Text)                      -- result+tagListPeekStringIndex _obj tag index = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    value <- allocMem :: IO (Ptr CString)+    result <- gst_tag_list_peek_string_index _obj' tag' index value+    let result' = (/= 0) result+    value' <- peek value+    value'' <- cstringToText value'+    touchManagedPtr _obj+    freeMem tag'+    freeMem value+    return (result', value'')++data TagListPeekStringIndexMethodInfo+instance (signature ~ (T.Text -> Word32 -> m (Bool,T.Text)), MonadIO m) => MethodInfo TagListPeekStringIndexMethodInfo TagList signature where+    overloadedMethod _ = tagListPeekStringIndex++-- method TagList::remove_tag+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_remove_tag" gst_tag_list_remove_tag :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    IO ()+++tagListRemoveTag ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> T.Text                               -- tag+    -> m ()                                 -- result+tagListRemoveTag _obj tag = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    tag' <- textToCString tag+    gst_tag_list_remove_tag _obj' tag'+    touchManagedPtr _obj+    freeMem tag'+    return ()++data TagListRemoveTagMethodInfo+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo TagListRemoveTagMethodInfo TagList signature where+    overloadedMethod _ = tagListRemoveTag++-- method TagList::set_scope+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scope", argType = TInterface "Gst" "TagScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_set_scope" gst_tag_list_set_scope :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    CUInt ->                                -- scope : TInterface "Gst" "TagScope"+    IO ()+++tagListSetScope ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> TagScope                             -- scope+    -> m ()                                 -- result+tagListSetScope _obj scope = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let scope' = (fromIntegral . fromEnum) scope+    gst_tag_list_set_scope _obj' scope'+    touchManagedPtr _obj+    return ()++data TagListSetScopeMethodInfo+instance (signature ~ (TagScope -> m ()), MonadIO m) => MethodInfo TagListSetScopeMethodInfo TagList signature where+    overloadedMethod _ = tagListSetScope++-- method TagList::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_to_string" gst_tag_list_to_string :: +    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"+    IO CString+++tagListToString ::+    (MonadIO m) =>+    TagList                                 -- _obj+    -> m T.Text                             -- result+tagListToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_tag_list_to_string _obj'+    checkUnexpectedReturnNULL "gst_tag_list_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data TagListToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo TagListToStringMethodInfo TagList signature where+    overloadedMethod _ = tagListToString++-- method TagList::copy_value+-- method type : MemberFunction+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_tag_list_copy_value" gst_tag_list_copy_value :: +    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"+    Ptr TagList ->                          -- list : TInterface "Gst" "TagList"+    CString ->                              -- tag : TBasicType TUTF8+    IO CInt+++tagListCopyValue ::+    (MonadIO m) =>+    TagList                                 -- list+    -> T.Text                               -- tag+    -> m (Bool,GValue)                      -- result+tagListCopyValue list tag = liftIO $ do+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)+    let list' = unsafeManagedPtrGetPtr list+    tag' <- textToCString tag+    result <- gst_tag_list_copy_value dest list' tag'+    let result' = (/= 0) result+    dest' <- (wrapBoxed GValue) dest+    touchManagedPtr list+    freeMem tag'+    return (result', dest')++type family ResolveTagListMethod (t :: Symbol) (o :: *) :: * where+    ResolveTagListMethod "addValue" o = TagListAddValueMethodInfo+    ResolveTagListMethod "foreach" o = TagListForeachMethodInfo+    ResolveTagListMethod "insert" o = TagListInsertMethodInfo+    ResolveTagListMethod "isEmpty" o = TagListIsEmptyMethodInfo+    ResolveTagListMethod "isEqual" o = TagListIsEqualMethodInfo+    ResolveTagListMethod "merge" o = TagListMergeMethodInfo+    ResolveTagListMethod "nTags" o = TagListNTagsMethodInfo+    ResolveTagListMethod "nthTagName" o = TagListNthTagNameMethodInfo+    ResolveTagListMethod "peekStringIndex" o = TagListPeekStringIndexMethodInfo+    ResolveTagListMethod "removeTag" o = TagListRemoveTagMethodInfo+    ResolveTagListMethod "toString" o = TagListToStringMethodInfo+    ResolveTagListMethod "getBoolean" o = TagListGetBooleanMethodInfo+    ResolveTagListMethod "getBooleanIndex" o = TagListGetBooleanIndexMethodInfo+    ResolveTagListMethod "getDate" o = TagListGetDateMethodInfo+    ResolveTagListMethod "getDateIndex" o = TagListGetDateIndexMethodInfo+    ResolveTagListMethod "getDateTime" o = TagListGetDateTimeMethodInfo+    ResolveTagListMethod "getDateTimeIndex" o = TagListGetDateTimeIndexMethodInfo+    ResolveTagListMethod "getDouble" o = TagListGetDoubleMethodInfo+    ResolveTagListMethod "getDoubleIndex" o = TagListGetDoubleIndexMethodInfo+    ResolveTagListMethod "getFloat" o = TagListGetFloatMethodInfo+    ResolveTagListMethod "getFloatIndex" o = TagListGetFloatIndexMethodInfo+    ResolveTagListMethod "getInt" o = TagListGetIntMethodInfo+    ResolveTagListMethod "getInt64" o = TagListGetInt64MethodInfo+    ResolveTagListMethod "getInt64Index" o = TagListGetInt64IndexMethodInfo+    ResolveTagListMethod "getIntIndex" o = TagListGetIntIndexMethodInfo+    ResolveTagListMethod "getPointer" o = TagListGetPointerMethodInfo+    ResolveTagListMethod "getPointerIndex" o = TagListGetPointerIndexMethodInfo+    ResolveTagListMethod "getSample" o = TagListGetSampleMethodInfo+    ResolveTagListMethod "getSampleIndex" o = TagListGetSampleIndexMethodInfo+    ResolveTagListMethod "getScope" o = TagListGetScopeMethodInfo+    ResolveTagListMethod "getString" o = TagListGetStringMethodInfo+    ResolveTagListMethod "getStringIndex" o = TagListGetStringIndexMethodInfo+    ResolveTagListMethod "getTagSize" o = TagListGetTagSizeMethodInfo+    ResolveTagListMethod "getUint" o = TagListGetUintMethodInfo+    ResolveTagListMethod "getUint64" o = TagListGetUint64MethodInfo+    ResolveTagListMethod "getUint64Index" o = TagListGetUint64IndexMethodInfo+    ResolveTagListMethod "getUintIndex" o = TagListGetUintIndexMethodInfo+    ResolveTagListMethod "getValueIndex" o = TagListGetValueIndexMethodInfo+    ResolveTagListMethod "setScope" o = TagListSetScopeMethodInfo+    ResolveTagListMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTagListMethod t TagList, MethodInfo info TagList p) => IsLabelProxy t (TagList -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTagListMethod t TagList, MethodInfo info TagList p) => IsLabel t (TagList -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/TagList.hs-boot view
@@ -0,0 +1,50 @@+module GI.Gst.Structs.TagList 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++newtype TagList = TagList (ForeignPtr TagList)+instance BoxedObject TagList where+data TagListAddValueMethodInfo+data TagListForeachMethodInfo+data TagListGetBooleanMethodInfo+data TagListGetBooleanIndexMethodInfo+data TagListGetDateMethodInfo+data TagListGetDateIndexMethodInfo+data TagListGetDateTimeMethodInfo+data TagListGetDateTimeIndexMethodInfo+data TagListGetDoubleMethodInfo+data TagListGetDoubleIndexMethodInfo+data TagListGetFloatMethodInfo+data TagListGetFloatIndexMethodInfo+data TagListGetIntMethodInfo+data TagListGetInt64MethodInfo+data TagListGetInt64IndexMethodInfo+data TagListGetIntIndexMethodInfo+data TagListGetPointerMethodInfo+data TagListGetPointerIndexMethodInfo+data TagListGetSampleMethodInfo+data TagListGetSampleIndexMethodInfo+data TagListGetScopeMethodInfo+data TagListGetStringMethodInfo+data TagListGetStringIndexMethodInfo+data TagListGetTagSizeMethodInfo+data TagListGetUintMethodInfo+data TagListGetUint64MethodInfo+data TagListGetUint64IndexMethodInfo+data TagListGetUintIndexMethodInfo+data TagListGetValueIndexMethodInfo+data TagListInsertMethodInfo+data TagListIsEmptyMethodInfo+data TagListIsEqualMethodInfo+data TagListMergeMethodInfo+data TagListNTagsMethodInfo+data TagListNthTagNameMethodInfo+data TagListPeekStringIndexMethodInfo+data TagListRemoveTagMethodInfo+data TagListSetScopeMethodInfo+data TagListToStringMethodInfo
+ GI/Gst/Structs/TimedValue.hs view
@@ -0,0 +1,73 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++Structure for saving a timestamp and a value.+-}++module GI.Gst.Structs.TimedValue+    ( ++-- * Exported types+    TimedValue(..)                          ,+    newZeroTimedValue                       ,+    noTimedValue                            ,+++ -- * Properties+-- ** Timestamp+    timedValueReadTimestamp                 ,+++-- ** Value+    timedValueReadValue                     ,+++++    ) 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 GI.Gst.Callbacks++newtype TimedValue = TimedValue (ForeignPtr TimedValue)+-- | Construct a `TimedValue` struct initialized to zero.+newZeroTimedValue :: MonadIO m => m TimedValue+newZeroTimedValue = liftIO $ callocBytes 16 >>= wrapPtr TimedValue++noTimedValue :: Maybe TimedValue+noTimedValue = Nothing++timedValueReadTimestamp :: TimedValue -> IO Word64+timedValueReadTimestamp s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO Word64+    return val++timedValueReadValue :: TimedValue -> IO Double+timedValueReadValue s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 8) :: IO CDouble+    let val' = realToFrac val+    return val'++type family ResolveTimedValueMethod (t :: Symbol) (o :: *) :: * where+    ResolveTimedValueMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTimedValueMethod t TimedValue, MethodInfo info TimedValue p) => IsLabelProxy t (TimedValue -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTimedValueMethod t TimedValue, MethodInfo info TimedValue p) => IsLabel t (TimedValue -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/TimedValue.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.TimedValue 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++newtype TimedValue = TimedValue (ForeignPtr TimedValue)
+ GI/Gst/Structs/Toc.hs view
@@ -0,0 +1,426 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++#GstToc functions are used to create/free #GstToc and #GstTocEntry structures.+Also they are used to convert #GstToc into #GstStructure and vice versa.++#GstToc lets you to inform other elements in pipeline or application that playing+source has some kind of table of contents (TOC). These may be chapters, editions,+angles or other types. For example: DVD chapters, Matroska chapters or cue sheet+TOC. Such TOC will be useful for applications to display instead of just a+playlist.++Using TOC is very easy. Firstly, create #GstToc structure which represents root+contents of the source. You can also attach TOC-specific tags to it. Then fill+it with #GstTocEntry entries by appending them to the #GstToc using+gst_toc_append_entry(), and appending subentries to a #GstTocEntry using+gst_toc_entry_append_sub_entry().++Note that root level of the TOC can contain only either editions or chapters. You+should not mix them together at the same level. Otherwise you will get serialization+/deserialization errors. Make sure that no one of the entries has negative start and+ stop values.++Use gst_event_new_toc() to create a new TOC #GstEvent, and gst_event_parse_toc() to+parse received TOC event. Use gst_event_new_toc_select() to create a new TOC select #GstEvent,+and gst_event_parse_toc_select() to parse received TOC select event. The same rule for+the #GstMessage: gst_message_new_toc() to create new TOC #GstMessage, and+gst_message_parse_toc() to parse received TOC message.++TOCs can have global scope or current scope. Global scope TOCs contain+all entries that can possibly be selected using a toc select event, and+are what an application is usually interested in. TOCs with current scope+only contain the parts of the TOC relevant to the currently selected/playing+stream; the current scope TOC is used by downstream elements such as muxers+to write correct TOC entries when transcoding files, for example. When+playing a DVD, the global TOC would contain a hierarchy of all titles,+chapters and angles, for example, while the current TOC would only contain+the chapters for the currently playing title if playback of a specific+title was requested.++Applications and plugins should not rely on TOCs having a certain kind of+structure, but should allow for different alternatives. For example, a+simple CUE sheet embedded in a file may be presented as a flat list of+track entries, or could have a top-level edition node (or some other+alternative type entry) with track entries underneath that node; or even+multiple top-level edition nodes (or some other alternative type entries)+each with track entries underneath, in case the source file has extracted+a track listing from different sources).+-}++module GI.Gst.Structs.Toc+    ( ++-- * Exported types+    Toc(..)                                 ,+    noToc                                   ,+++ -- * Methods+-- ** tocAppendEntry+    TocAppendEntryMethodInfo                ,+    tocAppendEntry                          ,+++-- ** tocDump+    TocDumpMethodInfo                       ,+    tocDump                                 ,+++-- ** tocFindEntry+    TocFindEntryMethodInfo                  ,+    tocFindEntry                            ,+++-- ** tocGetEntries+    TocGetEntriesMethodInfo                 ,+    tocGetEntries                           ,+++-- ** tocGetScope+    TocGetScopeMethodInfo                   ,+    tocGetScope                             ,+++-- ** tocGetTags+    TocGetTagsMethodInfo                    ,+    tocGetTags                              ,+++-- ** tocMergeTags+    TocMergeTagsMethodInfo                  ,+    tocMergeTags                            ,+++-- ** tocNew+    tocNew                                  ,+++-- ** tocSetTags+    TocSetTagsMethodInfo                    ,+    tocSetTags                              ,+++++    ) 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 GI.Gst.Callbacks++newtype Toc = Toc (ForeignPtr Toc)+foreign import ccall "gst_toc_get_type" c_gst_toc_get_type :: +    IO GType++instance BoxedObject Toc where+    boxedType _ = c_gst_toc_get_type++noToc :: Maybe Toc+noToc = Nothing++-- method Toc::new+-- method type : Constructor+-- Args : [Arg {argCName = "scope", argType = TInterface "Gst" "TocScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Toc"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_new" gst_toc_new :: +    CUInt ->                                -- scope : TInterface "Gst" "TocScope"+    IO (Ptr Toc)+++tocNew ::+    (MonadIO m) =>+    TocScope                                -- scope+    -> m Toc                                -- result+tocNew scope = liftIO $ do+    let scope' = (fromIntegral . fromEnum) scope+    result <- gst_toc_new scope'+    checkUnexpectedReturnNULL "gst_toc_new" result+    result' <- (wrapBoxed Toc) result+    return result'++-- method Toc::append_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "entry", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_append_entry" gst_toc_append_entry :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    Ptr TocEntry ->                         -- entry : TInterface "Gst" "TocEntry"+    IO ()+++tocAppendEntry ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> TocEntry                             -- entry+    -> m ()                                 -- result+tocAppendEntry _obj entry = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    entry' <- copyBoxed entry+    gst_toc_append_entry _obj' entry'+    touchManagedPtr _obj+    touchManagedPtr entry+    return ()++data TocAppendEntryMethodInfo+instance (signature ~ (TocEntry -> m ()), MonadIO m) => MethodInfo TocAppendEntryMethodInfo Toc signature where+    overloadedMethod _ = tocAppendEntry++-- method Toc::dump+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_dump" gst_toc_dump :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    IO ()+++tocDump ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> m ()                                 -- result+tocDump _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_toc_dump _obj'+    touchManagedPtr _obj+    return ()++data TocDumpMethodInfo+instance (signature ~ (m ()), MonadIO m) => MethodInfo TocDumpMethodInfo Toc signature where+    overloadedMethod _ = tocDump++-- method Toc::find_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TocEntry"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_find_entry" gst_toc_find_entry :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    CString ->                              -- uid : TBasicType TUTF8+    IO (Ptr TocEntry)+++tocFindEntry ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> T.Text                               -- uid+    -> m TocEntry                           -- result+tocFindEntry _obj uid = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    uid' <- textToCString uid+    result <- gst_toc_find_entry _obj' uid'+    checkUnexpectedReturnNULL "gst_toc_find_entry" result+    result' <- (newBoxed TocEntry) result+    touchManagedPtr _obj+    freeMem uid'+    return result'++data TocFindEntryMethodInfo+instance (signature ~ (T.Text -> m TocEntry), MonadIO m) => MethodInfo TocFindEntryMethodInfo Toc signature where+    overloadedMethod _ = tocFindEntry++-- method Toc::get_entries+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "TocEntry")+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_get_entries" gst_toc_get_entries :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    IO (Ptr (GList (Ptr TocEntry)))+++tocGetEntries ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> m [TocEntry]                         -- result+tocGetEntries _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_get_entries _obj'+    checkUnexpectedReturnNULL "gst_toc_get_entries" result+    result' <- unpackGList result+    result'' <- mapM (newBoxed TocEntry) result'+    touchManagedPtr _obj+    return result''++data TocGetEntriesMethodInfo+instance (signature ~ (m [TocEntry]), MonadIO m) => MethodInfo TocGetEntriesMethodInfo Toc signature where+    overloadedMethod _ = tocGetEntries++-- method Toc::get_scope+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TocScope"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_get_scope" gst_toc_get_scope :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    IO CUInt+++tocGetScope ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> m TocScope                           -- result+tocGetScope _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_get_scope _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data TocGetScopeMethodInfo+instance (signature ~ (m TocScope), MonadIO m) => MethodInfo TocGetScopeMethodInfo Toc signature where+    overloadedMethod _ = tocGetScope++-- method Toc::get_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_get_tags" gst_toc_get_tags :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    IO (Ptr TagList)+++tocGetTags ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> m TagList                            -- result+tocGetTags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_get_tags _obj'+    checkUnexpectedReturnNULL "gst_toc_get_tags" result+    result' <- (newBoxed TagList) result+    touchManagedPtr _obj+    return result'++data TocGetTagsMethodInfo+instance (signature ~ (m TagList), MonadIO m) => MethodInfo TocGetTagsMethodInfo Toc signature where+    overloadedMethod _ = tocGetTags++-- method Toc::merge_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_merge_tags" gst_toc_merge_tags :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO ()+++tocMergeTags ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> Maybe (TagList)                      -- tags+    -> TagMergeMode                         -- mode+    -> m ()                                 -- result+tocMergeTags _obj tags mode = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeTags <- case tags of+        Nothing -> return nullPtr+        Just jTags -> do+            let jTags' = unsafeManagedPtrGetPtr jTags+            return jTags'+    let mode' = (fromIntegral . fromEnum) mode+    gst_toc_merge_tags _obj' maybeTags mode'+    touchManagedPtr _obj+    whenJust tags touchManagedPtr+    return ()++data TocMergeTagsMethodInfo+instance (signature ~ (Maybe (TagList) -> TagMergeMode -> m ()), MonadIO m) => MethodInfo TocMergeTagsMethodInfo Toc signature where+    overloadedMethod _ = tocMergeTags++-- method Toc::set_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_set_tags" gst_toc_set_tags :: +    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"+    IO ()+++tocSetTags ::+    (MonadIO m) =>+    Toc                                     -- _obj+    -> Maybe (TagList)                      -- tags+    -> m ()                                 -- result+tocSetTags _obj tags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeTags <- case tags of+        Nothing -> return nullPtr+        Just jTags -> do+            jTags' <- copyBoxed jTags+            return jTags'+    gst_toc_set_tags _obj' maybeTags+    touchManagedPtr _obj+    whenJust tags touchManagedPtr+    return ()++data TocSetTagsMethodInfo+instance (signature ~ (Maybe (TagList) -> m ()), MonadIO m) => MethodInfo TocSetTagsMethodInfo Toc signature where+    overloadedMethod _ = tocSetTags++type family ResolveTocMethod (t :: Symbol) (o :: *) :: * where+    ResolveTocMethod "appendEntry" o = TocAppendEntryMethodInfo+    ResolveTocMethod "dump" o = TocDumpMethodInfo+    ResolveTocMethod "findEntry" o = TocFindEntryMethodInfo+    ResolveTocMethod "mergeTags" o = TocMergeTagsMethodInfo+    ResolveTocMethod "getEntries" o = TocGetEntriesMethodInfo+    ResolveTocMethod "getScope" o = TocGetScopeMethodInfo+    ResolveTocMethod "getTags" o = TocGetTagsMethodInfo+    ResolveTocMethod "setTags" o = TocSetTagsMethodInfo+    ResolveTocMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTocMethod t Toc, MethodInfo info Toc p) => IsLabelProxy t (Toc -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTocMethod t Toc, MethodInfo info Toc p) => IsLabel t (Toc -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Toc.hs-boot view
@@ -0,0 +1,19 @@+module GI.Gst.Structs.Toc 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++newtype Toc = Toc (ForeignPtr Toc)+instance BoxedObject Toc where+data TocAppendEntryMethodInfo+data TocDumpMethodInfo+data TocFindEntryMethodInfo+data TocGetEntriesMethodInfo+data TocGetScopeMethodInfo+data TocGetTagsMethodInfo+data TocMergeTagsMethodInfo+data TocSetTagsMethodInfo
+ GI/Gst/Structs/TocEntry.hs view
@@ -0,0 +1,645 @@+++{- |+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.Structs.TocEntry+    ( ++-- * Exported types+    TocEntry(..)                            ,+    noTocEntry                              ,+++ -- * Methods+-- ** tocEntryAppendSubEntry+    TocEntryAppendSubEntryMethodInfo        ,+    tocEntryAppendSubEntry                  ,+++-- ** tocEntryGetEntryType+    TocEntryGetEntryTypeMethodInfo          ,+    tocEntryGetEntryType                    ,+++-- ** tocEntryGetLoop+    TocEntryGetLoopMethodInfo               ,+    tocEntryGetLoop                         ,+++-- ** tocEntryGetParent+    TocEntryGetParentMethodInfo             ,+    tocEntryGetParent                       ,+++-- ** tocEntryGetStartStopTimes+    TocEntryGetStartStopTimesMethodInfo     ,+    tocEntryGetStartStopTimes               ,+++-- ** tocEntryGetSubEntries+    TocEntryGetSubEntriesMethodInfo         ,+    tocEntryGetSubEntries                   ,+++-- ** tocEntryGetTags+    TocEntryGetTagsMethodInfo               ,+    tocEntryGetTags                         ,+++-- ** tocEntryGetToc+    TocEntryGetTocMethodInfo                ,+    tocEntryGetToc                          ,+++-- ** tocEntryGetUid+    TocEntryGetUidMethodInfo                ,+    tocEntryGetUid                          ,+++-- ** tocEntryIsAlternative+    TocEntryIsAlternativeMethodInfo         ,+    tocEntryIsAlternative                   ,+++-- ** tocEntryIsSequence+    TocEntryIsSequenceMethodInfo            ,+    tocEntryIsSequence                      ,+++-- ** tocEntryMergeTags+    TocEntryMergeTagsMethodInfo             ,+    tocEntryMergeTags                       ,+++-- ** tocEntryNew+    tocEntryNew                             ,+++-- ** tocEntrySetLoop+    TocEntrySetLoopMethodInfo               ,+    tocEntrySetLoop                         ,+++-- ** tocEntrySetStartStopTimes+    TocEntrySetStartStopTimesMethodInfo     ,+    tocEntrySetStartStopTimes               ,+++-- ** tocEntrySetTags+    TocEntrySetTagsMethodInfo               ,+    tocEntrySetTags                         ,+++++    ) 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 GI.Gst.Callbacks++newtype TocEntry = TocEntry (ForeignPtr TocEntry)+foreign import ccall "gst_toc_entry_get_type" c_gst_toc_entry_get_type :: +    IO GType++instance BoxedObject TocEntry where+    boxedType _ = c_gst_toc_entry_get_type++noTocEntry :: Maybe TocEntry+noTocEntry = Nothing++-- method TocEntry::new+-- method type : Constructor+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "TocEntryType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TocEntry"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_new" gst_toc_entry_new :: +    CUInt ->                                -- type : TInterface "Gst" "TocEntryType"+    CString ->                              -- uid : TBasicType TUTF8+    IO (Ptr TocEntry)+++tocEntryNew ::+    (MonadIO m) =>+    TocEntryType                            -- type_+    -> T.Text                               -- uid+    -> m TocEntry                           -- result+tocEntryNew type_ uid = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    uid' <- textToCString uid+    result <- gst_toc_entry_new type_' uid'+    checkUnexpectedReturnNULL "gst_toc_entry_new" result+    result' <- (wrapBoxed TocEntry) result+    freeMem uid'+    return result'++-- method TocEntry::append_sub_entry+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subentry", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_append_sub_entry" gst_toc_entry_append_sub_entry :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    Ptr TocEntry ->                         -- subentry : TInterface "Gst" "TocEntry"+    IO ()+++tocEntryAppendSubEntry ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> TocEntry                             -- subentry+    -> m ()                                 -- result+tocEntryAppendSubEntry _obj subentry = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    subentry' <- copyBoxed subentry+    gst_toc_entry_append_sub_entry _obj' subentry'+    touchManagedPtr _obj+    touchManagedPtr subentry+    return ()++data TocEntryAppendSubEntryMethodInfo+instance (signature ~ (TocEntry -> m ()), MonadIO m) => MethodInfo TocEntryAppendSubEntryMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryAppendSubEntry++-- method TocEntry::get_entry_type+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TocEntryType"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_entry_type" gst_toc_entry_get_entry_type :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO CUInt+++tocEntryGetEntryType ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m TocEntryType                       -- result+tocEntryGetEntryType _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_get_entry_type _obj'+    let result' = (toEnum . fromIntegral) result+    touchManagedPtr _obj+    return result'++data TocEntryGetEntryTypeMethodInfo+instance (signature ~ (m TocEntryType), MonadIO m) => MethodInfo TocEntryGetEntryTypeMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetEntryType++-- method TocEntry::get_loop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "loop_type", argType = TInterface "Gst" "TocLoopType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "repeat_count", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_loop" gst_toc_entry_get_loop :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    Ptr CUInt ->                            -- loop_type : TInterface "Gst" "TocLoopType"+    Ptr Int32 ->                            -- repeat_count : TBasicType TInt32+    IO CInt+++tocEntryGetLoop ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m (Bool,TocLoopType,Int32)           -- result+tocEntryGetLoop _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    loopType <- allocMem :: IO (Ptr CUInt)+    repeatCount <- allocMem :: IO (Ptr Int32)+    result <- gst_toc_entry_get_loop _obj' loopType repeatCount+    let result' = (/= 0) result+    loopType' <- peek loopType+    let loopType'' = (toEnum . fromIntegral) loopType'+    repeatCount' <- peek repeatCount+    touchManagedPtr _obj+    freeMem loopType+    freeMem repeatCount+    return (result', loopType'', repeatCount')++data TocEntryGetLoopMethodInfo+instance (signature ~ (m (Bool,TocLoopType,Int32)), MonadIO m) => MethodInfo TocEntryGetLoopMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetLoop++-- method TocEntry::get_parent+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TocEntry"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_parent" gst_toc_entry_get_parent :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO (Ptr TocEntry)+++tocEntryGetParent ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m TocEntry                           -- result+tocEntryGetParent _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_get_parent _obj'+    checkUnexpectedReturnNULL "gst_toc_entry_get_parent" result+    result' <- (newBoxed TocEntry) result+    touchManagedPtr _obj+    return result'++data TocEntryGetParentMethodInfo+instance (signature ~ (m TocEntry), MonadIO m) => MethodInfo TocEntryGetParentMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetParent++-- method TocEntry::get_start_stop_times+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_start_stop_times" gst_toc_entry_get_start_stop_times :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    Ptr Int64 ->                            -- start : TBasicType TInt64+    Ptr Int64 ->                            -- stop : TBasicType TInt64+    IO CInt+++tocEntryGetStartStopTimes ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m (Bool,Int64,Int64)                 -- result+tocEntryGetStartStopTimes _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    start <- allocMem :: IO (Ptr Int64)+    stop <- allocMem :: IO (Ptr Int64)+    result <- gst_toc_entry_get_start_stop_times _obj' start stop+    let result' = (/= 0) result+    start' <- peek start+    stop' <- peek stop+    touchManagedPtr _obj+    freeMem start+    freeMem stop+    return (result', start', stop')++data TocEntryGetStartStopTimesMethodInfo+instance (signature ~ (m (Bool,Int64,Int64)), MonadIO m) => MethodInfo TocEntryGetStartStopTimesMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetStartStopTimes++-- method TocEntry::get_sub_entries+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TInterface "Gst" "TocEntry")+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_sub_entries" gst_toc_entry_get_sub_entries :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO (Ptr (GList (Ptr TocEntry)))+++tocEntryGetSubEntries ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m [TocEntry]                         -- result+tocEntryGetSubEntries _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_get_sub_entries _obj'+    checkUnexpectedReturnNULL "gst_toc_entry_get_sub_entries" result+    result' <- unpackGList result+    result'' <- mapM (newBoxed TocEntry) result'+    touchManagedPtr _obj+    return result''++data TocEntryGetSubEntriesMethodInfo+instance (signature ~ (m [TocEntry]), MonadIO m) => MethodInfo TocEntryGetSubEntriesMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetSubEntries++-- method TocEntry::get_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "TagList"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_tags" gst_toc_entry_get_tags :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO (Ptr TagList)+++tocEntryGetTags ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m TagList                            -- result+tocEntryGetTags _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_get_tags _obj'+    checkUnexpectedReturnNULL "gst_toc_entry_get_tags" result+    result' <- (newBoxed TagList) result+    touchManagedPtr _obj+    return result'++data TocEntryGetTagsMethodInfo+instance (signature ~ (m TagList), MonadIO m) => MethodInfo TocEntryGetTagsMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetTags++-- method TocEntry::get_toc+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Toc"+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_toc" gst_toc_entry_get_toc :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO (Ptr Toc)+++tocEntryGetToc ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m Toc                                -- result+tocEntryGetToc _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_get_toc _obj'+    checkUnexpectedReturnNULL "gst_toc_entry_get_toc" result+    result' <- (newBoxed Toc) result+    touchManagedPtr _obj+    return result'++data TocEntryGetTocMethodInfo+instance (signature ~ (m Toc), MonadIO m) => MethodInfo TocEntryGetTocMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetToc++-- method TocEntry::get_uid+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_get_uid" gst_toc_entry_get_uid :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO CString+++tocEntryGetUid ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m T.Text                             -- result+tocEntryGetUid _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_get_uid _obj'+    checkUnexpectedReturnNULL "gst_toc_entry_get_uid" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data TocEntryGetUidMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo TocEntryGetUidMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryGetUid++-- method TocEntry::is_alternative+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_is_alternative" gst_toc_entry_is_alternative :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO CInt+++tocEntryIsAlternative ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m Bool                               -- result+tocEntryIsAlternative _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_is_alternative _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TocEntryIsAlternativeMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo TocEntryIsAlternativeMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryIsAlternative++-- method TocEntry::is_sequence+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_is_sequence" gst_toc_entry_is_sequence :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    IO CInt+++tocEntryIsSequence ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> m Bool                               -- result+tocEntryIsSequence _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_toc_entry_is_sequence _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data TocEntryIsSequenceMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo TocEntryIsSequenceMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryIsSequence++-- method TocEntry::merge_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_merge_tags" gst_toc_entry_merge_tags :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"+    IO ()+++tocEntryMergeTags ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> Maybe (TagList)                      -- tags+    -> TagMergeMode                         -- mode+    -> m ()                                 -- result+tocEntryMergeTags _obj tags mode = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeTags <- case tags of+        Nothing -> return nullPtr+        Just jTags -> do+            let jTags' = unsafeManagedPtrGetPtr jTags+            return jTags'+    let mode' = (fromIntegral . fromEnum) mode+    gst_toc_entry_merge_tags _obj' maybeTags mode'+    touchManagedPtr _obj+    whenJust tags touchManagedPtr+    return ()++data TocEntryMergeTagsMethodInfo+instance (signature ~ (Maybe (TagList) -> TagMergeMode -> m ()), MonadIO m) => MethodInfo TocEntryMergeTagsMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntryMergeTags++-- method TocEntry::set_loop+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "loop_type", argType = TInterface "Gst" "TocLoopType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "repeat_count", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_set_loop" gst_toc_entry_set_loop :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    CUInt ->                                -- loop_type : TInterface "Gst" "TocLoopType"+    Int32 ->                                -- repeat_count : TBasicType TInt32+    IO ()+++tocEntrySetLoop ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> TocLoopType                          -- loopType+    -> Int32                                -- repeatCount+    -> m ()                                 -- result+tocEntrySetLoop _obj loopType repeatCount = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let loopType' = (fromIntegral . fromEnum) loopType+    gst_toc_entry_set_loop _obj' loopType' repeatCount+    touchManagedPtr _obj+    return ()++data TocEntrySetLoopMethodInfo+instance (signature ~ (TocLoopType -> Int32 -> m ()), MonadIO m) => MethodInfo TocEntrySetLoopMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntrySetLoop++-- method TocEntry::set_start_stop_times+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_set_start_stop_times" gst_toc_entry_set_start_stop_times :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    Int64 ->                                -- start : TBasicType TInt64+    Int64 ->                                -- stop : TBasicType TInt64+    IO ()+++tocEntrySetStartStopTimes ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> Int64                                -- start+    -> Int64                                -- stop+    -> m ()                                 -- result+tocEntrySetStartStopTimes _obj start stop = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    gst_toc_entry_set_start_stop_times _obj' start stop+    touchManagedPtr _obj+    return ()++data TocEntrySetStartStopTimesMethodInfo+instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo TocEntrySetStartStopTimesMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntrySetStartStopTimes++-- method TocEntry::set_tags+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_toc_entry_set_tags" gst_toc_entry_set_tags :: +    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"+    IO ()+++tocEntrySetTags ::+    (MonadIO m) =>+    TocEntry                                -- _obj+    -> Maybe (TagList)                      -- tags+    -> m ()                                 -- result+tocEntrySetTags _obj tags = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeTags <- case tags of+        Nothing -> return nullPtr+        Just jTags -> do+            jTags' <- copyBoxed jTags+            return jTags'+    gst_toc_entry_set_tags _obj' maybeTags+    touchManagedPtr _obj+    whenJust tags touchManagedPtr+    return ()++data TocEntrySetTagsMethodInfo+instance (signature ~ (Maybe (TagList) -> m ()), MonadIO m) => MethodInfo TocEntrySetTagsMethodInfo TocEntry signature where+    overloadedMethod _ = tocEntrySetTags++type family ResolveTocEntryMethod (t :: Symbol) (o :: *) :: * where+    ResolveTocEntryMethod "appendSubEntry" o = TocEntryAppendSubEntryMethodInfo+    ResolveTocEntryMethod "isAlternative" o = TocEntryIsAlternativeMethodInfo+    ResolveTocEntryMethod "isSequence" o = TocEntryIsSequenceMethodInfo+    ResolveTocEntryMethod "mergeTags" o = TocEntryMergeTagsMethodInfo+    ResolveTocEntryMethod "getEntryType" o = TocEntryGetEntryTypeMethodInfo+    ResolveTocEntryMethod "getLoop" o = TocEntryGetLoopMethodInfo+    ResolveTocEntryMethod "getParent" o = TocEntryGetParentMethodInfo+    ResolveTocEntryMethod "getStartStopTimes" o = TocEntryGetStartStopTimesMethodInfo+    ResolveTocEntryMethod "getSubEntries" o = TocEntryGetSubEntriesMethodInfo+    ResolveTocEntryMethod "getTags" o = TocEntryGetTagsMethodInfo+    ResolveTocEntryMethod "getToc" o = TocEntryGetTocMethodInfo+    ResolveTocEntryMethod "getUid" o = TocEntryGetUidMethodInfo+    ResolveTocEntryMethod "setLoop" o = TocEntrySetLoopMethodInfo+    ResolveTocEntryMethod "setStartStopTimes" o = TocEntrySetStartStopTimesMethodInfo+    ResolveTocEntryMethod "setTags" o = TocEntrySetTagsMethodInfo+    ResolveTocEntryMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTocEntryMethod t TocEntry, MethodInfo info TocEntry p) => IsLabelProxy t (TocEntry -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTocEntryMethod t TocEntry, MethodInfo info TocEntry p) => IsLabel t (TocEntry -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/TocEntry.hs-boot view
@@ -0,0 +1,26 @@+module GI.Gst.Structs.TocEntry 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++newtype TocEntry = TocEntry (ForeignPtr TocEntry)+instance BoxedObject TocEntry where+data TocEntryAppendSubEntryMethodInfo+data TocEntryGetEntryTypeMethodInfo+data TocEntryGetLoopMethodInfo+data TocEntryGetParentMethodInfo+data TocEntryGetStartStopTimesMethodInfo+data TocEntryGetSubEntriesMethodInfo+data TocEntryGetTagsMethodInfo+data TocEntryGetTocMethodInfo+data TocEntryGetUidMethodInfo+data TocEntryIsAlternativeMethodInfo+data TocEntryIsSequenceMethodInfo+data TocEntryMergeTagsMethodInfo+data TocEntrySetLoopMethodInfo+data TocEntrySetStartStopTimesMethodInfo+data TocEntrySetTagsMethodInfo
+ GI/Gst/Structs/TypeFind.hs view
@@ -0,0 +1,244 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++The following functions allow you to detect the media type of an unknown+stream.+-}++module GI.Gst.Structs.TypeFind+    ( ++-- * Exported types+    TypeFind(..)                            ,+    newZeroTypeFind                         ,+    noTypeFind                              ,+++ -- * Methods+-- ** typeFindGetLength+    TypeFindGetLengthMethodInfo             ,+    typeFindGetLength                       ,+++-- ** typeFindPeek+    TypeFindPeekMethodInfo                  ,+    typeFindPeek                            ,+++-- ** typeFindRegister+    typeFindRegister                        ,+++-- ** typeFindSuggest+    TypeFindSuggestMethodInfo               ,+    typeFindSuggest                         ,+++++ -- * Properties+-- ** Data+    typeFindReadData                        ,+++++    ) 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 GI.Gst.Callbacks+import qualified GI.GLib as GLib++newtype TypeFind = TypeFind (ForeignPtr TypeFind)+-- | Construct a `TypeFind` struct initialized to zero.+newZeroTypeFind :: MonadIO m => m TypeFind+newZeroTypeFind = liftIO $ callocBytes 64 >>= wrapPtr TypeFind++noTypeFind :: Maybe TypeFind+noTypeFind = Nothing++-- XXX Skipped getter for "TypeFind:peek" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "TypeFind:suggest" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++typeFindReadData :: TypeFind -> IO (Ptr ())+typeFindReadData s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr ())+    return val++-- XXX Skipped getter for "TypeFind:get_length" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- method TypeFind::get_length+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt64+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_get_length" gst_type_find_get_length :: +    Ptr TypeFind ->                         -- _obj : TInterface "Gst" "TypeFind"+    IO Word64+++typeFindGetLength ::+    (MonadIO m) =>+    TypeFind                                -- _obj+    -> m Word64                             -- result+typeFindGetLength _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_type_find_get_length _obj'+    touchManagedPtr _obj+    return result++data TypeFindGetLengthMethodInfo+instance (signature ~ (m Word64), MonadIO m) => MethodInfo TypeFindGetLengthMethodInfo TypeFind signature where+    overloadedMethod _ = typeFindGetLength++-- method TypeFind::peek+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- returnType : TCArray False (-1) 2 (TBasicType TUInt8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_peek" gst_type_find_peek :: +    Ptr TypeFind ->                         -- _obj : TInterface "Gst" "TypeFind"+    Int64 ->                                -- offset : TBasicType TInt64+    Ptr Word32 ->                           -- size : TBasicType TUInt32+    IO (Ptr Word8)+++typeFindPeek ::+    (MonadIO m) =>+    TypeFind                                -- _obj+    -> Int64                                -- offset+    -> m ByteString                         -- result+typeFindPeek _obj offset = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    size <- allocMem :: IO (Ptr Word32)+    result <- gst_type_find_peek _obj' offset size+    size' <- peek size+    checkUnexpectedReturnNULL "gst_type_find_peek" result+    result' <- (unpackByteStringWithLength size') result+    touchManagedPtr _obj+    freeMem size+    return result'++data TypeFindPeekMethodInfo+instance (signature ~ (Int64 -> m ByteString), MonadIO m) => MethodInfo TypeFindPeekMethodInfo TypeFind signature where+    overloadedMethod _ = typeFindPeek++-- method TypeFind::suggest+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "probability", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TVoid+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_suggest" gst_type_find_suggest :: +    Ptr TypeFind ->                         -- _obj : TInterface "Gst" "TypeFind"+    Word32 ->                               -- probability : TBasicType TUInt32+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"+    IO ()+++typeFindSuggest ::+    (MonadIO m) =>+    TypeFind                                -- _obj+    -> Word32                               -- probability+    -> Caps                                 -- caps+    -> m ()                                 -- result+typeFindSuggest _obj probability caps = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let caps' = unsafeManagedPtrGetPtr caps+    gst_type_find_suggest _obj' probability caps'+    touchManagedPtr _obj+    touchManagedPtr caps+    return ()++data TypeFindSuggestMethodInfo+instance (signature ~ (Word32 -> Caps -> m ()), MonadIO m) => MethodInfo TypeFindSuggestMethodInfo TypeFind signature where+    overloadedMethod _ = typeFindSuggest++-- method TypeFind::register+-- method type : MemberFunction+-- Args : [Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TypeFindFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 6, argDestroy = 7, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "extensions", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "possible_caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_type_find_register" gst_type_find_register :: +    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"+    CString ->                              -- name : TBasicType TUTF8+    Word32 ->                               -- rank : TBasicType TUInt32+    FunPtr TypeFindFunctionC ->             -- func : TInterface "Gst" "TypeFindFunction"+    CString ->                              -- extensions : TBasicType TUTF8+    Ptr Caps ->                             -- possible_caps : TInterface "Gst" "Caps"+    Ptr () ->                               -- data : TBasicType TVoid+    FunPtr GLib.DestroyNotifyC ->           -- data_notify : TInterface "GLib" "DestroyNotify"+    IO CInt+++typeFindRegister ::+    (MonadIO m, PluginK a) =>+    Maybe (a)                               -- plugin+    -> T.Text                               -- name+    -> Word32                               -- rank+    -> TypeFindFunction                     -- func+    -> Maybe (T.Text)                       -- extensions+    -> Caps                                 -- possibleCaps+    -> m Bool                               -- result+typeFindRegister plugin name rank func extensions possibleCaps = liftIO $ do+    maybePlugin <- case plugin of+        Nothing -> return nullPtr+        Just jPlugin -> do+            let jPlugin' = unsafeManagedPtrCastPtr jPlugin+            return jPlugin'+    name' <- textToCString name+    func' <- mkTypeFindFunction (typeFindFunctionWrapper Nothing func)+    maybeExtensions <- case extensions of+        Nothing -> return nullPtr+        Just jExtensions -> do+            jExtensions' <- textToCString jExtensions+            return jExtensions'+    let possibleCaps' = unsafeManagedPtrGetPtr possibleCaps+    let data_ = castFunPtrToPtr func'+    let dataNotify = safeFreeFunPtrPtr+    result <- gst_type_find_register maybePlugin name' rank func' maybeExtensions possibleCaps' data_ dataNotify+    let result' = (/= 0) result+    whenJust plugin touchManagedPtr+    touchManagedPtr possibleCaps+    freeMem name'+    freeMem maybeExtensions+    return result'++type family ResolveTypeFindMethod (t :: Symbol) (o :: *) :: * where+    ResolveTypeFindMethod "peek" o = TypeFindPeekMethodInfo+    ResolveTypeFindMethod "suggest" o = TypeFindSuggestMethodInfo+    ResolveTypeFindMethod "getLength" o = TypeFindGetLengthMethodInfo+    ResolveTypeFindMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveTypeFindMethod t TypeFind, MethodInfo info TypeFind p) => IsLabelProxy t (TypeFind -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveTypeFindMethod t TypeFind, MethodInfo info TypeFind p) => IsLabel t (TypeFind -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/TypeFind.hs-boot view
@@ -0,0 +1,13 @@+module GI.Gst.Structs.TypeFind 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++newtype TypeFind = TypeFind (ForeignPtr TypeFind)+data TypeFindGetLengthMethodInfo+data TypeFindPeekMethodInfo+data TypeFindSuggestMethodInfo
+ GI/Gst/Structs/Uri.hs view
@@ -0,0 +1,1811 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++A #GstUri object can be used to parse and split a URI string into its+constituant parts. Two #GstUri objects can be joined to make a new #GstUri+using the algorithm described in RFC3986.+-}++module GI.Gst.Structs.Uri+    ( ++-- * Exported types+    Uri(..)                                 ,+    noUri                                   ,+++ -- * Methods+-- ** uriAppendPath+    UriAppendPathMethodInfo                 ,+    uriAppendPath                           ,+++-- ** uriAppendPathSegment+    UriAppendPathSegmentMethodInfo          ,+    uriAppendPathSegment                    ,+++-- ** uriConstruct+    uriConstruct                            ,+++-- ** uriEqual+    UriEqualMethodInfo                      ,+    uriEqual                                ,+++-- ** uriFromString+    uriFromString                           ,+++-- ** uriFromStringWithBase+    UriFromStringWithBaseMethodInfo         ,+    uriFromStringWithBase                   ,+++-- ** uriGetFragment+    UriGetFragmentMethodInfo                ,+    uriGetFragment                          ,+++-- ** uriGetHost+    UriGetHostMethodInfo                    ,+    uriGetHost                              ,+++-- ** uriGetLocation+    uriGetLocation                          ,+++-- ** uriGetPath+    UriGetPathMethodInfo                    ,+    uriGetPath                              ,+++-- ** uriGetPathSegments+    UriGetPathSegmentsMethodInfo            ,+    uriGetPathSegments                      ,+++-- ** uriGetPathString+    UriGetPathStringMethodInfo              ,+    uriGetPathString                        ,+++-- ** uriGetPort+    UriGetPortMethodInfo                    ,+    uriGetPort                              ,+++-- ** uriGetProtocol+    uriGetProtocol                          ,+++-- ** uriGetQueryKeys+    UriGetQueryKeysMethodInfo               ,+    uriGetQueryKeys                         ,+++-- ** uriGetQueryString+    UriGetQueryStringMethodInfo             ,+    uriGetQueryString                       ,+++-- ** uriGetQueryTable+    UriGetQueryTableMethodInfo              ,+    uriGetQueryTable                        ,+++-- ** uriGetQueryValue+    UriGetQueryValueMethodInfo              ,+    uriGetQueryValue                        ,+++-- ** uriGetScheme+    UriGetSchemeMethodInfo                  ,+    uriGetScheme                            ,+++-- ** uriGetUserinfo+    UriGetUserinfoMethodInfo                ,+    uriGetUserinfo                          ,+++-- ** uriHasProtocol+    uriHasProtocol                          ,+++-- ** uriIsNormalized+    UriIsNormalizedMethodInfo               ,+    uriIsNormalized                         ,+++-- ** uriIsValid+    uriIsValid                              ,+++-- ** uriIsWritable+    UriIsWritableMethodInfo                 ,+    uriIsWritable                           ,+++-- ** uriJoin+    UriJoinMethodInfo                       ,+    uriJoin                                 ,+++-- ** uriJoinStrings+    uriJoinStrings                          ,+++-- ** uriMakeWritable+    UriMakeWritableMethodInfo               ,+    uriMakeWritable                         ,+++-- ** uriNew+    uriNew                                  ,+++-- ** uriNewWithBase+    UriNewWithBaseMethodInfo                ,+    uriNewWithBase                          ,+++-- ** uriNormalize+    UriNormalizeMethodInfo                  ,+    uriNormalize                            ,+++-- ** uriProtocolIsSupported+    uriProtocolIsSupported                  ,+++-- ** uriProtocolIsValid+    uriProtocolIsValid                      ,+++-- ** uriQueryHasKey+    UriQueryHasKeyMethodInfo                ,+    uriQueryHasKey                          ,+++-- ** uriRemoveQueryKey+    UriRemoveQueryKeyMethodInfo             ,+    uriRemoveQueryKey                       ,+++-- ** uriSetFragment+    UriSetFragmentMethodInfo                ,+    uriSetFragment                          ,+++-- ** uriSetHost+    UriSetHostMethodInfo                    ,+    uriSetHost                              ,+++-- ** uriSetPath+    UriSetPathMethodInfo                    ,+    uriSetPath                              ,+++-- ** uriSetPathSegments+    UriSetPathSegmentsMethodInfo            ,+    uriSetPathSegments                      ,+++-- ** uriSetPathString+    UriSetPathStringMethodInfo              ,+    uriSetPathString                        ,+++-- ** uriSetPort+    UriSetPortMethodInfo                    ,+    uriSetPort                              ,+++-- ** uriSetQueryString+    UriSetQueryStringMethodInfo             ,+    uriSetQueryString                       ,+++-- ** uriSetQueryTable+    UriSetQueryTableMethodInfo              ,+    uriSetQueryTable                        ,+++-- ** uriSetQueryValue+    UriSetQueryValueMethodInfo              ,+    uriSetQueryValue                        ,+++-- ** uriSetScheme+    UriSetSchemeMethodInfo                  ,+    uriSetScheme                            ,+++-- ** uriSetUserinfo+    UriSetUserinfoMethodInfo                ,+    uriSetUserinfo                          ,+++-- ** uriToString+    UriToStringMethodInfo                   ,+    uriToString                             ,+++++    ) 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 GI.Gst.Callbacks++newtype Uri = Uri (ForeignPtr Uri)+foreign import ccall "gst_uri_get_type" c_gst_uri_get_type :: +    IO GType++instance BoxedObject Uri where+    boxedType _ = c_gst_uri_get_type++noUri :: Maybe Uri+noUri = Nothing++-- method Uri::new+-- method type : Constructor+-- Args : [Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "userinfo", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fragment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Uri"+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_new" gst_uri_new :: +    CString ->                              -- scheme : TBasicType TUTF8+    CString ->                              -- userinfo : TBasicType TUTF8+    CString ->                              -- host : TBasicType TUTF8+    Word32 ->                               -- port : TBasicType TUInt32+    CString ->                              -- path : TBasicType TUTF8+    CString ->                              -- query : TBasicType TUTF8+    CString ->                              -- fragment : TBasicType TUTF8+    IO (Ptr Uri)+++uriNew ::+    (MonadIO m) =>+    Maybe (T.Text)                          -- scheme+    -> Maybe (T.Text)                       -- userinfo+    -> Maybe (T.Text)                       -- host+    -> Word32                               -- port+    -> Maybe (T.Text)                       -- path+    -> Maybe (T.Text)                       -- query+    -> Maybe (T.Text)                       -- fragment+    -> m Uri                                -- result+uriNew scheme userinfo host port path query fragment = liftIO $ do+    maybeScheme <- case scheme of+        Nothing -> return nullPtr+        Just jScheme -> do+            jScheme' <- textToCString jScheme+            return jScheme'+    maybeUserinfo <- case userinfo of+        Nothing -> return nullPtr+        Just jUserinfo -> do+            jUserinfo' <- textToCString jUserinfo+            return jUserinfo'+    maybeHost <- case host of+        Nothing -> return nullPtr+        Just jHost -> do+            jHost' <- textToCString jHost+            return jHost'+    maybePath <- case path of+        Nothing -> return nullPtr+        Just jPath -> do+            jPath' <- textToCString jPath+            return jPath'+    maybeQuery <- case query of+        Nothing -> return nullPtr+        Just jQuery -> do+            jQuery' <- textToCString jQuery+            return jQuery'+    maybeFragment <- case fragment of+        Nothing -> return nullPtr+        Just jFragment -> do+            jFragment' <- textToCString jFragment+            return jFragment'+    result <- gst_uri_new maybeScheme maybeUserinfo maybeHost port maybePath maybeQuery maybeFragment+    checkUnexpectedReturnNULL "gst_uri_new" result+    result' <- (wrapBoxed Uri) result+    freeMem maybeScheme+    freeMem maybeUserinfo+    freeMem maybeHost+    freeMem maybePath+    freeMem maybeQuery+    freeMem maybeFragment+    return result'++-- method Uri::append_path+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "relative_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_append_path" gst_uri_append_path :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- relative_path : TBasicType TUTF8+    IO CInt+++uriAppendPath ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- relativePath+    -> m Bool                               -- result+uriAppendPath _obj relativePath = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    relativePath' <- textToCString relativePath+    result <- gst_uri_append_path _obj' relativePath'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem relativePath'+    return result'++data UriAppendPathMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriAppendPathMethodInfo Uri signature where+    overloadedMethod _ = uriAppendPath++-- method Uri::append_path_segment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_segment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_append_path_segment" gst_uri_append_path_segment :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- path_segment : TBasicType TUTF8+    IO CInt+++uriAppendPathSegment ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- pathSegment+    -> m Bool                               -- result+uriAppendPathSegment _obj pathSegment = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    pathSegment' <- textToCString pathSegment+    result <- gst_uri_append_path_segment _obj' pathSegment'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem pathSegment'+    return result'++data UriAppendPathSegmentMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriAppendPathSegmentMethodInfo Uri signature where+    overloadedMethod _ = uriAppendPathSegment++-- method Uri::equal+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "second", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_equal" gst_uri_equal :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    Ptr Uri ->                              -- second : TInterface "Gst" "Uri"+    IO CInt+++uriEqual ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> Uri                                  -- second+    -> m Bool                               -- result+uriEqual _obj second = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    let second' = unsafeManagedPtrGetPtr second+    result <- gst_uri_equal _obj' second'+    let result' = (/= 0) result+    touchManagedPtr _obj+    touchManagedPtr second+    return result'++data UriEqualMethodInfo+instance (signature ~ (Uri -> m Bool), MonadIO m) => MethodInfo UriEqualMethodInfo Uri signature where+    overloadedMethod _ = uriEqual++-- method Uri::from_string_with_base+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Uri"+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_from_string_with_base" gst_uri_from_string_with_base :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- uri : TBasicType TUTF8+    IO (Ptr Uri)+++uriFromStringWithBase ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- uri+    -> m Uri                                -- result+uriFromStringWithBase _obj uri = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    uri' <- textToCString uri+    result <- gst_uri_from_string_with_base _obj' uri'+    checkUnexpectedReturnNULL "gst_uri_from_string_with_base" result+    result' <- (wrapBoxed Uri) result+    touchManagedPtr _obj+    freeMem uri'+    return result'++data UriFromStringWithBaseMethodInfo+instance (signature ~ (T.Text -> m Uri), MonadIO m) => MethodInfo UriFromStringWithBaseMethodInfo Uri signature where+    overloadedMethod _ = uriFromStringWithBase++-- method Uri::get_fragment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_fragment" gst_uri_get_fragment :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriGetFragment ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriGetFragment _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_fragment _obj'+    checkUnexpectedReturnNULL "gst_uri_get_fragment" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data UriGetFragmentMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetFragmentMethodInfo Uri signature where+    overloadedMethod _ = uriGetFragment++-- method Uri::get_host+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_host" gst_uri_get_host :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriGetHost ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriGetHost _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_host _obj'+    checkUnexpectedReturnNULL "gst_uri_get_host" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data UriGetHostMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetHostMethodInfo Uri signature where+    overloadedMethod _ = uriGetHost++-- method Uri::get_path+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_path" gst_uri_get_path :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriGetPath ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriGetPath _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_path _obj'+    checkUnexpectedReturnNULL "gst_uri_get_path" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data UriGetPathMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetPathMethodInfo Uri signature where+    overloadedMethod _ = uriGetPath++-- method Uri::get_path_segments+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_path_segments" gst_uri_get_path_segments :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO (Ptr (GList CString))+++uriGetPathSegments ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m [T.Text]                           -- result+uriGetPathSegments _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_path_segments _obj'+    checkUnexpectedReturnNULL "gst_uri_get_path_segments" result+    result' <- unpackGList result+    result'' <- mapM cstringToText result'+    mapGList freeMem result+    g_list_free result+    touchManagedPtr _obj+    return result''++data UriGetPathSegmentsMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m) => MethodInfo UriGetPathSegmentsMethodInfo Uri signature where+    overloadedMethod _ = uriGetPathSegments++-- method Uri::get_path_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_path_string" gst_uri_get_path_string :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriGetPathString ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriGetPathString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_path_string _obj'+    checkUnexpectedReturnNULL "gst_uri_get_path_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data UriGetPathStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetPathStringMethodInfo Uri signature where+    overloadedMethod _ = uriGetPathString++-- method Uri::get_port+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUInt32+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_port" gst_uri_get_port :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO Word32+++uriGetPort ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m Word32                             -- result+uriGetPort _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_port _obj'+    touchManagedPtr _obj+    return result++data UriGetPortMethodInfo+instance (signature ~ (m Word32), MonadIO m) => MethodInfo UriGetPortMethodInfo Uri signature where+    overloadedMethod _ = uriGetPort++-- method Uri::get_query_keys+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGList (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_query_keys" gst_uri_get_query_keys :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO (Ptr (GList CString))+++uriGetQueryKeys ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m [T.Text]                           -- result+uriGetQueryKeys _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_query_keys _obj'+    checkUnexpectedReturnNULL "gst_uri_get_query_keys" result+    result' <- unpackGList result+    result'' <- mapM cstringToText result'+    g_list_free result+    touchManagedPtr _obj+    return result''++data UriGetQueryKeysMethodInfo+instance (signature ~ (m [T.Text]), MonadIO m) => MethodInfo UriGetQueryKeysMethodInfo Uri signature where+    overloadedMethod _ = uriGetQueryKeys++-- method Uri::get_query_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_query_string" gst_uri_get_query_string :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriGetQueryString ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriGetQueryString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_query_string _obj'+    checkUnexpectedReturnNULL "gst_uri_get_query_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data UriGetQueryStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetQueryStringMethodInfo Uri signature where+    overloadedMethod _ = uriGetQueryString++-- method Uri::get_query_table+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TGHash (TBasicType TUTF8) (TBasicType TUTF8)+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_query_table" gst_uri_get_query_table :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO (Ptr (GHashTable CString CString))+++uriGetQueryTable ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m (Map.Map T.Text T.Text)            -- result+uriGetQueryTable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_query_table _obj'+    checkUnexpectedReturnNULL "gst_uri_get_query_table" result+    result' <- unpackGHashTable result+    let result'' = mapFirst cstringUnpackPtr result'+    result''' <- mapFirstA cstringToText result''+    let result'''' = mapSecond cstringUnpackPtr result'''+    result''''' <- mapSecondA cstringToText result''''+    let result'''''' = Map.fromList result'''''+    unrefGHashTable result+    touchManagedPtr _obj+    return result''''''++data UriGetQueryTableMethodInfo+instance (signature ~ (m (Map.Map T.Text T.Text)), MonadIO m) => MethodInfo UriGetQueryTableMethodInfo Uri signature where+    overloadedMethod _ = uriGetQueryTable++-- method Uri::get_query_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_query_value" gst_uri_get_query_value :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- query_key : TBasicType TUTF8+    IO CString+++uriGetQueryValue ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- queryKey+    -> m T.Text                             -- result+uriGetQueryValue _obj queryKey = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    queryKey' <- textToCString queryKey+    result <- gst_uri_get_query_value _obj' queryKey'+    checkUnexpectedReturnNULL "gst_uri_get_query_value" result+    result' <- cstringToText result+    touchManagedPtr _obj+    freeMem queryKey'+    return result'++data UriGetQueryValueMethodInfo+instance (signature ~ (T.Text -> m T.Text), MonadIO m) => MethodInfo UriGetQueryValueMethodInfo Uri signature where+    overloadedMethod _ = uriGetQueryValue++-- method Uri::get_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_scheme" gst_uri_get_scheme :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriGetScheme ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriGetScheme _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_scheme _obj'+    checkUnexpectedReturnNULL "gst_uri_get_scheme" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data UriGetSchemeMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetSchemeMethodInfo Uri signature where+    overloadedMethod _ = uriGetScheme++-- method Uri::get_userinfo+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_userinfo" gst_uri_get_userinfo :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriGetUserinfo ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriGetUserinfo _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_get_userinfo _obj'+    checkUnexpectedReturnNULL "gst_uri_get_userinfo" result+    result' <- cstringToText result+    touchManagedPtr _obj+    return result'++data UriGetUserinfoMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetUserinfoMethodInfo Uri signature where+    overloadedMethod _ = uriGetUserinfo++-- method Uri::is_normalized+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_is_normalized" gst_uri_is_normalized :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CInt+++uriIsNormalized ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m Bool                               -- result+uriIsNormalized _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_is_normalized _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data UriIsNormalizedMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo UriIsNormalizedMethodInfo Uri signature where+    overloadedMethod _ = uriIsNormalized++-- method Uri::is_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_is_writable" gst_uri_is_writable :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CInt+++uriIsWritable ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m Bool                               -- result+uriIsWritable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_is_writable _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data UriIsWritableMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo UriIsWritableMethodInfo Uri signature where+    overloadedMethod _ = uriIsWritable++-- method Uri::join+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_uri", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Uri"+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_join" gst_uri_join :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    Ptr Uri ->                              -- ref_uri : TInterface "Gst" "Uri"+    IO (Ptr Uri)+++uriJoin ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> Maybe (Uri)                          -- refUri+    -> m Uri                                -- result+uriJoin _obj refUri = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeRefUri <- case refUri of+        Nothing -> return nullPtr+        Just jRefUri -> do+            let jRefUri' = unsafeManagedPtrGetPtr jRefUri+            return jRefUri'+    result <- gst_uri_join _obj' maybeRefUri+    checkUnexpectedReturnNULL "gst_uri_join" result+    result' <- (wrapBoxed Uri) result+    touchManagedPtr _obj+    whenJust refUri touchManagedPtr+    return result'++data UriJoinMethodInfo+instance (signature ~ (Maybe (Uri) -> m Uri), MonadIO m) => MethodInfo UriJoinMethodInfo Uri signature where+    overloadedMethod _ = uriJoin++-- method Uri::make_writable+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Uri"+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_make_writable" gst_uri_make_writable :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO (Ptr Uri)+++uriMakeWritable ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m Uri                                -- result+uriMakeWritable _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_make_writable _obj'+    checkUnexpectedReturnNULL "gst_uri_make_writable" result+    result' <- (wrapBoxed Uri) result+    touchManagedPtr _obj+    return result'++data UriMakeWritableMethodInfo+instance (signature ~ (m Uri), MonadIO m) => MethodInfo UriMakeWritableMethodInfo Uri signature where+    overloadedMethod _ = uriMakeWritable++-- method Uri::new_with_base+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "userinfo", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fragment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Uri"+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_new_with_base" gst_uri_new_with_base :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- scheme : TBasicType TUTF8+    CString ->                              -- userinfo : TBasicType TUTF8+    CString ->                              -- host : TBasicType TUTF8+    Word32 ->                               -- port : TBasicType TUInt32+    CString ->                              -- path : TBasicType TUTF8+    CString ->                              -- query : TBasicType TUTF8+    CString ->                              -- fragment : TBasicType TUTF8+    IO (Ptr Uri)+++uriNewWithBase ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> Maybe (T.Text)                       -- scheme+    -> Maybe (T.Text)                       -- userinfo+    -> Maybe (T.Text)                       -- host+    -> Word32                               -- port+    -> Maybe (T.Text)                       -- path+    -> Maybe (T.Text)                       -- query+    -> Maybe (T.Text)                       -- fragment+    -> m Uri                                -- result+uriNewWithBase _obj scheme userinfo host port path query fragment = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeScheme <- case scheme of+        Nothing -> return nullPtr+        Just jScheme -> do+            jScheme' <- textToCString jScheme+            return jScheme'+    maybeUserinfo <- case userinfo of+        Nothing -> return nullPtr+        Just jUserinfo -> do+            jUserinfo' <- textToCString jUserinfo+            return jUserinfo'+    maybeHost <- case host of+        Nothing -> return nullPtr+        Just jHost -> do+            jHost' <- textToCString jHost+            return jHost'+    maybePath <- case path of+        Nothing -> return nullPtr+        Just jPath -> do+            jPath' <- textToCString jPath+            return jPath'+    maybeQuery <- case query of+        Nothing -> return nullPtr+        Just jQuery -> do+            jQuery' <- textToCString jQuery+            return jQuery'+    maybeFragment <- case fragment of+        Nothing -> return nullPtr+        Just jFragment -> do+            jFragment' <- textToCString jFragment+            return jFragment'+    result <- gst_uri_new_with_base _obj' maybeScheme maybeUserinfo maybeHost port maybePath maybeQuery maybeFragment+    checkUnexpectedReturnNULL "gst_uri_new_with_base" result+    result' <- (wrapBoxed Uri) result+    touchManagedPtr _obj+    freeMem maybeScheme+    freeMem maybeUserinfo+    freeMem maybeHost+    freeMem maybePath+    freeMem maybeQuery+    freeMem maybeFragment+    return result'++data UriNewWithBaseMethodInfo+instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Word32 -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m Uri), MonadIO m) => MethodInfo UriNewWithBaseMethodInfo Uri signature where+    overloadedMethod _ = uriNewWithBase++-- method Uri::normalize+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_normalize" gst_uri_normalize :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CInt+++uriNormalize ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m Bool                               -- result+uriNormalize _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_normalize _obj'+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data UriNormalizeMethodInfo+instance (signature ~ (m Bool), MonadIO m) => MethodInfo UriNormalizeMethodInfo Uri signature where+    overloadedMethod _ = uriNormalize++-- method Uri::query_has_key+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_query_has_key" gst_uri_query_has_key :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- query_key : TBasicType TUTF8+    IO CInt+++uriQueryHasKey ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- queryKey+    -> m Bool                               -- result+uriQueryHasKey _obj queryKey = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    queryKey' <- textToCString queryKey+    result <- gst_uri_query_has_key _obj' queryKey'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem queryKey'+    return result'++data UriQueryHasKeyMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriQueryHasKeyMethodInfo Uri signature where+    overloadedMethod _ = uriQueryHasKey++-- method Uri::remove_query_key+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_remove_query_key" gst_uri_remove_query_key :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- query_key : TBasicType TUTF8+    IO CInt+++uriRemoveQueryKey ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- queryKey+    -> m Bool                               -- result+uriRemoveQueryKey _obj queryKey = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    queryKey' <- textToCString queryKey+    result <- gst_uri_remove_query_key _obj' queryKey'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem queryKey'+    return result'++data UriRemoveQueryKeyMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriRemoveQueryKeyMethodInfo Uri signature where+    overloadedMethod _ = uriRemoveQueryKey++-- method Uri::set_fragment+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fragment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_fragment" gst_uri_set_fragment :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- fragment : TBasicType TUTF8+    IO CInt+++uriSetFragment ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> Maybe (T.Text)                       -- fragment+    -> m Bool                               -- result+uriSetFragment _obj fragment = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeFragment <- case fragment of+        Nothing -> return nullPtr+        Just jFragment -> do+            jFragment' <- textToCString jFragment+            return jFragment'+    result <- gst_uri_set_fragment _obj' maybeFragment+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem maybeFragment+    return result'++data UriSetFragmentMethodInfo+instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m) => MethodInfo UriSetFragmentMethodInfo Uri signature where+    overloadedMethod _ = uriSetFragment++-- method Uri::set_host+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_host" gst_uri_set_host :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- host : TBasicType TUTF8+    IO CInt+++uriSetHost ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- host+    -> m Bool                               -- result+uriSetHost _obj host = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    host' <- textToCString host+    result <- gst_uri_set_host _obj' host'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem host'+    return result'++data UriSetHostMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetHostMethodInfo Uri signature where+    overloadedMethod _ = uriSetHost++-- method Uri::set_path+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_path" gst_uri_set_path :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- path : TBasicType TUTF8+    IO CInt+++uriSetPath ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- path+    -> m Bool                               -- result+uriSetPath _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    path' <- textToCString path+    result <- gst_uri_set_path _obj' path'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem path'+    return result'++data UriSetPathMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetPathMethodInfo Uri signature where+    overloadedMethod _ = uriSetPath++-- method Uri::set_path_segments+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_segments", argType = TGList (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_path_segments" gst_uri_set_path_segments :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    Ptr (GList CString) ->                  -- path_segments : TGList (TBasicType TUTF8)+    IO CInt+++uriSetPathSegments ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> [T.Text]                             -- pathSegments+    -> m Bool                               -- result+uriSetPathSegments _obj pathSegments = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    pathSegments' <- mapM textToCString pathSegments+    pathSegments'' <- packGList pathSegments'+    result <- gst_uri_set_path_segments _obj' pathSegments''+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data UriSetPathSegmentsMethodInfo+instance (signature ~ ([T.Text] -> m Bool), MonadIO m) => MethodInfo UriSetPathSegmentsMethodInfo Uri signature where+    overloadedMethod _ = uriSetPathSegments++-- method Uri::set_path_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_path_string" gst_uri_set_path_string :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- path : TBasicType TUTF8+    IO CInt+++uriSetPathString ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- path+    -> m Bool                               -- result+uriSetPathString _obj path = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    path' <- textToCString path+    result <- gst_uri_set_path_string _obj' path'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem path'+    return result'++data UriSetPathStringMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetPathStringMethodInfo Uri signature where+    overloadedMethod _ = uriSetPathString++-- method Uri::set_port+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_port" gst_uri_set_port :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    Word32 ->                               -- port : TBasicType TUInt32+    IO CInt+++uriSetPort ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> Word32                               -- port+    -> m Bool                               -- result+uriSetPort _obj port = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_set_port _obj' port+    let result' = (/= 0) result+    touchManagedPtr _obj+    return result'++data UriSetPortMethodInfo+instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo UriSetPortMethodInfo Uri signature where+    overloadedMethod _ = uriSetPort++-- method Uri::set_query_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_query_string" gst_uri_set_query_string :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- query : TBasicType TUTF8+    IO CInt+++uriSetQueryString ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- query+    -> m Bool                               -- result+uriSetQueryString _obj query = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    query' <- textToCString query+    result <- gst_uri_set_query_string _obj' query'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem query'+    return result'++data UriSetQueryStringMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetQueryStringMethodInfo Uri signature where+    overloadedMethod _ = uriSetQueryString++-- method Uri::set_query_table+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_table", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_query_table" gst_uri_set_query_table :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    Ptr (GHashTable CString CString) ->     -- query_table : TGHash (TBasicType TUTF8) (TBasicType TUTF8)+    IO CInt+++uriSetQueryTable ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> Maybe (Map.Map T.Text T.Text)        -- queryTable+    -> m Bool                               -- result+uriSetQueryTable _obj queryTable = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    maybeQueryTable <- case queryTable of+        Nothing -> return nullPtr+        Just jQueryTable -> do+            let jQueryTable' = Map.toList jQueryTable+            jQueryTable'' <- mapFirstA textToCString jQueryTable'+            jQueryTable''' <- mapSecondA textToCString jQueryTable''+            let jQueryTable'''' = mapFirst cstringPackPtr jQueryTable'''+            let jQueryTable''''' = mapSecond cstringPackPtr jQueryTable''''+            jQueryTable'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) jQueryTable'''''+            return jQueryTable''''''+    result <- gst_uri_set_query_table _obj' maybeQueryTable+    let result' = (/= 0) result+    touchManagedPtr _obj+    unrefGHashTable maybeQueryTable+    return result'++data UriSetQueryTableMethodInfo+instance (signature ~ (Maybe (Map.Map T.Text T.Text) -> m Bool), MonadIO m) => MethodInfo UriSetQueryTableMethodInfo Uri signature where+    overloadedMethod _ = uriSetQueryTable++-- method Uri::set_query_value+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_query_value" gst_uri_set_query_value :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- query_key : TBasicType TUTF8+    CString ->                              -- query_value : TBasicType TUTF8+    IO CInt+++uriSetQueryValue ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- queryKey+    -> Maybe (T.Text)                       -- queryValue+    -> m Bool                               -- result+uriSetQueryValue _obj queryKey queryValue = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    queryKey' <- textToCString queryKey+    maybeQueryValue <- case queryValue of+        Nothing -> return nullPtr+        Just jQueryValue -> do+            jQueryValue' <- textToCString jQueryValue+            return jQueryValue'+    result <- gst_uri_set_query_value _obj' queryKey' maybeQueryValue+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem queryKey'+    freeMem maybeQueryValue+    return result'++data UriSetQueryValueMethodInfo+instance (signature ~ (T.Text -> Maybe (T.Text) -> m Bool), MonadIO m) => MethodInfo UriSetQueryValueMethodInfo Uri signature where+    overloadedMethod _ = uriSetQueryValue++-- method Uri::set_scheme+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_scheme" gst_uri_set_scheme :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- scheme : TBasicType TUTF8+    IO CInt+++uriSetScheme ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- scheme+    -> m Bool                               -- result+uriSetScheme _obj scheme = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    scheme' <- textToCString scheme+    result <- gst_uri_set_scheme _obj' scheme'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem scheme'+    return result'++data UriSetSchemeMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetSchemeMethodInfo Uri signature where+    overloadedMethod _ = uriSetScheme++-- method Uri::set_userinfo+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "userinfo", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_set_userinfo" gst_uri_set_userinfo :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    CString ->                              -- userinfo : TBasicType TUTF8+    IO CInt+++uriSetUserinfo ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> T.Text                               -- userinfo+    -> m Bool                               -- result+uriSetUserinfo _obj userinfo = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    userinfo' <- textToCString userinfo+    result <- gst_uri_set_userinfo _obj' userinfo'+    let result' = (/= 0) result+    touchManagedPtr _obj+    freeMem userinfo'+    return result'++data UriSetUserinfoMethodInfo+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetUserinfoMethodInfo Uri signature where+    overloadedMethod _ = uriSetUserinfo++-- method Uri::to_string+-- method type : OrdinaryMethod+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_to_string" gst_uri_to_string :: +    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"+    IO CString+++uriToString ::+    (MonadIO m) =>+    Uri                                     -- _obj+    -> m T.Text                             -- result+uriToString _obj = liftIO $ do+    let _obj' = unsafeManagedPtrGetPtr _obj+    result <- gst_uri_to_string _obj'+    checkUnexpectedReturnNULL "gst_uri_to_string" result+    result' <- cstringToText result+    freeMem result+    touchManagedPtr _obj+    return result'++data UriToStringMethodInfo+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriToStringMethodInfo Uri signature where+    overloadedMethod _ = uriToString++-- method Uri::construct+-- method type : MemberFunction+-- Args : [Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "location", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_construct" gst_uri_construct :: +    CString ->                              -- protocol : TBasicType TUTF8+    CString ->                              -- location : TBasicType TUTF8+    IO CString+++uriConstruct ::+    (MonadIO m) =>+    T.Text                                  -- protocol+    -> T.Text                               -- location+    -> m T.Text                             -- result+uriConstruct protocol location = liftIO $ do+    protocol' <- textToCString protocol+    location' <- textToCString location+    result <- gst_uri_construct protocol' location'+    checkUnexpectedReturnNULL "gst_uri_construct" result+    result' <- cstringToText result+    freeMem result+    freeMem protocol'+    freeMem location'+    return result'++-- method Uri::from_string+-- method type : MemberFunction+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TInterface "Gst" "Uri"+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_from_string" gst_uri_from_string :: +    CString ->                              -- uri : TBasicType TUTF8+    IO (Ptr Uri)+++uriFromString ::+    (MonadIO m) =>+    T.Text                                  -- uri+    -> m Uri                                -- result+uriFromString uri = liftIO $ do+    uri' <- textToCString uri+    result <- gst_uri_from_string uri'+    checkUnexpectedReturnNULL "gst_uri_from_string" result+    result' <- (wrapBoxed Uri) result+    freeMem uri'+    return result'++-- method Uri::get_location+-- method type : MemberFunction+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_location" gst_uri_get_location :: +    CString ->                              -- uri : TBasicType TUTF8+    IO CString+++uriGetLocation ::+    (MonadIO m) =>+    T.Text                                  -- uri+    -> m T.Text                             -- result+uriGetLocation uri = liftIO $ do+    uri' <- textToCString uri+    result <- gst_uri_get_location uri'+    checkUnexpectedReturnNULL "gst_uri_get_location" result+    result' <- cstringToText result+    freeMem result+    freeMem uri'+    return result'++-- method Uri::get_protocol+-- method type : MemberFunction+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_get_protocol" gst_uri_get_protocol :: +    CString ->                              -- uri : TBasicType TUTF8+    IO CString+++uriGetProtocol ::+    (MonadIO m) =>+    T.Text                                  -- uri+    -> m T.Text                             -- result+uriGetProtocol uri = liftIO $ do+    uri' <- textToCString uri+    result <- gst_uri_get_protocol uri'+    checkUnexpectedReturnNULL "gst_uri_get_protocol" result+    result' <- cstringToText result+    freeMem result+    freeMem uri'+    return result'++-- method Uri::has_protocol+-- method type : MemberFunction+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_has_protocol" gst_uri_has_protocol :: +    CString ->                              -- uri : TBasicType TUTF8+    CString ->                              -- protocol : TBasicType TUTF8+    IO CInt+++uriHasProtocol ::+    (MonadIO m) =>+    T.Text                                  -- uri+    -> T.Text                               -- protocol+    -> m Bool                               -- result+uriHasProtocol uri protocol = liftIO $ do+    uri' <- textToCString uri+    protocol' <- textToCString protocol+    result <- gst_uri_has_protocol uri' protocol'+    let result' = (/= 0) result+    freeMem uri'+    freeMem protocol'+    return result'++-- method Uri::is_valid+-- method type : MemberFunction+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_is_valid" gst_uri_is_valid :: +    CString ->                              -- uri : TBasicType TUTF8+    IO CInt+++uriIsValid ::+    (MonadIO m) =>+    T.Text                                  -- uri+    -> m Bool                               -- result+uriIsValid uri = liftIO $ do+    uri' <- textToCString uri+    result <- gst_uri_is_valid uri'+    let result' = (/= 0) result+    freeMem uri'+    return result'++-- method Uri::join_strings+-- method type : MemberFunction+-- Args : [Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TUTF8+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_join_strings" gst_uri_join_strings :: +    CString ->                              -- base_uri : TBasicType TUTF8+    CString ->                              -- ref_uri : TBasicType TUTF8+    IO CString+++uriJoinStrings ::+    (MonadIO m) =>+    T.Text                                  -- baseUri+    -> T.Text                               -- refUri+    -> m T.Text                             -- result+uriJoinStrings baseUri refUri = liftIO $ do+    baseUri' <- textToCString baseUri+    refUri' <- textToCString refUri+    result <- gst_uri_join_strings baseUri' refUri'+    checkUnexpectedReturnNULL "gst_uri_join_strings" result+    result' <- cstringToText result+    freeMem result+    freeMem baseUri'+    freeMem refUri'+    return result'++-- method Uri::protocol_is_supported+-- method type : MemberFunction+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "URIType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_protocol_is_supported" gst_uri_protocol_is_supported :: +    CUInt ->                                -- type : TInterface "Gst" "URIType"+    CString ->                              -- protocol : TBasicType TUTF8+    IO CInt+++uriProtocolIsSupported ::+    (MonadIO m) =>+    URIType                                 -- type_+    -> T.Text                               -- protocol+    -> m Bool                               -- result+uriProtocolIsSupported type_ protocol = liftIO $ do+    let type_' = (fromIntegral . fromEnum) type_+    protocol' <- textToCString protocol+    result <- gst_uri_protocol_is_supported type_' protocol'+    let result' = (/= 0) result+    freeMem protocol'+    return result'++-- method Uri::protocol_is_valid+-- method type : MemberFunction+-- Args : [Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]+-- Lengths : []+-- returnType : TBasicType TBoolean+-- throws : False+-- Skip return : False++foreign import ccall "gst_uri_protocol_is_valid" gst_uri_protocol_is_valid :: +    CString ->                              -- protocol : TBasicType TUTF8+    IO CInt+++uriProtocolIsValid ::+    (MonadIO m) =>+    T.Text                                  -- protocol+    -> m Bool                               -- result+uriProtocolIsValid protocol = liftIO $ do+    protocol' <- textToCString protocol+    result <- gst_uri_protocol_is_valid protocol'+    let result' = (/= 0) result+    freeMem protocol'+    return result'++type family ResolveUriMethod (t :: Symbol) (o :: *) :: * where+    ResolveUriMethod "appendPath" o = UriAppendPathMethodInfo+    ResolveUriMethod "appendPathSegment" o = UriAppendPathSegmentMethodInfo+    ResolveUriMethod "equal" o = UriEqualMethodInfo+    ResolveUriMethod "fromStringWithBase" o = UriFromStringWithBaseMethodInfo+    ResolveUriMethod "isNormalized" o = UriIsNormalizedMethodInfo+    ResolveUriMethod "isWritable" o = UriIsWritableMethodInfo+    ResolveUriMethod "join" o = UriJoinMethodInfo+    ResolveUriMethod "makeWritable" o = UriMakeWritableMethodInfo+    ResolveUriMethod "newWithBase" o = UriNewWithBaseMethodInfo+    ResolveUriMethod "normalize" o = UriNormalizeMethodInfo+    ResolveUriMethod "queryHasKey" o = UriQueryHasKeyMethodInfo+    ResolveUriMethod "removeQueryKey" o = UriRemoveQueryKeyMethodInfo+    ResolveUriMethod "toString" o = UriToStringMethodInfo+    ResolveUriMethod "getFragment" o = UriGetFragmentMethodInfo+    ResolveUriMethod "getHost" o = UriGetHostMethodInfo+    ResolveUriMethod "getPath" o = UriGetPathMethodInfo+    ResolveUriMethod "getPathSegments" o = UriGetPathSegmentsMethodInfo+    ResolveUriMethod "getPathString" o = UriGetPathStringMethodInfo+    ResolveUriMethod "getPort" o = UriGetPortMethodInfo+    ResolveUriMethod "getQueryKeys" o = UriGetQueryKeysMethodInfo+    ResolveUriMethod "getQueryString" o = UriGetQueryStringMethodInfo+    ResolveUriMethod "getQueryTable" o = UriGetQueryTableMethodInfo+    ResolveUriMethod "getQueryValue" o = UriGetQueryValueMethodInfo+    ResolveUriMethod "getScheme" o = UriGetSchemeMethodInfo+    ResolveUriMethod "getUserinfo" o = UriGetUserinfoMethodInfo+    ResolveUriMethod "setFragment" o = UriSetFragmentMethodInfo+    ResolveUriMethod "setHost" o = UriSetHostMethodInfo+    ResolveUriMethod "setPath" o = UriSetPathMethodInfo+    ResolveUriMethod "setPathSegments" o = UriSetPathSegmentsMethodInfo+    ResolveUriMethod "setPathString" o = UriSetPathStringMethodInfo+    ResolveUriMethod "setPort" o = UriSetPortMethodInfo+    ResolveUriMethod "setQueryString" o = UriSetQueryStringMethodInfo+    ResolveUriMethod "setQueryTable" o = UriSetQueryTableMethodInfo+    ResolveUriMethod "setQueryValue" o = UriSetQueryValueMethodInfo+    ResolveUriMethod "setScheme" o = UriSetSchemeMethodInfo+    ResolveUriMethod "setUserinfo" o = UriSetUserinfoMethodInfo+    ResolveUriMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveUriMethod t Uri, MethodInfo info Uri p) => IsLabelProxy t (Uri -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveUriMethod t Uri, MethodInfo info Uri p) => IsLabel t (Uri -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/Uri.hs-boot view
@@ -0,0 +1,47 @@+module GI.Gst.Structs.Uri 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++newtype Uri = Uri (ForeignPtr Uri)+instance BoxedObject Uri where+data UriAppendPathMethodInfo+data UriAppendPathSegmentMethodInfo+data UriEqualMethodInfo+data UriFromStringWithBaseMethodInfo+data UriGetFragmentMethodInfo+data UriGetHostMethodInfo+data UriGetPathMethodInfo+data UriGetPathSegmentsMethodInfo+data UriGetPathStringMethodInfo+data UriGetPortMethodInfo+data UriGetQueryKeysMethodInfo+data UriGetQueryStringMethodInfo+data UriGetQueryTableMethodInfo+data UriGetQueryValueMethodInfo+data UriGetSchemeMethodInfo+data UriGetUserinfoMethodInfo+data UriIsNormalizedMethodInfo+data UriIsWritableMethodInfo+data UriJoinMethodInfo+data UriMakeWritableMethodInfo+data UriNewWithBaseMethodInfo+data UriNormalizeMethodInfo+data UriQueryHasKeyMethodInfo+data UriRemoveQueryKeyMethodInfo+data UriSetFragmentMethodInfo+data UriSetHostMethodInfo+data UriSetPathMethodInfo+data UriSetPathSegmentsMethodInfo+data UriSetPathStringMethodInfo+data UriSetPortMethodInfo+data UriSetQueryStringMethodInfo+data UriSetQueryTableMethodInfo+data UriSetQueryValueMethodInfo+data UriSetSchemeMethodInfo+data UriSetUserinfoMethodInfo+data UriToStringMethodInfo
+ GI/Gst/Structs/ValueTable.hs view
@@ -0,0 +1,70 @@+++{- |+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte+License    : LGPL-2.1+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)++VTable for the #GValue @type.+-}++module GI.Gst.Structs.ValueTable+    ( ++-- * Exported types+    ValueTable(..)                          ,+    newZeroValueTable                       ,+    noValueTable                            ,+++ -- * Properties+-- ** Type+    valueTableReadType                      ,+++++    ) 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 GI.Gst.Callbacks++newtype ValueTable = ValueTable (ForeignPtr ValueTable)+-- | Construct a `ValueTable` struct initialized to zero.+newZeroValueTable :: MonadIO m => m ValueTable+newZeroValueTable = liftIO $ callocBytes 64 >>= wrapPtr ValueTable++noValueTable :: Maybe ValueTable+noValueTable = Nothing++valueTableReadType :: ValueTable -> IO GType+valueTableReadType s = withManagedPtr s $ \ptr -> do+    val <- peek (ptr `plusPtr` 0) :: IO CGType+    let val' = GType val+    return val'++-- XXX Skipped getter for "ValueTable:compare" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "ValueTable:serialize" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++-- XXX Skipped getter for "ValueTable:deserialize" :: Not implemented: "Wrapping foreign callbacks is not supported yet"++type family ResolveValueTableMethod (t :: Symbol) (o :: *) :: * where+    ResolveValueTableMethod l o = MethodResolutionFailed l o++instance (info ~ ResolveValueTableMethod t ValueTable, MethodInfo info ValueTable p) => IsLabelProxy t (ValueTable -> p) where+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)++#if MIN_VERSION_base(4,9,0)+instance (info ~ ResolveValueTableMethod t ValueTable, MethodInfo info ValueTable p) => IsLabel t (ValueTable -> p) where+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)+#endif++
+ GI/Gst/Structs/ValueTable.hs-boot view
@@ -0,0 +1,10 @@+module GI.Gst.Structs.ValueTable 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++newtype ValueTable = ValueTable (ForeignPtr ValueTable)
+ GI/Gst/Types.hs view
@@ -0,0 +1,160 @@+module GI.Gst.Types+    (     module GI.Gst.Interfaces.ChildProxy     ,+    module GI.Gst.Interfaces.Preset         ,+    module GI.Gst.Interfaces.TagSetter      ,+    module GI.Gst.Interfaces.TocSetter      ,+    module GI.Gst.Interfaces.URIHandler     ,+    module GI.Gst.Objects.Allocator         ,+    module GI.Gst.Objects.Bin               ,+    module GI.Gst.Objects.BufferPool        ,+    module GI.Gst.Objects.Bus               ,+    module GI.Gst.Objects.Clock             ,+    module GI.Gst.Objects.ControlBinding    ,+    module GI.Gst.Objects.ControlSource     ,+    module GI.Gst.Objects.Device            ,+    module GI.Gst.Objects.DeviceMonitor     ,+    module GI.Gst.Objects.DeviceProvider    ,+    module GI.Gst.Objects.DeviceProviderFactory,+    module GI.Gst.Objects.Element           ,+    module GI.Gst.Objects.ElementFactory    ,+    module GI.Gst.Objects.GhostPad          ,+    module GI.Gst.Objects.Object            ,+    module GI.Gst.Objects.Pad               ,+    module GI.Gst.Objects.PadTemplate       ,+    module GI.Gst.Objects.Pipeline          ,+    module GI.Gst.Objects.Plugin            ,+    module GI.Gst.Objects.PluginFeature     ,+    module GI.Gst.Objects.ProxyPad          ,+    module GI.Gst.Objects.Registry          ,+    module GI.Gst.Objects.SystemClock       ,+    module GI.Gst.Objects.Task              ,+    module GI.Gst.Objects.TaskPool          ,+    module GI.Gst.Objects.TypeFindFactory   ,+    module GI.Gst.Structs.AllocationParams  ,+    module GI.Gst.Structs.AtomicQueue       ,+    module GI.Gst.Structs.Buffer            ,+    module GI.Gst.Structs.BufferList        ,+    module GI.Gst.Structs.BufferPoolAcquireParams,+    module GI.Gst.Structs.Caps              ,+    module GI.Gst.Structs.CapsFeatures      ,+    module GI.Gst.Structs.ClockEntry        ,+    module GI.Gst.Structs.Context           ,+    module GI.Gst.Structs.DateTime          ,+    module GI.Gst.Structs.DebugCategory     ,+    module GI.Gst.Structs.DebugMessage      ,+    module GI.Gst.Structs.Event             ,+    module GI.Gst.Structs.FormatDefinition  ,+    module GI.Gst.Structs.Iterator          ,+    module GI.Gst.Structs.MapInfo           ,+    module GI.Gst.Structs.Memory            ,+    module GI.Gst.Structs.Message           ,+    module GI.Gst.Structs.Meta              ,+    module GI.Gst.Structs.MetaInfo          ,+    module GI.Gst.Structs.MetaTransformCopy ,+    module GI.Gst.Structs.MiniObject        ,+    module GI.Gst.Structs.PadProbeInfo      ,+    module GI.Gst.Structs.ParamSpecFraction ,+    module GI.Gst.Structs.ParentBufferMeta  ,+    module GI.Gst.Structs.ParseContext      ,+    module GI.Gst.Structs.PluginDesc        ,+    module GI.Gst.Structs.Poll              ,+    module GI.Gst.Structs.PollFD            ,+    module GI.Gst.Structs.ProtectionMeta    ,+    module GI.Gst.Structs.Query             ,+    module GI.Gst.Structs.Sample            ,+    module GI.Gst.Structs.Segment           ,+    module GI.Gst.Structs.StaticCaps        ,+    module GI.Gst.Structs.StaticPadTemplate ,+    module GI.Gst.Structs.Structure         ,+    module GI.Gst.Structs.TagList           ,+    module GI.Gst.Structs.TimedValue        ,+    module GI.Gst.Structs.Toc               ,+    module GI.Gst.Structs.TocEntry          ,+    module GI.Gst.Structs.TypeFind          ,+    module GI.Gst.Structs.Uri               ,+    module GI.Gst.Structs.ValueTable        ,+    module GI.Gst.Enums                     ,+    module GI.Gst.Flags                     ,+++    ) where+++import {-# SOURCE #-} GI.Gst.Interfaces.ChildProxy+import {-# SOURCE #-} GI.Gst.Interfaces.Preset+import {-# SOURCE #-} GI.Gst.Interfaces.TagSetter+import {-# SOURCE #-} GI.Gst.Interfaces.TocSetter+import {-# SOURCE #-} GI.Gst.Interfaces.URIHandler+import {-# SOURCE #-} GI.Gst.Objects.Allocator+import {-# SOURCE #-} GI.Gst.Objects.Bin+import {-# SOURCE #-} GI.Gst.Objects.BufferPool+import {-# SOURCE #-} GI.Gst.Objects.Bus+import {-# SOURCE #-} GI.Gst.Objects.Clock+import {-# SOURCE #-} GI.Gst.Objects.ControlBinding+import {-# SOURCE #-} GI.Gst.Objects.ControlSource+import {-# SOURCE #-} GI.Gst.Objects.Device+import {-# SOURCE #-} GI.Gst.Objects.DeviceMonitor+import {-# SOURCE #-} GI.Gst.Objects.DeviceProvider+import {-# SOURCE #-} GI.Gst.Objects.DeviceProviderFactory+import {-# SOURCE #-} GI.Gst.Objects.Element+import {-# SOURCE #-} GI.Gst.Objects.ElementFactory+import {-# SOURCE #-} GI.Gst.Objects.GhostPad+import {-# SOURCE #-} GI.Gst.Objects.Object+import {-# SOURCE #-} GI.Gst.Objects.Pad+import {-# SOURCE #-} GI.Gst.Objects.PadTemplate+import {-# SOURCE #-} GI.Gst.Objects.Pipeline+import {-# SOURCE #-} GI.Gst.Objects.Plugin+import {-# SOURCE #-} GI.Gst.Objects.PluginFeature+import {-# SOURCE #-} GI.Gst.Objects.ProxyPad+import {-# SOURCE #-} GI.Gst.Objects.Registry+import {-# SOURCE #-} GI.Gst.Objects.SystemClock+import {-# SOURCE #-} GI.Gst.Objects.Task+import {-# SOURCE #-} GI.Gst.Objects.TaskPool+import {-# SOURCE #-} GI.Gst.Objects.TypeFindFactory+import {-# SOURCE #-} GI.Gst.Structs.AllocationParams+import {-# SOURCE #-} GI.Gst.Structs.AtomicQueue+import {-# SOURCE #-} GI.Gst.Structs.Buffer+import {-# SOURCE #-} GI.Gst.Structs.BufferList+import {-# SOURCE #-} GI.Gst.Structs.BufferPoolAcquireParams+import {-# SOURCE #-} GI.Gst.Structs.Caps+import {-# SOURCE #-} GI.Gst.Structs.CapsFeatures+import {-# SOURCE #-} GI.Gst.Structs.ClockEntry+import {-# SOURCE #-} GI.Gst.Structs.Context+import {-# SOURCE #-} GI.Gst.Structs.DateTime+import {-# SOURCE #-} GI.Gst.Structs.DebugCategory+import {-# SOURCE #-} GI.Gst.Structs.DebugMessage+import {-# SOURCE #-} GI.Gst.Structs.Event+import {-# SOURCE #-} GI.Gst.Structs.FormatDefinition+import {-# SOURCE #-} GI.Gst.Structs.Iterator+import {-# SOURCE #-} GI.Gst.Structs.MapInfo+import {-# SOURCE #-} GI.Gst.Structs.Memory+import {-# SOURCE #-} GI.Gst.Structs.Message+import {-# SOURCE #-} GI.Gst.Structs.Meta+import {-# SOURCE #-} GI.Gst.Structs.MetaInfo+import {-# SOURCE #-} GI.Gst.Structs.MetaTransformCopy+import {-# SOURCE #-} GI.Gst.Structs.MiniObject+import {-# SOURCE #-} GI.Gst.Structs.PadProbeInfo+import {-# SOURCE #-} GI.Gst.Structs.ParamSpecFraction+import {-# SOURCE #-} GI.Gst.Structs.ParentBufferMeta+import {-# SOURCE #-} GI.Gst.Structs.ParseContext+import {-# SOURCE #-} GI.Gst.Structs.PluginDesc+import {-# SOURCE #-} GI.Gst.Structs.Poll+import {-# SOURCE #-} GI.Gst.Structs.PollFD+import {-# SOURCE #-} GI.Gst.Structs.ProtectionMeta+import {-# SOURCE #-} GI.Gst.Structs.Query+import {-# SOURCE #-} GI.Gst.Structs.Sample+import {-# SOURCE #-} GI.Gst.Structs.Segment+import {-# SOURCE #-} GI.Gst.Structs.StaticCaps+import {-# SOURCE #-} GI.Gst.Structs.StaticPadTemplate+import {-# SOURCE #-} GI.Gst.Structs.Structure+import {-# SOURCE #-} GI.Gst.Structs.TagList+import {-# SOURCE #-} GI.Gst.Structs.TimedValue+import {-# SOURCE #-} GI.Gst.Structs.Toc+import {-# SOURCE #-} GI.Gst.Structs.TocEntry+import {-# SOURCE #-} GI.Gst.Structs.TypeFind+import {-# SOURCE #-} GI.Gst.Structs.Uri+import {-# SOURCE #-} GI.Gst.Structs.ValueTable++import GI.Gst.Enums+import GI.Gst.Flags+
+ LICENSE view
@@ -0,0 +1,456 @@+                  GNU LESSER GENERAL PUBLIC LICENSE+                       Version 2.1, February 1999++ Copyright (C) 1991, 1999 Free Software Foundation, Inc.+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA+ Everyone is permitted to copy and distribute verbatim copies+ of this license document, but changing it is not allowed.++[This is the first released version of the Lesser GPL.  It also counts+ as the successor of the GNU Library Public License, version 2, hence+ the version number 2.1.]++                            Preamble++  The licenses for most software are designed to take away your+freedom to share and change it.  By contrast, the GNU General Public+Licenses are intended to guarantee your freedom to share and change+free software--to make sure the software is free for all its users.++  This license, the Lesser General Public License, applies to some+specially designated software packages--typically libraries--of the+Free Software Foundation and other authors who decide to use it.  You+can use it too, but we suggest you first think carefully about whether+this license or the ordinary General Public License is the better+strategy to use in any particular case, based on the explanations below.++  When we speak of free software, we are referring to freedom of use,+not price.  Our General Public Licenses are designed to make sure that+you have the freedom to distribute copies of free software (and charge+for this service if you wish); that you receive source code or can get+it if you want it; that you can change the software and use pieces of+it in new free programs; and that you are informed that you can do+these things.++  To protect your rights, we need to make restrictions that forbid+distributors to deny you these rights or to ask you to surrender these+rights.  These restrictions translate to certain responsibilities for+you if you distribute copies of the library or if you modify it.++  For example, if you distribute copies of the library, whether gratis+or for a fee, you must give the recipients all the rights that we gave+you.  You must make sure that they, too, receive or can get the source+code.  If you link other code with the library, you must provide+complete object files to the recipients, so that they can relink them+with the library after making changes to the library and recompiling+it.  And you must show them these terms so they know their rights.++  We protect your rights with a two-step method: (1) we copyright the+library, and (2) we offer you this license, which gives you legal+permission to copy, distribute and/or modify the library.++  To protect each distributor, we want to make it very clear that+there is no warranty for the free library.  Also, if the library is+modified by someone else and passed on, the recipients should know+that what they have is not the original version, so that the original+author's reputation will not be affected by problems that might be+introduced by others.++  Finally, software patents pose a constant threat to the existence of+any free program.  We wish to make sure that a company cannot+effectively restrict the users of a free program by obtaining a+restrictive license from a patent holder.  Therefore, we insist that+any patent license obtained for a version of the library must be+consistent with the full freedom of use specified in this license.++  Most GNU software, including some libraries, is covered by the+ordinary GNU General Public License.  This license, the GNU Lesser+General Public License, applies to certain designated libraries, and+is quite different from the ordinary General Public License.  We use+this license for certain libraries in order to permit linking those+libraries into non-free programs.++  When a program is linked with a library, whether statically or using+a shared library, the combination of the two is legally speaking a+combined work, a derivative of the original library.  The ordinary+General Public License therefore permits such linking only if the+entire combination fits its criteria of freedom.  The Lesser General+Public License permits more lax criteria for linking other code with+the library.++  We call this license the "Lesser" General Public License because it+does Less to protect the user's freedom than the ordinary General+Public License.  It also provides other free software developers Less+of an advantage over competing non-free programs.  These disadvantages+are the reason we use the ordinary General Public License for many+libraries.  However, the Lesser license provides advantages in certain+special circumstances.++  For example, on rare occasions, there may be a special need to+encourage the widest possible use of a certain library, so that it becomes+a de-facto standard.  To achieve this, non-free programs must be+allowed to use the library.  A more frequent case is that a free+library does the same job as widely used non-free libraries.  In this+case, there is little to gain by limiting the free library to free+software only, so we use the Lesser General Public License.++  In other cases, permission to use a particular library in non-free+programs enables a greater number of people to use a large body of+free software.  For example, permission to use the GNU C Library in+non-free programs enables many more people to use the whole GNU+operating system, as well as its variant, the GNU/Linux operating+system.++  Although the Lesser General Public License is Less protective of the+users' freedom, it does ensure that the user of a program that is+linked with the Library has the freedom and the wherewithal to run+that program using a modified version of the Library.++  The precise terms and conditions for copying, distribution and+modification follow.  Pay close attention to the difference between a+"work based on the library" and a "work that uses the library".  The+former contains code derived from the library, whereas the latter must+be combined with the library in order to run.++                  GNU LESSER GENERAL PUBLIC LICENSE+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION++  0. This License Agreement applies to any software library or other+program which contains a notice placed by the copyright holder or+other authorized party saying it may be distributed under the terms of+this Lesser General Public License (also called "this License").+Each licensee is addressed as "you".++  A "library" means a collection of software functions and/or data+prepared so as to be conveniently linked with application programs+(which use some of those functions and data) to form executables.++  The "Library", below, refers to any such software library or work+which has been distributed under these terms.  A "work based on the+Library" means either the Library or any derivative work under+copyright law: that is to say, a work containing the Library or a+portion of it, either verbatim or with modifications and/or translated+straightforwardly into another language.  (Hereinafter, translation is+included without limitation in the term "modification".)++  "Source code" for a work means the preferred form of the work for+making modifications to it.  For a library, complete source code means+all the source code for all modules it contains, plus any associated+interface definition files, plus the scripts used to control compilation+and installation of the library.++  Activities other than copying, distribution and modification are not+covered by this License; they are outside its scope.  The act of+running a program using the Library is not restricted, and output from+such a program is covered only if its contents constitute a work based+on the Library (independent of the use of the Library in a tool for+writing it).  Whether that is true depends on what the Library does+and what the program that uses the Library does.++  1. You may copy and distribute verbatim copies of the Library's+complete source code as you receive it, in any medium, provided that+you conspicuously and appropriately publish on each copy an+appropriate copyright notice and disclaimer of warranty; keep intact+all the notices that refer to this License and to the absence of any+warranty; and distribute a copy of this License along with the+Library.++  You may charge a fee for the physical act of transferring a copy,+and you may at your option offer warranty protection in exchange for a+fee.++  2. You may modify your copy or copies of the Library or any portion+of it, thus forming a work based on the Library, and copy and+distribute such modifications or work under the terms of Section 1+above, provided that you also meet all of these conditions:++    a) The modified work must itself be a software library.++    b) You must cause the files modified to carry prominent notices+    stating that you changed the files and the date of any change.++    c) You must cause the whole of the work to be licensed at no+    charge to all third parties under the terms of this License.++    d) If a facility in the modified Library refers to a function or a+    table of data to be supplied by an application program that uses+    the facility, other than as an argument passed when the facility+    is invoked, then you must make a good faith effort to ensure that,+    in the event an application does not supply such function or+    table, the facility still operates, and performs whatever part of+    its purpose remains meaningful.++    (For example, a function in a library to compute square roots has+    a purpose that is entirely well-defined independent of the+    application.  Therefore, Subsection 2d requires that any+    application-supplied function or table used by this function must+    be optional: if the application does not supply it, the square+    root function must still compute square roots.)++These requirements apply to the modified work as a whole.  If+identifiable sections of that work are not derived from the Library,+and can be reasonably considered independent and separate works in+themselves, then this License, and its terms, do not apply to those+sections when you distribute them as separate works.  But when you+distribute the same sections as part of a whole which is a work based+on the Library, the distribution of the whole must be on the terms of+this License, whose permissions for other licensees extend to the+entire whole, and thus to each and every part regardless of who wrote+it.++Thus, it is not the intent of this section to claim rights or contest+your rights to work written entirely by you; rather, the intent is to+exercise the right to control the distribution of derivative or+collective works based on the Library.++In addition, mere aggregation of another work not based on the Library+with the Library (or with a work based on the Library) on a volume of+a storage or distribution medium does not bring the other work under+the scope of this License.++  3. You may opt to apply the terms of the ordinary GNU General Public+License instead of this License to a given copy of the Library.  To do+this, you must alter all the notices that refer to this License, so+that they refer to the ordinary GNU General Public License, version 2,+instead of to this License.  (If a newer version than version 2 of the+ordinary GNU General Public License has appeared, then you can specify+that version instead if you wish.)  Do not make any other change in+these notices.++  Once this change is made in a given copy, it is irreversible for+that copy, so the ordinary GNU General Public License applies to all+subsequent copies and derivative works made from that copy.++  This option is useful when you wish to copy part of the code of+the Library into a program that is not a library.++  4. You may copy and distribute the Library (or a portion or+derivative of it, under Section 2) in object code or executable form+under the terms of Sections 1 and 2 above provided that you accompany+it with the complete corresponding machine-readable source code, which+must be distributed under the terms of Sections 1 and 2 above on a+medium customarily used for software interchange.++  If distribution of object code is made by offering access to copy+from a designated place, then offering equivalent access to copy the+source code from the same place satisfies the requirement to+distribute the source code, even though third parties are not+compelled to copy the source along with the object code.++  5. A program that contains no derivative of any portion of the+Library, but is designed to work with the Library by being compiled or+linked with it, is called a "work that uses the Library".  Such a+work, in isolation, is not a derivative work of the Library, and+therefore falls outside the scope of this License.++  However, linking a "work that uses the Library" with the Library+creates an executable that is a derivative of the Library (because it+contains portions of the Library), rather than a "work that uses the+library".  The executable is therefore covered by this License.+Section 6 states terms for distribution of such executables.++  When a "work that uses the Library" uses material from a header file+that is part of the Library, the object code for the work may be a+derivative work of the Library even though the source code is not.+Whether this is true is especially significant if the work can be+linked without the Library, or if the work is itself a library.  The+threshold for this to be true is not precisely defined by law.++  If such an object file uses only numerical parameters, data+structure layouts and accessors, and small macros and small inline+functions (ten lines or less in length), then the use of the object+file is unrestricted, regardless of whether it is legally a derivative+work.  (Executables containing this object code plus portions of the+Library will still fall under Section 6.)++  Otherwise, if the work is a derivative of the Library, you may+distribute the object code for the work under the terms of Section 6.+Any executables containing that work also fall under Section 6,+whether or not they are linked directly with the Library itself.++  6. As an exception to the Sections above, you may also combine or+link a "work that uses the Library" with the Library to produce a+work containing portions of the Library, and distribute that work+under terms of your choice, provided that the terms permit+modification of the work for the customer's own use and reverse+engineering for debugging such modifications.++  You must give prominent notice with each copy of the work that the+Library is used in it and that the Library and its use are covered by+this License.  You must supply a copy of this License.  If the work+during execution displays copyright notices, you must include the+copyright notice for the Library among them, as well as a reference+directing the user to the copy of this License.  Also, you must do one+of these things:++    a) Accompany the work with the complete corresponding+    machine-readable source code for the Library including whatever+    changes were used in the work (which must be distributed under+    Sections 1 and 2 above); and, if the work is an executable linked+    with the Library, with the complete machine-readable "work that+    uses the Library", as object code and/or source code, so that the+    user can modify the Library and then relink to produce a modified+    executable containing the modified Library.  (It is understood+    that the user who changes the contents of definitions files in the+    Library will not necessarily be able to recompile the application+    to use the modified definitions.)++    b) Use a suitable shared library mechanism for linking with the+    Library.  A suitable mechanism is one that (1) uses at run time a+    copy of the library already present on the user's computer system,+    rather than copying library functions into the executable, and (2)+    will operate properly with a modified version of the library, if+    the user installs one, as long as the modified version is+    interface-compatible with the version that the work was made with.++    c) Accompany the work with a written offer, valid for at+    least three years, to give the same user the materials+    specified in Subsection 6a, above, for a charge no more+    than the cost of performing this distribution.++    d) If distribution of the work is made by offering access to copy+    from a designated place, offer equivalent access to copy the above+    specified materials from the same place.++    e) Verify that the user has already received a copy of these+    materials or that you have already sent this user a copy.++  For an executable, the required form of the "work that uses the+Library" must include any data and utility programs needed for+reproducing the executable from it.  However, as a special exception,+the materials to be distributed need not include anything that is+normally distributed (in either source or binary form) with the major+components (compiler, kernel, and so on) of the operating system on+which the executable runs, unless that component itself accompanies+the executable.++  It may happen that this requirement contradicts the license+restrictions of other proprietary libraries that do not normally+accompany the operating system.  Such a contradiction means you cannot+use both them and the Library together in an executable that you+distribute.++  7. You may place library facilities that are a work based on the+Library side-by-side in a single library together with other library+facilities not covered by this License, and distribute such a combined+library, provided that the separate distribution of the work based on+the Library and of the other library facilities is otherwise+permitted, and provided that you do these two things:++    a) Accompany the combined library with a copy of the same work+    based on the Library, uncombined with any other library+    facilities.  This must be distributed under the terms of the+    Sections above.++    b) Give prominent notice with the combined library of the fact+    that part of it is a work based on the Library, and explaining+    where to find the accompanying uncombined form of the same work.++  8. You may not copy, modify, sublicense, link with, or distribute+the Library except as expressly provided under this License.  Any+attempt otherwise to copy, modify, sublicense, link with, or+distribute the Library is void, and will automatically terminate your+rights under this License.  However, parties who have received copies,+or rights, from you under this License will not have their licenses+terminated so long as such parties remain in full compliance.++  9. You are not required to accept this License, since you have not+signed it.  However, nothing else grants you permission to modify or+distribute the Library or its derivative works.  These actions are+prohibited by law if you do not accept this License.  Therefore, by+modifying or distributing the Library (or any work based on the+Library), you indicate your acceptance of this License to do so, and+all its terms and conditions for copying, distributing or modifying+the Library or works based on it.++  10. Each time you redistribute the Library (or any work based on the+Library), the recipient automatically receives a license from the+original licensor to copy, distribute, link with or modify the Library+subject to these terms and conditions.  You may not impose any further+restrictions on the recipients' exercise of the rights granted herein.+You are not responsible for enforcing compliance by third parties with+this License.++  11. If, as a consequence of a court judgment or allegation of patent+infringement or for any other reason (not limited to patent issues),+conditions are imposed on you (whether by court order, agreement or+otherwise) that contradict the conditions of this License, they do not+excuse you from the conditions of this License.  If you cannot+distribute so as to satisfy simultaneously your obligations under this+License and any other pertinent obligations, then as a consequence you+may not distribute the Library at all.  For example, if a patent+license would not permit royalty-free redistribution of the Library by+all those who receive copies directly or indirectly through you, then+the only way you could satisfy both it and this License would be to+refrain entirely from distribution of the Library.++If any portion of this section is held invalid or unenforceable under any+particular circumstance, the balance of the section is intended to apply,+and the section as a whole is intended to apply in other circumstances.++It is not the purpose of this section to induce you to infringe any+patents or other property right claims or to contest validity of any+such claims; this section has the sole purpose of protecting the+integrity of the free software distribution system which is+implemented by public license practices.  Many people have made+generous contributions to the wide range of software distributed+through that system in reliance on consistent application of that+system; it is up to the author/donor to decide if he or she is willing+to distribute software through any other system and a licensee cannot+impose that choice.++This section is intended to make thoroughly clear what is believed to+be a consequence of the rest of this License.++  12. If the distribution and/or use of the Library is restricted in+certain countries either by patents or by copyrighted interfaces, the+original copyright holder who places the Library under this License may add+an explicit geographical distribution limitation excluding those countries,+so that distribution is permitted only in or among countries not thus+excluded.  In such case, this License incorporates the limitation as if+written in the body of this License.++  13. The Free Software Foundation may publish revised and/or new+versions of the Lesser General Public License from time to time.+Such new versions will be similar in spirit to the present version,+but may differ in detail to address new problems or concerns.++Each version is given a distinguishing version number.  If the Library+specifies a version number of this License which applies to it and+"any later version", you have the option of following the terms and+conditions either of that version or of any later version published by+the Free Software Foundation.  If the Library does not specify a+license version number, you may choose any version ever published by+the Free Software Foundation.++  14. If you wish to incorporate parts of the Library into other free+programs whose distribution conditions are incompatible with these,+write to the author to ask for permission.  For software which is+copyrighted by the Free Software Foundation, write to the Free+Software Foundation; we sometimes make exceptions for this.  Our+decision will be guided by the two goals of preserving the free status+of all derivatives of our free software and of promoting the sharing+and reuse of software generally.++                            NO WARRANTY++  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH+DAMAGES.
+ Setup.hs view
@@ -0,0 +1,3 @@+#!/usr/bin/env runhaskell+import Distribution.Simple+main = defaultMain
+ gi-gst.cabal view
@@ -0,0 +1,112 @@+-- Autogenerated, do not edit.+name:               gi-gst+version:            0.1.6.13+synopsis:           Gst bindings+description:        Bindings for Gst, autogenerated by haskell-gi.+homepage:           https://github.com/haskell-gi/haskell-gi+license:            LGPL-2.1+license-file:       LICENSE+author:             Will Thompson, Iñaki García Etxebarria and Jonas Platte+maintainer:         Iñaki García Etxebarria (garetxe@gmail.com)+category:           Bindings+build-type:         Simple+cabal-version:      >=1.10++library+    default-language:   Haskell2010+    default-extensions: ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts+    other-extensions:   PatternSynonyms ViewPatterns+    ghc-options:        -fno-warn-unused-imports -fno-warn-warnings-deprecations+    exposed-modules:    GI.Gst.Types+                        GI.Gst+                        GI.Gst.Callbacks+                        GI.Gst.Constants+                        GI.Gst.Enums+                        GI.Gst.Flags+                        GI.Gst.Functions+                        GI.Gst.Interfaces+                        GI.Gst.Interfaces.ChildProxy+                        GI.Gst.Interfaces.Preset+                        GI.Gst.Interfaces.TagSetter+                        GI.Gst.Interfaces.TocSetter+                        GI.Gst.Interfaces.URIHandler+                        GI.Gst.Objects+                        GI.Gst.Objects.Allocator+                        GI.Gst.Objects.Bin+                        GI.Gst.Objects.BufferPool+                        GI.Gst.Objects.Bus+                        GI.Gst.Objects.Clock+                        GI.Gst.Objects.ControlBinding+                        GI.Gst.Objects.ControlSource+                        GI.Gst.Objects.Device+                        GI.Gst.Objects.DeviceMonitor+                        GI.Gst.Objects.DeviceProvider+                        GI.Gst.Objects.DeviceProviderFactory+                        GI.Gst.Objects.Element+                        GI.Gst.Objects.ElementFactory+                        GI.Gst.Objects.GhostPad+                        GI.Gst.Objects.Object+                        GI.Gst.Objects.Pad+                        GI.Gst.Objects.PadTemplate+                        GI.Gst.Objects.Pipeline+                        GI.Gst.Objects.Plugin+                        GI.Gst.Objects.PluginFeature+                        GI.Gst.Objects.ProxyPad+                        GI.Gst.Objects.Registry+                        GI.Gst.Objects.SystemClock+                        GI.Gst.Objects.Task+                        GI.Gst.Objects.TaskPool+                        GI.Gst.Objects.TypeFindFactory+                        GI.Gst.Structs+                        GI.Gst.Structs.AllocationParams+                        GI.Gst.Structs.AtomicQueue+                        GI.Gst.Structs.Buffer+                        GI.Gst.Structs.BufferList+                        GI.Gst.Structs.BufferPoolAcquireParams+                        GI.Gst.Structs.Caps+                        GI.Gst.Structs.CapsFeatures+                        GI.Gst.Structs.ClockEntry+                        GI.Gst.Structs.Context+                        GI.Gst.Structs.DateTime+                        GI.Gst.Structs.DebugCategory+                        GI.Gst.Structs.DebugMessage+                        GI.Gst.Structs.Event+                        GI.Gst.Structs.FormatDefinition+                        GI.Gst.Structs.Iterator+                        GI.Gst.Structs.MapInfo+                        GI.Gst.Structs.Memory+                        GI.Gst.Structs.Message+                        GI.Gst.Structs.Meta+                        GI.Gst.Structs.MetaInfo+                        GI.Gst.Structs.MetaTransformCopy+                        GI.Gst.Structs.MiniObject+                        GI.Gst.Structs.PadProbeInfo+                        GI.Gst.Structs.ParamSpecFraction+                        GI.Gst.Structs.ParentBufferMeta+                        GI.Gst.Structs.ParseContext+                        GI.Gst.Structs.PluginDesc+                        GI.Gst.Structs.Poll+                        GI.Gst.Structs.PollFD+                        GI.Gst.Structs.ProtectionMeta+                        GI.Gst.Structs.Query+                        GI.Gst.Structs.Sample+                        GI.Gst.Structs.Segment+                        GI.Gst.Structs.StaticCaps+                        GI.Gst.Structs.StaticPadTemplate+                        GI.Gst.Structs.Structure+                        GI.Gst.Structs.TagList+                        GI.Gst.Structs.TimedValue+                        GI.Gst.Structs.Toc+                        GI.Gst.Structs.TocEntry+                        GI.Gst.Structs.TypeFind+                        GI.Gst.Structs.Uri+                        GI.Gst.Structs.ValueTable+    pkgconfig-depends:  gstreamer-1.0 >= 1.6+    build-depends: base >= 4.8 && <5,+        haskell-gi-base >= 0.13 && < 1,+        gi-glib >= 0.2.46.13 && < 0.2.47,+        gi-gobject >= 0.2.46.13 && < 0.2.47,+        bytestring >= 0.10,+        containers >= 0.5,+        text >= 1.0,+        transformers >= 0.3