#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Gst.Objects.Bin
(
Bin(..) ,
IsBin ,
toBin ,
noBin ,
#if ENABLE_OVERLOADING
BinAddMethodInfo ,
#endif
binAdd ,
#if ENABLE_OVERLOADING
BinFindUnlinkedPadMethodInfo ,
#endif
binFindUnlinkedPad ,
#if ENABLE_OVERLOADING
BinGetByInterfaceMethodInfo ,
#endif
binGetByInterface ,
#if ENABLE_OVERLOADING
BinGetByNameMethodInfo ,
#endif
binGetByName ,
#if ENABLE_OVERLOADING
BinGetByNameRecurseUpMethodInfo ,
#endif
binGetByNameRecurseUp ,
#if ENABLE_OVERLOADING
BinGetSuppressedFlagsMethodInfo ,
#endif
binGetSuppressedFlags ,
#if ENABLE_OVERLOADING
BinIterateAllByInterfaceMethodInfo ,
#endif
binIterateAllByInterface ,
#if ENABLE_OVERLOADING
BinIterateElementsMethodInfo ,
#endif
binIterateElements ,
#if ENABLE_OVERLOADING
BinIterateRecurseMethodInfo ,
#endif
binIterateRecurse ,
#if ENABLE_OVERLOADING
BinIterateSinksMethodInfo ,
#endif
binIterateSinks ,
#if ENABLE_OVERLOADING
BinIterateSortedMethodInfo ,
#endif
binIterateSorted ,
#if ENABLE_OVERLOADING
BinIterateSourcesMethodInfo ,
#endif
binIterateSources ,
binNew ,
#if ENABLE_OVERLOADING
BinRecalculateLatencyMethodInfo ,
#endif
binRecalculateLatency ,
#if ENABLE_OVERLOADING
BinRemoveMethodInfo ,
#endif
binRemove ,
#if ENABLE_OVERLOADING
BinSetSuppressedFlagsMethodInfo ,
#endif
binSetSuppressedFlags ,
#if ENABLE_OVERLOADING
BinSyncChildrenStatesMethodInfo ,
#endif
binSyncChildrenStates ,
#if ENABLE_OVERLOADING
BinAsyncHandlingPropertyInfo ,
#endif
#if ENABLE_OVERLOADING
binAsyncHandling ,
#endif
constructBinAsyncHandling ,
getBinAsyncHandling ,
setBinAsyncHandling ,
#if ENABLE_OVERLOADING
BinMessageForwardPropertyInfo ,
#endif
#if ENABLE_OVERLOADING
binMessageForward ,
#endif
constructBinMessageForward ,
getBinMessageForward ,
setBinMessageForward ,
BinDeepElementAddedCallback ,
#if ENABLE_OVERLOADING
BinDeepElementAddedSignalInfo ,
#endif
C_BinDeepElementAddedCallback ,
afterBinDeepElementAdded ,
genClosure_BinDeepElementAdded ,
mk_BinDeepElementAddedCallback ,
noBinDeepElementAddedCallback ,
onBinDeepElementAdded ,
wrap_BinDeepElementAddedCallback ,
BinDeepElementRemovedCallback ,
#if ENABLE_OVERLOADING
BinDeepElementRemovedSignalInfo ,
#endif
C_BinDeepElementRemovedCallback ,
afterBinDeepElementRemoved ,
genClosure_BinDeepElementRemoved ,
mk_BinDeepElementRemovedCallback ,
noBinDeepElementRemovedCallback ,
onBinDeepElementRemoved ,
wrap_BinDeepElementRemovedCallback ,
BinDoLatencyCallback ,
#if ENABLE_OVERLOADING
BinDoLatencySignalInfo ,
#endif
C_BinDoLatencyCallback ,
afterBinDoLatency ,
genClosure_BinDoLatency ,
mk_BinDoLatencyCallback ,
noBinDoLatencyCallback ,
onBinDoLatency ,
wrap_BinDoLatencyCallback ,
BinElementAddedCallback ,
#if ENABLE_OVERLOADING
BinElementAddedSignalInfo ,
#endif
C_BinElementAddedCallback ,
afterBinElementAdded ,
genClosure_BinElementAdded ,
mk_BinElementAddedCallback ,
noBinElementAddedCallback ,
onBinElementAdded ,
wrap_BinElementAddedCallback ,
BinElementRemovedCallback ,
#if ENABLE_OVERLOADING
BinElementRemovedSignalInfo ,
#endif
C_BinElementRemovedCallback ,
afterBinElementRemoved ,
genClosure_BinElementRemoved ,
mk_BinElementRemovedCallback ,
noBinElementRemovedCallback ,
onBinElementRemoved ,
wrap_BinElementRemovedCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Interfaces.ChildProxy as Gst.ChildProxy
import {-# SOURCE #-} qualified GI.Gst.Objects.Element as Gst.Element
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Pad as Gst.Pad
import {-# SOURCE #-} qualified GI.Gst.Structs.Iterator as Gst.Iterator
newtype Bin = Bin (ManagedPtr Bin)
foreign import ccall "gst_bin_get_type"
c_gst_bin_get_type :: IO GType
instance GObject Bin where
gobjectType = c_gst_bin_get_type
class (GObject o, O.IsDescendantOf Bin o) => IsBin o
instance (GObject o, O.IsDescendantOf Bin o) => IsBin o
instance O.HasParentTypes Bin
type instance O.ParentTypes Bin = '[Gst.Element.Element, Gst.Object.Object, GObject.Object.Object, Gst.ChildProxy.ChildProxy]
toBin :: (MonadIO m, IsBin o) => o -> m Bin
toBin = liftIO . unsafeCastTo Bin
noBin :: Maybe Bin
noBin = Nothing
#if ENABLE_OVERLOADING
type family ResolveBinMethod (t :: Symbol) (o :: *) :: * where
ResolveBinMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo
ResolveBinMethod "add" o = BinAddMethodInfo
ResolveBinMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveBinMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo
ResolveBinMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo
ResolveBinMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo
ResolveBinMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveBinMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveBinMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo
ResolveBinMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo
ResolveBinMethod "childAdded" o = Gst.ChildProxy.ChildProxyChildAddedMethodInfo
ResolveBinMethod "childRemoved" o = Gst.ChildProxy.ChildProxyChildRemovedMethodInfo
ResolveBinMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo
ResolveBinMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo
ResolveBinMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveBinMethod "findUnlinkedPad" o = BinFindUnlinkedPadMethodInfo
ResolveBinMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveBinMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo
ResolveBinMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo
ResolveBinMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo
ResolveBinMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveBinMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveBinMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveBinMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveBinMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveBinMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveBinMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveBinMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo
ResolveBinMethod "iterateAllByInterface" o = BinIterateAllByInterfaceMethodInfo
ResolveBinMethod "iterateElements" o = BinIterateElementsMethodInfo
ResolveBinMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo
ResolveBinMethod "iterateRecurse" o = BinIterateRecurseMethodInfo
ResolveBinMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo
ResolveBinMethod "iterateSinks" o = BinIterateSinksMethodInfo
ResolveBinMethod "iterateSorted" o = BinIterateSortedMethodInfo
ResolveBinMethod "iterateSources" o = BinIterateSourcesMethodInfo
ResolveBinMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo
ResolveBinMethod "link" o = Gst.Element.ElementLinkMethodInfo
ResolveBinMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo
ResolveBinMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo
ResolveBinMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo
ResolveBinMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo
ResolveBinMethod "lookup" o = Gst.ChildProxy.ChildProxyLookupMethodInfo
ResolveBinMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo
ResolveBinMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo
ResolveBinMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo
ResolveBinMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo
ResolveBinMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveBinMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveBinMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo
ResolveBinMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo
ResolveBinMethod "query" o = Gst.Element.ElementQueryMethodInfo
ResolveBinMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo
ResolveBinMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo
ResolveBinMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo
ResolveBinMethod "recalculateLatency" o = BinRecalculateLatencyMethodInfo
ResolveBinMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveBinMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveBinMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo
ResolveBinMethod "remove" o = BinRemoveMethodInfo
ResolveBinMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveBinMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo
ResolveBinMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo
ResolveBinMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo
ResolveBinMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveBinMethod "seek" o = Gst.Element.ElementSeekMethodInfo
ResolveBinMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo
ResolveBinMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo
ResolveBinMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveBinMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveBinMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveBinMethod "syncChildrenStates" o = BinSyncChildrenStatesMethodInfo
ResolveBinMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo
ResolveBinMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveBinMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveBinMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo
ResolveBinMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo
ResolveBinMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveBinMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveBinMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveBinMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo
ResolveBinMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo
ResolveBinMethod "getByInterface" o = BinGetByInterfaceMethodInfo
ResolveBinMethod "getByName" o = BinGetByNameMethodInfo
ResolveBinMethod "getByNameRecurseUp" o = BinGetByNameRecurseUpMethodInfo
ResolveBinMethod "getChildByIndex" o = Gst.ChildProxy.ChildProxyGetChildByIndexMethodInfo
ResolveBinMethod "getChildByName" o = Gst.ChildProxy.ChildProxyGetChildByNameMethodInfo
ResolveBinMethod "getChildrenCount" o = Gst.ChildProxy.ChildProxyGetChildrenCountMethodInfo
ResolveBinMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo
ResolveBinMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo
ResolveBinMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo
ResolveBinMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo
ResolveBinMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo
ResolveBinMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo
ResolveBinMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveBinMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveBinMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveBinMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo
ResolveBinMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveBinMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo
ResolveBinMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveBinMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo
ResolveBinMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo
ResolveBinMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveBinMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveBinMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveBinMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveBinMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo
ResolveBinMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo
ResolveBinMethod "getState" o = Gst.Element.ElementGetStateMethodInfo
ResolveBinMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo
ResolveBinMethod "getSuppressedFlags" o = BinGetSuppressedFlagsMethodInfo
ResolveBinMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveBinMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo
ResolveBinMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo
ResolveBinMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo
ResolveBinMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo
ResolveBinMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveBinMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveBinMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveBinMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveBinMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo
ResolveBinMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveBinMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveBinMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveBinMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo
ResolveBinMethod "setState" o = Gst.Element.ElementSetStateMethodInfo
ResolveBinMethod "setSuppressedFlags" o = BinSetSuppressedFlagsMethodInfo
ResolveBinMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBinMethod t Bin, O.MethodInfo info Bin p) => OL.IsLabel t (Bin -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
type BinDeepElementAddedCallback =
Bin
-> Gst.Element.Element
-> IO ()
noBinDeepElementAddedCallback :: Maybe BinDeepElementAddedCallback
noBinDeepElementAddedCallback = Nothing
type C_BinDeepElementAddedCallback =
Ptr () ->
Ptr Bin ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_BinDeepElementAddedCallback :: C_BinDeepElementAddedCallback -> IO (FunPtr C_BinDeepElementAddedCallback)
genClosure_BinDeepElementAdded :: MonadIO m => BinDeepElementAddedCallback -> m (GClosure C_BinDeepElementAddedCallback)
genClosure_BinDeepElementAdded cb = liftIO $ do
let cb' = wrap_BinDeepElementAddedCallback cb
mk_BinDeepElementAddedCallback cb' >>= B.GClosure.newGClosure
wrap_BinDeepElementAddedCallback ::
BinDeepElementAddedCallback ->
C_BinDeepElementAddedCallback
wrap_BinDeepElementAddedCallback _cb _ subBin element _ = do
subBin' <- (newObject Bin) subBin
element' <- (newObject Gst.Element.Element) element
_cb subBin' element'
onBinDeepElementAdded :: (IsBin a, MonadIO m) => a -> BinDeepElementAddedCallback -> m SignalHandlerId
onBinDeepElementAdded obj cb = liftIO $ do
let cb' = wrap_BinDeepElementAddedCallback cb
cb'' <- mk_BinDeepElementAddedCallback cb'
connectSignalFunPtr obj "deep-element-added" cb'' SignalConnectBefore
afterBinDeepElementAdded :: (IsBin a, MonadIO m) => a -> BinDeepElementAddedCallback -> m SignalHandlerId
afterBinDeepElementAdded obj cb = liftIO $ do
let cb' = wrap_BinDeepElementAddedCallback cb
cb'' <- mk_BinDeepElementAddedCallback cb'
connectSignalFunPtr obj "deep-element-added" cb'' SignalConnectAfter
type BinDeepElementRemovedCallback =
Bin
-> Gst.Element.Element
-> IO ()
noBinDeepElementRemovedCallback :: Maybe BinDeepElementRemovedCallback
noBinDeepElementRemovedCallback = Nothing
type C_BinDeepElementRemovedCallback =
Ptr () ->
Ptr Bin ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_BinDeepElementRemovedCallback :: C_BinDeepElementRemovedCallback -> IO (FunPtr C_BinDeepElementRemovedCallback)
genClosure_BinDeepElementRemoved :: MonadIO m => BinDeepElementRemovedCallback -> m (GClosure C_BinDeepElementRemovedCallback)
genClosure_BinDeepElementRemoved cb = liftIO $ do
let cb' = wrap_BinDeepElementRemovedCallback cb
mk_BinDeepElementRemovedCallback cb' >>= B.GClosure.newGClosure
wrap_BinDeepElementRemovedCallback ::
BinDeepElementRemovedCallback ->
C_BinDeepElementRemovedCallback
wrap_BinDeepElementRemovedCallback _cb _ subBin element _ = do
subBin' <- (newObject Bin) subBin
element' <- (newObject Gst.Element.Element) element
_cb subBin' element'
onBinDeepElementRemoved :: (IsBin a, MonadIO m) => a -> BinDeepElementRemovedCallback -> m SignalHandlerId
onBinDeepElementRemoved obj cb = liftIO $ do
let cb' = wrap_BinDeepElementRemovedCallback cb
cb'' <- mk_BinDeepElementRemovedCallback cb'
connectSignalFunPtr obj "deep-element-removed" cb'' SignalConnectBefore
afterBinDeepElementRemoved :: (IsBin a, MonadIO m) => a -> BinDeepElementRemovedCallback -> m SignalHandlerId
afterBinDeepElementRemoved obj cb = liftIO $ do
let cb' = wrap_BinDeepElementRemovedCallback cb
cb'' <- mk_BinDeepElementRemovedCallback cb'
connectSignalFunPtr obj "deep-element-removed" cb'' SignalConnectAfter
type BinDoLatencyCallback =
IO Bool
noBinDoLatencyCallback :: Maybe BinDoLatencyCallback
noBinDoLatencyCallback = Nothing
type C_BinDoLatencyCallback =
Ptr () ->
Ptr () ->
IO CInt
foreign import ccall "wrapper"
mk_BinDoLatencyCallback :: C_BinDoLatencyCallback -> IO (FunPtr C_BinDoLatencyCallback)
genClosure_BinDoLatency :: MonadIO m => BinDoLatencyCallback -> m (GClosure C_BinDoLatencyCallback)
genClosure_BinDoLatency cb = liftIO $ do
let cb' = wrap_BinDoLatencyCallback cb
mk_BinDoLatencyCallback cb' >>= B.GClosure.newGClosure
wrap_BinDoLatencyCallback ::
BinDoLatencyCallback ->
C_BinDoLatencyCallback
wrap_BinDoLatencyCallback _cb _ _ = do
result <- _cb
let result' = (fromIntegral . fromEnum) result
return result'
onBinDoLatency :: (IsBin a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId
onBinDoLatency obj cb = liftIO $ do
let cb' = wrap_BinDoLatencyCallback cb
cb'' <- mk_BinDoLatencyCallback cb'
connectSignalFunPtr obj "do-latency" cb'' SignalConnectBefore
afterBinDoLatency :: (IsBin a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId
afterBinDoLatency obj cb = liftIO $ do
let cb' = wrap_BinDoLatencyCallback cb
cb'' <- mk_BinDoLatencyCallback cb'
connectSignalFunPtr obj "do-latency" cb'' SignalConnectAfter
type BinElementAddedCallback =
Gst.Element.Element
-> IO ()
noBinElementAddedCallback :: Maybe BinElementAddedCallback
noBinElementAddedCallback = Nothing
type C_BinElementAddedCallback =
Ptr () ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_BinElementAddedCallback :: C_BinElementAddedCallback -> IO (FunPtr C_BinElementAddedCallback)
genClosure_BinElementAdded :: MonadIO m => BinElementAddedCallback -> m (GClosure C_BinElementAddedCallback)
genClosure_BinElementAdded cb = liftIO $ do
let cb' = wrap_BinElementAddedCallback cb
mk_BinElementAddedCallback cb' >>= B.GClosure.newGClosure
wrap_BinElementAddedCallback ::
BinElementAddedCallback ->
C_BinElementAddedCallback
wrap_BinElementAddedCallback _cb _ element _ = do
element' <- (newObject Gst.Element.Element) element
_cb element'
onBinElementAdded :: (IsBin a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId
onBinElementAdded obj cb = liftIO $ do
let cb' = wrap_BinElementAddedCallback cb
cb'' <- mk_BinElementAddedCallback cb'
connectSignalFunPtr obj "element-added" cb'' SignalConnectBefore
afterBinElementAdded :: (IsBin a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId
afterBinElementAdded obj cb = liftIO $ do
let cb' = wrap_BinElementAddedCallback cb
cb'' <- mk_BinElementAddedCallback cb'
connectSignalFunPtr obj "element-added" cb'' SignalConnectAfter
type BinElementRemovedCallback =
Gst.Element.Element
-> IO ()
noBinElementRemovedCallback :: Maybe BinElementRemovedCallback
noBinElementRemovedCallback = Nothing
type C_BinElementRemovedCallback =
Ptr () ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_BinElementRemovedCallback :: C_BinElementRemovedCallback -> IO (FunPtr C_BinElementRemovedCallback)
genClosure_BinElementRemoved :: MonadIO m => BinElementRemovedCallback -> m (GClosure C_BinElementRemovedCallback)
genClosure_BinElementRemoved cb = liftIO $ do
let cb' = wrap_BinElementRemovedCallback cb
mk_BinElementRemovedCallback cb' >>= B.GClosure.newGClosure
wrap_BinElementRemovedCallback ::
BinElementRemovedCallback ->
C_BinElementRemovedCallback
wrap_BinElementRemovedCallback _cb _ element _ = do
element' <- (newObject Gst.Element.Element) element
_cb element'
onBinElementRemoved :: (IsBin a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId
onBinElementRemoved obj cb = liftIO $ do
let cb' = wrap_BinElementRemovedCallback cb
cb'' <- mk_BinElementRemovedCallback cb'
connectSignalFunPtr obj "element-removed" cb'' SignalConnectBefore
afterBinElementRemoved :: (IsBin a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId
afterBinElementRemoved obj cb = liftIO $ do
let cb' = wrap_BinElementRemovedCallback cb
cb'' <- mk_BinElementRemovedCallback cb'
connectSignalFunPtr obj "element-removed" cb'' SignalConnectAfter
getBinAsyncHandling :: (MonadIO m, IsBin o) => o -> m Bool
getBinAsyncHandling obj = liftIO $ B.Properties.getObjectPropertyBool obj "async-handling"
setBinAsyncHandling :: (MonadIO m, IsBin o) => o -> Bool -> m ()
setBinAsyncHandling obj val = liftIO $ B.Properties.setObjectPropertyBool obj "async-handling" val
constructBinAsyncHandling :: (IsBin o) => Bool -> IO (GValueConstruct o)
constructBinAsyncHandling val = B.Properties.constructObjectPropertyBool "async-handling" val
#if ENABLE_OVERLOADING
data BinAsyncHandlingPropertyInfo
instance AttrInfo BinAsyncHandlingPropertyInfo where
type AttrAllowedOps BinAsyncHandlingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint BinAsyncHandlingPropertyInfo = (~) Bool
type AttrBaseTypeConstraint BinAsyncHandlingPropertyInfo = IsBin
type AttrGetType BinAsyncHandlingPropertyInfo = Bool
type AttrLabel BinAsyncHandlingPropertyInfo = "async-handling"
type AttrOrigin BinAsyncHandlingPropertyInfo = Bin
attrGet _ = getBinAsyncHandling
attrSet _ = setBinAsyncHandling
attrConstruct _ = constructBinAsyncHandling
attrClear _ = undefined
#endif
getBinMessageForward :: (MonadIO m, IsBin o) => o -> m Bool
getBinMessageForward obj = liftIO $ B.Properties.getObjectPropertyBool obj "message-forward"
setBinMessageForward :: (MonadIO m, IsBin o) => o -> Bool -> m ()
setBinMessageForward obj val = liftIO $ B.Properties.setObjectPropertyBool obj "message-forward" val
constructBinMessageForward :: (IsBin o) => Bool -> IO (GValueConstruct o)
constructBinMessageForward val = B.Properties.constructObjectPropertyBool "message-forward" val
#if ENABLE_OVERLOADING
data BinMessageForwardPropertyInfo
instance AttrInfo BinMessageForwardPropertyInfo where
type AttrAllowedOps BinMessageForwardPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint BinMessageForwardPropertyInfo = (~) Bool
type AttrBaseTypeConstraint BinMessageForwardPropertyInfo = IsBin
type AttrGetType BinMessageForwardPropertyInfo = Bool
type AttrLabel BinMessageForwardPropertyInfo = "message-forward"
type AttrOrigin BinMessageForwardPropertyInfo = Bin
attrGet _ = getBinMessageForward
attrSet _ = setBinMessageForward
attrConstruct _ = constructBinMessageForward
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Bin
type instance O.AttributeList Bin = BinAttributeList
type BinAttributeList = ('[ '("asyncHandling", BinAsyncHandlingPropertyInfo), '("messageForward", BinMessageForwardPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
binAsyncHandling :: AttrLabelProxy "asyncHandling"
binAsyncHandling = AttrLabelProxy
binMessageForward :: AttrLabelProxy "messageForward"
binMessageForward = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
data BinDeepElementAddedSignalInfo
instance SignalInfo BinDeepElementAddedSignalInfo where
type HaskellCallbackType BinDeepElementAddedSignalInfo = BinDeepElementAddedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_BinDeepElementAddedCallback cb
cb'' <- mk_BinDeepElementAddedCallback cb'
connectSignalFunPtr obj "deep-element-added" cb'' connectMode
data BinDeepElementRemovedSignalInfo
instance SignalInfo BinDeepElementRemovedSignalInfo where
type HaskellCallbackType BinDeepElementRemovedSignalInfo = BinDeepElementRemovedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_BinDeepElementRemovedCallback cb
cb'' <- mk_BinDeepElementRemovedCallback cb'
connectSignalFunPtr obj "deep-element-removed" cb'' connectMode
data BinDoLatencySignalInfo
instance SignalInfo BinDoLatencySignalInfo where
type HaskellCallbackType BinDoLatencySignalInfo = BinDoLatencyCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_BinDoLatencyCallback cb
cb'' <- mk_BinDoLatencyCallback cb'
connectSignalFunPtr obj "do-latency" cb'' connectMode
data BinElementAddedSignalInfo
instance SignalInfo BinElementAddedSignalInfo where
type HaskellCallbackType BinElementAddedSignalInfo = BinElementAddedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_BinElementAddedCallback cb
cb'' <- mk_BinElementAddedCallback cb'
connectSignalFunPtr obj "element-added" cb'' connectMode
data BinElementRemovedSignalInfo
instance SignalInfo BinElementRemovedSignalInfo where
type HaskellCallbackType BinElementRemovedSignalInfo = BinElementRemovedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_BinElementRemovedCallback cb
cb'' <- mk_BinElementRemovedCallback cb'
connectSignalFunPtr obj "element-removed" cb'' connectMode
type instance O.SignalList Bin = BinSignalList
type BinSignalList = ('[ '("childAdded", Gst.ChildProxy.ChildProxyChildAddedSignalInfo), '("childRemoved", Gst.ChildProxy.ChildProxyChildRemovedSignalInfo), '("deepElementAdded", BinDeepElementAddedSignalInfo), '("deepElementRemoved", BinDeepElementRemovedSignalInfo), '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("doLatency", BinDoLatencySignalInfo), '("elementAdded", BinElementAddedSignalInfo), '("elementRemoved", BinElementRemovedSignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_bin_new" gst_bin_new ::
CString ->
IO (Ptr Bin)
binNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m Bin
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 "binNew" result
result' <- (newObject Bin) result
freeMem maybeName
return result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "gst_bin_add" gst_bin_add ::
Ptr Bin ->
Ptr Gst.Element.Element ->
IO CInt
binAdd ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a, Gst.Element.IsElement b) =>
a
-> b
-> m Bool
binAdd bin element = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
element' <- unsafeManagedPtrCastPtr element
result <- gst_bin_add bin' element'
let result' = (/= 0) result
touchManagedPtr bin
touchManagedPtr element
return result'
#if ENABLE_OVERLOADING
data BinAddMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsBin a, Gst.Element.IsElement b) => O.MethodInfo BinAddMethodInfo a signature where
overloadedMethod _ = binAdd
#endif
foreign import ccall "gst_bin_find_unlinked_pad" gst_bin_find_unlinked_pad ::
Ptr Bin ->
CUInt ->
IO (Ptr Gst.Pad.Pad)
binFindUnlinkedPad ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> Gst.Enums.PadDirection
-> m (Maybe Gst.Pad.Pad)
binFindUnlinkedPad bin direction = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
let direction' = (fromIntegral . fromEnum) direction
result <- gst_bin_find_unlinked_pad bin' direction'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Gst.Pad.Pad) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinFindUnlinkedPadMethodInfo
instance (signature ~ (Gst.Enums.PadDirection -> m (Maybe Gst.Pad.Pad)), MonadIO m, IsBin a) => O.MethodInfo BinFindUnlinkedPadMethodInfo a signature where
overloadedMethod _ = binFindUnlinkedPad
#endif
foreign import ccall "gst_bin_get_by_interface" gst_bin_get_by_interface ::
Ptr Bin ->
CGType ->
IO (Ptr Gst.Element.Element)
binGetByInterface ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> GType
-> m (Maybe Gst.Element.Element)
binGetByInterface bin iface = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
let iface' = gtypeToCGType iface
result <- gst_bin_get_by_interface bin' iface'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Gst.Element.Element) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinGetByInterfaceMethodInfo
instance (signature ~ (GType -> m (Maybe Gst.Element.Element)), MonadIO m, IsBin a) => O.MethodInfo BinGetByInterfaceMethodInfo a signature where
overloadedMethod _ = binGetByInterface
#endif
foreign import ccall "gst_bin_get_by_name" gst_bin_get_by_name ::
Ptr Bin ->
CString ->
IO (Ptr Gst.Element.Element)
binGetByName ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> T.Text
-> m (Maybe Gst.Element.Element)
binGetByName bin name = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
name' <- textToCString name
result <- gst_bin_get_by_name bin' name'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Gst.Element.Element) result'
return result''
touchManagedPtr bin
freeMem name'
return maybeResult
#if ENABLE_OVERLOADING
data BinGetByNameMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.Element.Element)), MonadIO m, IsBin a) => O.MethodInfo BinGetByNameMethodInfo a signature where
overloadedMethod _ = binGetByName
#endif
foreign import ccall "gst_bin_get_by_name_recurse_up" gst_bin_get_by_name_recurse_up ::
Ptr Bin ->
CString ->
IO (Ptr Gst.Element.Element)
binGetByNameRecurseUp ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> T.Text
-> m (Maybe Gst.Element.Element)
binGetByNameRecurseUp bin name = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
name' <- textToCString name
result <- gst_bin_get_by_name_recurse_up bin' name'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Gst.Element.Element) result'
return result''
touchManagedPtr bin
freeMem name'
return maybeResult
#if ENABLE_OVERLOADING
data BinGetByNameRecurseUpMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.Element.Element)), MonadIO m, IsBin a) => O.MethodInfo BinGetByNameRecurseUpMethodInfo a signature where
overloadedMethod _ = binGetByNameRecurseUp
#endif
foreign import ccall "gst_bin_get_suppressed_flags" gst_bin_get_suppressed_flags ::
Ptr Bin ->
IO CUInt
binGetSuppressedFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m [Gst.Flags.ElementFlags]
binGetSuppressedFlags bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_get_suppressed_flags bin'
let result' = wordToGFlags result
touchManagedPtr bin
return result'
#if ENABLE_OVERLOADING
data BinGetSuppressedFlagsMethodInfo
instance (signature ~ (m [Gst.Flags.ElementFlags]), MonadIO m, IsBin a) => O.MethodInfo BinGetSuppressedFlagsMethodInfo a signature where
overloadedMethod _ = binGetSuppressedFlags
#endif
foreign import ccall "gst_bin_iterate_all_by_interface" gst_bin_iterate_all_by_interface ::
Ptr Bin ->
CGType ->
IO (Ptr Gst.Iterator.Iterator)
binIterateAllByInterface ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> GType
-> m (Maybe Gst.Iterator.Iterator)
binIterateAllByInterface bin iface = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
let iface' = gtypeToCGType iface
result <- gst_bin_iterate_all_by_interface bin' iface'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.Iterator.Iterator) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinIterateAllByInterfaceMethodInfo
instance (signature ~ (GType -> m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsBin a) => O.MethodInfo BinIterateAllByInterfaceMethodInfo a signature where
overloadedMethod _ = binIterateAllByInterface
#endif
foreign import ccall "gst_bin_iterate_elements" gst_bin_iterate_elements ::
Ptr Bin ->
IO (Ptr Gst.Iterator.Iterator)
binIterateElements ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m (Maybe Gst.Iterator.Iterator)
binIterateElements bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_iterate_elements bin'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.Iterator.Iterator) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinIterateElementsMethodInfo
instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsBin a) => O.MethodInfo BinIterateElementsMethodInfo a signature where
overloadedMethod _ = binIterateElements
#endif
foreign import ccall "gst_bin_iterate_recurse" gst_bin_iterate_recurse ::
Ptr Bin ->
IO (Ptr Gst.Iterator.Iterator)
binIterateRecurse ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m (Maybe Gst.Iterator.Iterator)
binIterateRecurse bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_iterate_recurse bin'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.Iterator.Iterator) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinIterateRecurseMethodInfo
instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsBin a) => O.MethodInfo BinIterateRecurseMethodInfo a signature where
overloadedMethod _ = binIterateRecurse
#endif
foreign import ccall "gst_bin_iterate_sinks" gst_bin_iterate_sinks ::
Ptr Bin ->
IO (Ptr Gst.Iterator.Iterator)
binIterateSinks ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m (Maybe Gst.Iterator.Iterator)
binIterateSinks bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_iterate_sinks bin'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.Iterator.Iterator) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinIterateSinksMethodInfo
instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsBin a) => O.MethodInfo BinIterateSinksMethodInfo a signature where
overloadedMethod _ = binIterateSinks
#endif
foreign import ccall "gst_bin_iterate_sorted" gst_bin_iterate_sorted ::
Ptr Bin ->
IO (Ptr Gst.Iterator.Iterator)
binIterateSorted ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m (Maybe Gst.Iterator.Iterator)
binIterateSorted bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_iterate_sorted bin'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.Iterator.Iterator) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinIterateSortedMethodInfo
instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsBin a) => O.MethodInfo BinIterateSortedMethodInfo a signature where
overloadedMethod _ = binIterateSorted
#endif
foreign import ccall "gst_bin_iterate_sources" gst_bin_iterate_sources ::
Ptr Bin ->
IO (Ptr Gst.Iterator.Iterator)
binIterateSources ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m (Maybe Gst.Iterator.Iterator)
binIterateSources bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_iterate_sources bin'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapBoxed Gst.Iterator.Iterator) result'
return result''
touchManagedPtr bin
return maybeResult
#if ENABLE_OVERLOADING
data BinIterateSourcesMethodInfo
instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsBin a) => O.MethodInfo BinIterateSourcesMethodInfo a signature where
overloadedMethod _ = binIterateSources
#endif
foreign import ccall "gst_bin_recalculate_latency" gst_bin_recalculate_latency ::
Ptr Bin ->
IO CInt
binRecalculateLatency ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m Bool
binRecalculateLatency bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_recalculate_latency bin'
let result' = (/= 0) result
touchManagedPtr bin
return result'
#if ENABLE_OVERLOADING
data BinRecalculateLatencyMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBin a) => O.MethodInfo BinRecalculateLatencyMethodInfo a signature where
overloadedMethod _ = binRecalculateLatency
#endif
foreign import ccall "gst_bin_remove" gst_bin_remove ::
Ptr Bin ->
Ptr Gst.Element.Element ->
IO CInt
binRemove ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a, Gst.Element.IsElement b) =>
a
-> b
-> m Bool
binRemove bin element = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
element' <- unsafeManagedPtrCastPtr element
result <- gst_bin_remove bin' element'
let result' = (/= 0) result
touchManagedPtr bin
touchManagedPtr element
return result'
#if ENABLE_OVERLOADING
data BinRemoveMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsBin a, Gst.Element.IsElement b) => O.MethodInfo BinRemoveMethodInfo a signature where
overloadedMethod _ = binRemove
#endif
foreign import ccall "gst_bin_set_suppressed_flags" gst_bin_set_suppressed_flags ::
Ptr Bin ->
CUInt ->
IO ()
binSetSuppressedFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> [Gst.Flags.ElementFlags]
-> m ()
binSetSuppressedFlags bin flags = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
let flags' = gflagsToWord flags
gst_bin_set_suppressed_flags bin' flags'
touchManagedPtr bin
return ()
#if ENABLE_OVERLOADING
data BinSetSuppressedFlagsMethodInfo
instance (signature ~ ([Gst.Flags.ElementFlags] -> m ()), MonadIO m, IsBin a) => O.MethodInfo BinSetSuppressedFlagsMethodInfo a signature where
overloadedMethod _ = binSetSuppressedFlags
#endif
foreign import ccall "gst_bin_sync_children_states" gst_bin_sync_children_states ::
Ptr Bin ->
IO CInt
binSyncChildrenStates ::
(B.CallStack.HasCallStack, MonadIO m, IsBin a) =>
a
-> m Bool
binSyncChildrenStates bin = liftIO $ do
bin' <- unsafeManagedPtrCastPtr bin
result <- gst_bin_sync_children_states bin'
let result' = (/= 0) result
touchManagedPtr bin
return result'
#if ENABLE_OVERLOADING
data BinSyncChildrenStatesMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBin a) => O.MethodInfo BinSyncChildrenStatesMethodInfo a signature where
overloadedMethod _ = binSyncChildrenStates
#endif