{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Bus
(
Bus(..) ,
IsBus ,
toBus ,
noBus ,
#if defined(ENABLE_OVERLOADING)
ResolveBusMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BusAddSignalWatchMethodInfo ,
#endif
busAddSignalWatch ,
#if defined(ENABLE_OVERLOADING)
BusAddSignalWatchFullMethodInfo ,
#endif
busAddSignalWatchFull ,
#if defined(ENABLE_OVERLOADING)
BusAddWatchMethodInfo ,
#endif
busAddWatch ,
#if defined(ENABLE_OVERLOADING)
BusAsyncSignalFuncMethodInfo ,
#endif
busAsyncSignalFunc ,
#if defined(ENABLE_OVERLOADING)
BusCreateWatchMethodInfo ,
#endif
busCreateWatch ,
#if defined(ENABLE_OVERLOADING)
BusDisableSyncMessageEmissionMethodInfo ,
#endif
busDisableSyncMessageEmission ,
#if defined(ENABLE_OVERLOADING)
BusEnableSyncMessageEmissionMethodInfo ,
#endif
busEnableSyncMessageEmission ,
#if defined(ENABLE_OVERLOADING)
BusGetPollfdMethodInfo ,
#endif
busGetPollfd ,
#if defined(ENABLE_OVERLOADING)
BusHavePendingMethodInfo ,
#endif
busHavePending ,
busNew ,
#if defined(ENABLE_OVERLOADING)
BusPeekMethodInfo ,
#endif
busPeek ,
#if defined(ENABLE_OVERLOADING)
BusPollMethodInfo ,
#endif
busPoll ,
#if defined(ENABLE_OVERLOADING)
BusPopMethodInfo ,
#endif
busPop ,
#if defined(ENABLE_OVERLOADING)
BusPopFilteredMethodInfo ,
#endif
busPopFiltered ,
#if defined(ENABLE_OVERLOADING)
BusPostMethodInfo ,
#endif
busPost ,
#if defined(ENABLE_OVERLOADING)
BusRemoveSignalWatchMethodInfo ,
#endif
busRemoveSignalWatch ,
#if defined(ENABLE_OVERLOADING)
BusRemoveWatchMethodInfo ,
#endif
busRemoveWatch ,
#if defined(ENABLE_OVERLOADING)
BusSetFlushingMethodInfo ,
#endif
busSetFlushing ,
#if defined(ENABLE_OVERLOADING)
BusSetSyncHandlerMethodInfo ,
#endif
busSetSyncHandler ,
#if defined(ENABLE_OVERLOADING)
BusSyncSignalHandlerMethodInfo ,
#endif
busSyncSignalHandler ,
#if defined(ENABLE_OVERLOADING)
BusTimedPopMethodInfo ,
#endif
busTimedPop ,
#if defined(ENABLE_OVERLOADING)
BusTimedPopFilteredMethodInfo ,
#endif
busTimedPopFiltered ,
#if defined(ENABLE_OVERLOADING)
BusEnableAsyncPropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING)
busEnableAsync ,
#endif
constructBusEnableAsync ,
BusMessageCallback ,
#if defined(ENABLE_OVERLOADING)
BusMessageSignalInfo ,
#endif
C_BusMessageCallback ,
afterBusMessage ,
genClosure_BusMessage ,
mk_BusMessageCallback ,
noBusMessageCallback ,
onBusMessage ,
wrap_BusMessageCallback ,
BusSyncMessageCallback ,
#if defined(ENABLE_OVERLOADING)
BusSyncMessageSignalInfo ,
#endif
C_BusSyncMessageCallback ,
afterBusSyncMessage ,
genClosure_BusSyncMessage ,
mk_BusSyncMessageCallback ,
noBusSyncMessageCallback ,
onBusSyncMessage ,
wrap_BusSyncMessageCallback ,
) 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.GI.Base.Signals as B.Signals
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.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Structs.Message as Gst.Message
newtype Bus = Bus (ManagedPtr Bus)
deriving (Bus -> Bus -> Bool
(Bus -> Bus -> Bool) -> (Bus -> Bus -> Bool) -> Eq Bus
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Bus -> Bus -> Bool
$c/= :: Bus -> Bus -> Bool
== :: Bus -> Bus -> Bool
$c== :: Bus -> Bus -> Bool
Eq)
foreign import ccall "gst_bus_get_type"
c_gst_bus_get_type :: IO GType
instance GObject Bus where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_bus_get_type
instance B.GValue.IsGValue Bus where
toGValue :: Bus -> IO GValue
toGValue o :: Bus
o = do
GType
gtype <- IO GType
c_gst_bus_get_type
Bus -> (Ptr Bus -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Bus
o (GType -> (GValue -> Ptr Bus -> IO ()) -> Ptr Bus -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Bus -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Bus
fromGValue gv :: GValue
gv = do
Ptr Bus
ptr <- GValue -> IO (Ptr Bus)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Bus)
(ManagedPtr Bus -> Bus) -> Ptr Bus -> IO Bus
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Bus -> Bus
Bus Ptr Bus
ptr
class (GObject o, O.IsDescendantOf Bus o) => IsBus o
instance (GObject o, O.IsDescendantOf Bus o) => IsBus o
instance O.HasParentTypes Bus
type instance O.ParentTypes Bus = '[Gst.Object.Object, GObject.Object.Object]
toBus :: (MonadIO m, IsBus o) => o -> m Bus
toBus :: o -> m Bus
toBus = IO Bus -> m Bus
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bus -> m Bus) -> (o -> IO Bus) -> o -> m Bus
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Bus -> Bus) -> o -> IO Bus
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Bus -> Bus
Bus
noBus :: Maybe Bus
noBus :: Maybe Bus
noBus = Maybe Bus
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveBusMethod (t :: Symbol) (o :: *) :: * where
ResolveBusMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveBusMethod "addSignalWatch" o = BusAddSignalWatchMethodInfo
ResolveBusMethod "addSignalWatchFull" o = BusAddSignalWatchFullMethodInfo
ResolveBusMethod "addWatch" o = BusAddWatchMethodInfo
ResolveBusMethod "asyncSignalFunc" o = BusAsyncSignalFuncMethodInfo
ResolveBusMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveBusMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveBusMethod "createWatch" o = BusCreateWatchMethodInfo
ResolveBusMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveBusMethod "disableSyncMessageEmission" o = BusDisableSyncMessageEmissionMethodInfo
ResolveBusMethod "enableSyncMessageEmission" o = BusEnableSyncMessageEmissionMethodInfo
ResolveBusMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveBusMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveBusMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveBusMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveBusMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveBusMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveBusMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveBusMethod "havePending" o = BusHavePendingMethodInfo
ResolveBusMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveBusMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveBusMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveBusMethod "peek" o = BusPeekMethodInfo
ResolveBusMethod "poll" o = BusPollMethodInfo
ResolveBusMethod "pop" o = BusPopMethodInfo
ResolveBusMethod "popFiltered" o = BusPopFilteredMethodInfo
ResolveBusMethod "post" o = BusPostMethodInfo
ResolveBusMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveBusMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveBusMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveBusMethod "removeSignalWatch" o = BusRemoveSignalWatchMethodInfo
ResolveBusMethod "removeWatch" o = BusRemoveWatchMethodInfo
ResolveBusMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveBusMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveBusMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveBusMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveBusMethod "syncSignalHandler" o = BusSyncSignalHandlerMethodInfo
ResolveBusMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveBusMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveBusMethod "timedPop" o = BusTimedPopMethodInfo
ResolveBusMethod "timedPopFiltered" o = BusTimedPopFilteredMethodInfo
ResolveBusMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveBusMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveBusMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveBusMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveBusMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveBusMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveBusMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveBusMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveBusMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveBusMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveBusMethod "getPollfd" o = BusGetPollfdMethodInfo
ResolveBusMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveBusMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveBusMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveBusMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveBusMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveBusMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveBusMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveBusMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveBusMethod "setFlushing" o = BusSetFlushingMethodInfo
ResolveBusMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveBusMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveBusMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveBusMethod "setSyncHandler" o = BusSetSyncHandlerMethodInfo
ResolveBusMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBusMethod t Bus, O.MethodInfo info Bus p) => OL.IsLabel t (Bus -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type BusMessageCallback =
Gst.Message.Message
-> IO ()
noBusMessageCallback :: Maybe BusMessageCallback
noBusMessageCallback :: Maybe BusMessageCallback
noBusMessageCallback = Maybe BusMessageCallback
forall a. Maybe a
Nothing
type C_BusMessageCallback =
Ptr () ->
Ptr Gst.Message.Message ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_BusMessageCallback :: C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)
genClosure_BusMessage :: MonadIO m => BusMessageCallback -> m (GClosure C_BusMessageCallback)
genClosure_BusMessage :: BusMessageCallback -> m (GClosure C_BusMessageCallback)
genClosure_BusMessage cb :: BusMessageCallback
cb = IO (GClosure C_BusMessageCallback)
-> m (GClosure C_BusMessageCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BusMessageCallback)
-> m (GClosure C_BusMessageCallback))
-> IO (GClosure C_BusMessageCallback)
-> m (GClosure C_BusMessageCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_BusMessageCallback
cb' = BusMessageCallback -> C_BusMessageCallback
wrap_BusMessageCallback BusMessageCallback
cb
C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)
mk_BusMessageCallback C_BusMessageCallback
cb' IO (FunPtr C_BusMessageCallback)
-> (FunPtr C_BusMessageCallback
-> IO (GClosure C_BusMessageCallback))
-> IO (GClosure C_BusMessageCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BusMessageCallback -> IO (GClosure C_BusMessageCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_BusMessageCallback ::
BusMessageCallback ->
C_BusMessageCallback
wrap_BusMessageCallback :: BusMessageCallback -> C_BusMessageCallback
wrap_BusMessageCallback _cb :: BusMessageCallback
_cb _ message :: Ptr Message
message _ = do
(ManagedPtr Message -> Message)
-> Ptr Message -> BusMessageCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Message -> Message
Gst.Message.Message Ptr Message
message (BusMessageCallback -> IO ()) -> BusMessageCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \message' :: Message
message' -> do
BusMessageCallback
_cb Message
message'
onBusMessage :: (IsBus a, MonadIO m) => a -> P.Maybe T.Text -> BusMessageCallback -> m SignalHandlerId
onBusMessage :: a -> Maybe Text -> BusMessageCallback -> m SignalHandlerId
onBusMessage obj :: a
obj detail :: Maybe Text
detail cb :: BusMessageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_BusMessageCallback
cb' = BusMessageCallback -> C_BusMessageCallback
wrap_BusMessageCallback BusMessageCallback
cb
FunPtr C_BusMessageCallback
cb'' <- C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)
mk_BusMessageCallback C_BusMessageCallback
cb'
a
-> Text
-> FunPtr C_BusMessageCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "message" FunPtr C_BusMessageCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
detail
afterBusMessage :: (IsBus a, MonadIO m) => a -> P.Maybe T.Text -> BusMessageCallback -> m SignalHandlerId
afterBusMessage :: a -> Maybe Text -> BusMessageCallback -> m SignalHandlerId
afterBusMessage obj :: a
obj detail :: Maybe Text
detail cb :: BusMessageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_BusMessageCallback
cb' = BusMessageCallback -> C_BusMessageCallback
wrap_BusMessageCallback BusMessageCallback
cb
FunPtr C_BusMessageCallback
cb'' <- C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)
mk_BusMessageCallback C_BusMessageCallback
cb'
a
-> Text
-> FunPtr C_BusMessageCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "message" FunPtr C_BusMessageCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
detail
#if defined(ENABLE_OVERLOADING)
data BusMessageSignalInfo
instance SignalInfo BusMessageSignalInfo where
type HaskellCallbackType BusMessageSignalInfo = BusMessageCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_BusMessageCallback cb
cb'' <- mk_BusMessageCallback cb'
connectSignalFunPtr obj "message" cb'' connectMode detail
#endif
type BusSyncMessageCallback =
Gst.Message.Message
-> IO ()
noBusSyncMessageCallback :: Maybe BusSyncMessageCallback
noBusSyncMessageCallback :: Maybe BusMessageCallback
noBusSyncMessageCallback = Maybe BusMessageCallback
forall a. Maybe a
Nothing
type C_BusSyncMessageCallback =
Ptr () ->
Ptr Gst.Message.Message ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_BusSyncMessageCallback :: C_BusSyncMessageCallback -> IO (FunPtr C_BusSyncMessageCallback)
genClosure_BusSyncMessage :: MonadIO m => BusSyncMessageCallback -> m (GClosure C_BusSyncMessageCallback)
genClosure_BusSyncMessage :: BusMessageCallback -> m (GClosure C_BusMessageCallback)
genClosure_BusSyncMessage cb :: BusMessageCallback
cb = IO (GClosure C_BusMessageCallback)
-> m (GClosure C_BusMessageCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_BusMessageCallback)
-> m (GClosure C_BusMessageCallback))
-> IO (GClosure C_BusMessageCallback)
-> m (GClosure C_BusMessageCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_BusMessageCallback
cb' = BusMessageCallback -> C_BusMessageCallback
wrap_BusSyncMessageCallback BusMessageCallback
cb
C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)
mk_BusSyncMessageCallback C_BusMessageCallback
cb' IO (FunPtr C_BusMessageCallback)
-> (FunPtr C_BusMessageCallback
-> IO (GClosure C_BusMessageCallback))
-> IO (GClosure C_BusMessageCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_BusMessageCallback -> IO (GClosure C_BusMessageCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_BusSyncMessageCallback ::
BusSyncMessageCallback ->
C_BusSyncMessageCallback
wrap_BusSyncMessageCallback :: BusMessageCallback -> C_BusMessageCallback
wrap_BusSyncMessageCallback _cb :: BusMessageCallback
_cb _ message :: Ptr Message
message _ = do
(ManagedPtr Message -> Message)
-> Ptr Message -> BusMessageCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
(ManagedPtr a -> a) -> Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient ManagedPtr Message -> Message
Gst.Message.Message Ptr Message
message (BusMessageCallback -> IO ()) -> BusMessageCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \message' :: Message
message' -> do
BusMessageCallback
_cb Message
message'
onBusSyncMessage :: (IsBus a, MonadIO m) => a -> P.Maybe T.Text -> BusSyncMessageCallback -> m SignalHandlerId
onBusSyncMessage :: a -> Maybe Text -> BusMessageCallback -> m SignalHandlerId
onBusSyncMessage obj :: a
obj detail :: Maybe Text
detail cb :: BusMessageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_BusMessageCallback
cb' = BusMessageCallback -> C_BusMessageCallback
wrap_BusSyncMessageCallback BusMessageCallback
cb
FunPtr C_BusMessageCallback
cb'' <- C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)
mk_BusSyncMessageCallback C_BusMessageCallback
cb'
a
-> Text
-> FunPtr C_BusMessageCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "sync-message" FunPtr C_BusMessageCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
detail
afterBusSyncMessage :: (IsBus a, MonadIO m) => a -> P.Maybe T.Text -> BusSyncMessageCallback -> m SignalHandlerId
afterBusSyncMessage :: a -> Maybe Text -> BusMessageCallback -> m SignalHandlerId
afterBusSyncMessage obj :: a
obj detail :: Maybe Text
detail cb :: BusMessageCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_BusMessageCallback
cb' = BusMessageCallback -> C_BusMessageCallback
wrap_BusSyncMessageCallback BusMessageCallback
cb
FunPtr C_BusMessageCallback
cb'' <- C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)
mk_BusSyncMessageCallback C_BusMessageCallback
cb'
a
-> Text
-> FunPtr C_BusMessageCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "sync-message" FunPtr C_BusMessageCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
detail
#if defined(ENABLE_OVERLOADING)
data BusSyncMessageSignalInfo
instance SignalInfo BusSyncMessageSignalInfo where
type HaskellCallbackType BusSyncMessageSignalInfo = BusSyncMessageCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_BusSyncMessageCallback cb
cb'' <- mk_BusSyncMessageCallback cb'
connectSignalFunPtr obj "sync-message" cb'' connectMode detail
#endif
constructBusEnableAsync :: (IsBus o) => Bool -> IO (GValueConstruct o)
constructBusEnableAsync :: Bool -> IO (GValueConstruct o)
constructBusEnableAsync val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool "enable-async" Bool
val
#if defined(ENABLE_OVERLOADING)
data BusEnableAsyncPropertyInfo
instance AttrInfo BusEnableAsyncPropertyInfo where
type AttrAllowedOps BusEnableAsyncPropertyInfo = '[ 'AttrConstruct]
type AttrBaseTypeConstraint BusEnableAsyncPropertyInfo = IsBus
type AttrSetTypeConstraint BusEnableAsyncPropertyInfo = (~) Bool
type AttrTransferTypeConstraint BusEnableAsyncPropertyInfo = (~) Bool
type AttrTransferType BusEnableAsyncPropertyInfo = Bool
type AttrGetType BusEnableAsyncPropertyInfo = ()
type AttrLabel BusEnableAsyncPropertyInfo = "enable-async"
type AttrOrigin BusEnableAsyncPropertyInfo = Bus
attrGet = undefined
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructBusEnableAsync
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Bus
type instance O.AttributeList Bus = BusAttributeList
type BusAttributeList = ('[ '("enableAsync", BusEnableAsyncPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
busEnableAsync :: AttrLabelProxy "enableAsync"
busEnableAsync = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Bus = BusSignalList
type BusSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("message", BusMessageSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("syncMessage", BusSyncMessageSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_bus_new" gst_bus_new ::
IO (Ptr Bus)
busNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Bus
busNew :: m Bus
busNew = IO Bus -> m Bus
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bus -> m Bus) -> IO Bus -> m Bus
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
result <- IO (Ptr Bus)
gst_bus_new
Text -> Ptr Bus -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "busNew" Ptr Bus
result
Bus
result' <- ((ManagedPtr Bus -> Bus) -> Ptr Bus -> IO Bus
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Bus -> Bus
Bus) Ptr Bus
result
Bus -> IO Bus
forall (m :: * -> *) a. Monad m => a -> m a
return Bus
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_bus_add_signal_watch" gst_bus_add_signal_watch ::
Ptr Bus ->
IO ()
busAddSignalWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m ()
busAddSignalWatch :: a -> m ()
busAddSignalWatch bus :: a
bus = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Bus -> IO ()
gst_bus_add_signal_watch Ptr Bus
bus'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BusAddSignalWatchMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusAddSignalWatchMethodInfo a signature where
overloadedMethod = busAddSignalWatch
#endif
foreign import ccall "gst_bus_add_signal_watch_full" gst_bus_add_signal_watch_full ::
Ptr Bus ->
Int32 ->
IO ()
busAddSignalWatchFull ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Int32
-> m ()
busAddSignalWatchFull :: a -> Int32 -> m ()
busAddSignalWatchFull bus :: a
bus priority :: Int32
priority = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Bus -> Int32 -> IO ()
gst_bus_add_signal_watch_full Ptr Bus
bus' Int32
priority
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BusAddSignalWatchFullMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsBus a) => O.MethodInfo BusAddSignalWatchFullMethodInfo a signature where
overloadedMethod = busAddSignalWatchFull
#endif
foreign import ccall "gst_bus_add_watch_full" gst_bus_add_watch_full ::
Ptr Bus ->
Int32 ->
FunPtr Gst.Callbacks.C_BusFunc ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO Word32
busAddWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Int32
-> Gst.Callbacks.BusFunc
-> m Word32
busAddWatch :: a -> Int32 -> BusFunc -> m Word32
busAddWatch bus :: a
bus priority :: Int32
priority func :: BusFunc
func = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
FunPtr C_BusFunc
func' <- C_BusFunc -> IO (FunPtr C_BusFunc)
Gst.Callbacks.mk_BusFunc (Maybe (Ptr (FunPtr C_BusFunc)) -> BusFunc_WithClosures -> C_BusFunc
Gst.Callbacks.wrap_BusFunc Maybe (Ptr (FunPtr C_BusFunc))
forall a. Maybe a
Nothing (BusFunc -> BusFunc_WithClosures
Gst.Callbacks.drop_closures_BusFunc BusFunc
func))
let userData :: Ptr ()
userData = FunPtr C_BusFunc -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BusFunc
func'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Word32
result <- Ptr Bus
-> Int32
-> FunPtr C_BusFunc
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO Word32
gst_bus_add_watch_full Ptr Bus
bus' Int32
priority FunPtr C_BusFunc
func' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data BusAddWatchMethodInfo
instance (signature ~ (Int32 -> Gst.Callbacks.BusFunc -> m Word32), MonadIO m, IsBus a) => O.MethodInfo BusAddWatchMethodInfo a signature where
overloadedMethod = busAddWatch
#endif
foreign import ccall "gst_bus_async_signal_func" gst_bus_async_signal_func ::
Ptr Bus ->
Ptr Gst.Message.Message ->
Ptr () ->
IO CInt
busAsyncSignalFunc ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Gst.Message.Message
-> Ptr ()
-> m Bool
busAsyncSignalFunc :: a -> Message -> Ptr () -> m Bool
busAsyncSignalFunc bus :: a
bus message :: Message
message data_ :: Ptr ()
data_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
CInt
result <- C_BusFunc
gst_bus_async_signal_func Ptr Bus
bus' Ptr Message
message' Ptr ()
data_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
BusMessageCallback
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BusAsyncSignalFuncMethodInfo
instance (signature ~ (Gst.Message.Message -> Ptr () -> m Bool), MonadIO m, IsBus a) => O.MethodInfo BusAsyncSignalFuncMethodInfo a signature where
overloadedMethod = busAsyncSignalFunc
#endif
foreign import ccall "gst_bus_create_watch" gst_bus_create_watch ::
Ptr Bus ->
IO (Ptr GLib.Source.Source)
busCreateWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m (Maybe GLib.Source.Source)
busCreateWatch :: a -> m (Maybe Source)
busCreateWatch bus :: a
bus = IO (Maybe Source) -> m (Maybe Source)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Source) -> m (Maybe Source))
-> IO (Maybe Source) -> m (Maybe Source)
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Source
result <- Ptr Bus -> IO (Ptr Source)
gst_bus_create_watch Ptr Bus
bus'
Maybe Source
maybeResult <- Ptr Source -> (Ptr Source -> IO Source) -> IO (Maybe Source)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Source
result ((Ptr Source -> IO Source) -> IO (Maybe Source))
-> (Ptr Source -> IO Source) -> IO (Maybe Source)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Source
result' -> do
Source
result'' <- ((ManagedPtr Source -> Source) -> Ptr Source -> IO Source
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Source -> Source
GLib.Source.Source) Ptr Source
result'
Source -> IO Source
forall (m :: * -> *) a. Monad m => a -> m a
return Source
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Maybe Source -> IO (Maybe Source)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Source
maybeResult
#if defined(ENABLE_OVERLOADING)
data BusCreateWatchMethodInfo
instance (signature ~ (m (Maybe GLib.Source.Source)), MonadIO m, IsBus a) => O.MethodInfo BusCreateWatchMethodInfo a signature where
overloadedMethod = busCreateWatch
#endif
foreign import ccall "gst_bus_disable_sync_message_emission" gst_bus_disable_sync_message_emission ::
Ptr Bus ->
IO ()
busDisableSyncMessageEmission ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m ()
busDisableSyncMessageEmission :: a -> m ()
busDisableSyncMessageEmission bus :: a
bus = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Bus -> IO ()
gst_bus_disable_sync_message_emission Ptr Bus
bus'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BusDisableSyncMessageEmissionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusDisableSyncMessageEmissionMethodInfo a signature where
overloadedMethod = busDisableSyncMessageEmission
#endif
foreign import ccall "gst_bus_enable_sync_message_emission" gst_bus_enable_sync_message_emission ::
Ptr Bus ->
IO ()
busEnableSyncMessageEmission ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m ()
busEnableSyncMessageEmission :: a -> m ()
busEnableSyncMessageEmission bus :: a
bus = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Bus -> IO ()
gst_bus_enable_sync_message_emission Ptr Bus
bus'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BusEnableSyncMessageEmissionMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusEnableSyncMessageEmissionMethodInfo a signature where
overloadedMethod = busEnableSyncMessageEmission
#endif
foreign import ccall "gst_bus_get_pollfd" gst_bus_get_pollfd ::
Ptr Bus ->
Ptr GLib.PollFD.PollFD ->
IO ()
busGetPollfd ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m (GLib.PollFD.PollFD)
busGetPollfd :: a -> m PollFD
busGetPollfd bus :: a
bus = IO PollFD -> m PollFD
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PollFD -> m PollFD) -> IO PollFD -> m PollFD
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr PollFD
fd <- Int -> IO (Ptr PollFD)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 8 :: IO (Ptr GLib.PollFD.PollFD)
Ptr Bus -> Ptr PollFD -> IO ()
gst_bus_get_pollfd Ptr Bus
bus' Ptr PollFD
fd
PollFD
fd' <- ((ManagedPtr PollFD -> PollFD) -> Ptr PollFD -> IO PollFD
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr PollFD -> PollFD
GLib.PollFD.PollFD) Ptr PollFD
fd
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
PollFD -> IO PollFD
forall (m :: * -> *) a. Monad m => a -> m a
return PollFD
fd'
#if defined(ENABLE_OVERLOADING)
data BusGetPollfdMethodInfo
instance (signature ~ (m (GLib.PollFD.PollFD)), MonadIO m, IsBus a) => O.MethodInfo BusGetPollfdMethodInfo a signature where
overloadedMethod = busGetPollfd
#endif
foreign import ccall "gst_bus_have_pending" gst_bus_have_pending ::
Ptr Bus ->
IO CInt
busHavePending ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m Bool
busHavePending :: a -> m Bool
busHavePending bus :: a
bus = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
CInt
result <- Ptr Bus -> IO CInt
gst_bus_have_pending Ptr Bus
bus'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BusHavePendingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBus a) => O.MethodInfo BusHavePendingMethodInfo a signature where
overloadedMethod = busHavePending
#endif
foreign import ccall "gst_bus_peek" gst_bus_peek ::
Ptr Bus ->
IO (Ptr Gst.Message.Message)
busPeek ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m (Maybe Gst.Message.Message)
busPeek :: a -> m (Maybe Message)
busPeek bus :: a
bus = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Message
result <- Ptr Bus -> IO (Ptr Message)
gst_bus_peek Ptr Bus
bus'
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
data BusPeekMethodInfo
instance (signature ~ (m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusPeekMethodInfo a signature where
overloadedMethod = busPeek
#endif
foreign import ccall "gst_bus_poll" gst_bus_poll ::
Ptr Bus ->
CUInt ->
Word64 ->
IO (Ptr Gst.Message.Message)
busPoll ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> [Gst.Flags.MessageType]
-> Word64
-> m (Maybe Gst.Message.Message)
busPoll :: a -> [MessageType] -> Word64 -> m (Maybe Message)
busPoll bus :: a
bus events :: [MessageType]
events timeout :: Word64
timeout = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
let events' :: CUInt
events' = [MessageType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageType]
events
Ptr Message
result <- Ptr Bus -> CUInt -> Word64 -> IO (Ptr Message)
gst_bus_poll Ptr Bus
bus' CUInt
events' Word64
timeout
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
data BusPollMethodInfo
instance (signature ~ ([Gst.Flags.MessageType] -> Word64 -> m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusPollMethodInfo a signature where
overloadedMethod = busPoll
#endif
foreign import ccall "gst_bus_pop" gst_bus_pop ::
Ptr Bus ->
IO (Ptr Gst.Message.Message)
busPop ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m (Maybe Gst.Message.Message)
busPop :: a -> m (Maybe Message)
busPop bus :: a
bus = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Message
result <- Ptr Bus -> IO (Ptr Message)
gst_bus_pop Ptr Bus
bus'
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
data BusPopMethodInfo
instance (signature ~ (m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusPopMethodInfo a signature where
overloadedMethod = busPop
#endif
foreign import ccall "gst_bus_pop_filtered" gst_bus_pop_filtered ::
Ptr Bus ->
CUInt ->
IO (Ptr Gst.Message.Message)
busPopFiltered ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> [Gst.Flags.MessageType]
-> m (Maybe Gst.Message.Message)
busPopFiltered :: a -> [MessageType] -> m (Maybe Message)
busPopFiltered bus :: a
bus types :: [MessageType]
types = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
let types' :: CUInt
types' = [MessageType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageType]
types
Ptr Message
result <- Ptr Bus -> CUInt -> IO (Ptr Message)
gst_bus_pop_filtered Ptr Bus
bus' CUInt
types'
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
data BusPopFilteredMethodInfo
instance (signature ~ ([Gst.Flags.MessageType] -> m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusPopFilteredMethodInfo a signature where
overloadedMethod = busPopFiltered
#endif
foreign import ccall "gst_bus_post" gst_bus_post ::
Ptr Bus ->
Ptr Gst.Message.Message ->
IO CInt
busPost ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Gst.Message.Message
-> m Bool
busPost :: a -> Message -> m Bool
busPost bus :: a
bus message :: Message
message = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, BoxedObject a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Message
message
CInt
result <- Ptr Bus -> Ptr Message -> IO CInt
gst_bus_post Ptr Bus
bus' Ptr Message
message'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
BusMessageCallback
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BusPostMethodInfo
instance (signature ~ (Gst.Message.Message -> m Bool), MonadIO m, IsBus a) => O.MethodInfo BusPostMethodInfo a signature where
overloadedMethod = busPost
#endif
foreign import ccall "gst_bus_remove_signal_watch" gst_bus_remove_signal_watch ::
Ptr Bus ->
IO ()
busRemoveSignalWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m ()
busRemoveSignalWatch :: a -> m ()
busRemoveSignalWatch bus :: a
bus = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Bus -> IO ()
gst_bus_remove_signal_watch Ptr Bus
bus'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BusRemoveSignalWatchMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusRemoveSignalWatchMethodInfo a signature where
overloadedMethod = busRemoveSignalWatch
#endif
foreign import ccall "gst_bus_remove_watch" gst_bus_remove_watch ::
Ptr Bus ->
IO CInt
busRemoveWatch ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> m Bool
busRemoveWatch :: a -> m Bool
busRemoveWatch bus :: a
bus = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
CInt
result <- Ptr Bus -> IO CInt
gst_bus_remove_watch Ptr Bus
bus'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BusRemoveWatchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsBus a) => O.MethodInfo BusRemoveWatchMethodInfo a signature where
overloadedMethod = busRemoveWatch
#endif
foreign import ccall "gst_bus_set_flushing" gst_bus_set_flushing ::
Ptr Bus ->
CInt ->
IO ()
busSetFlushing ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Bool
-> m ()
busSetFlushing :: a -> Bool -> m ()
busSetFlushing bus :: a
bus flushing :: Bool
flushing = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
let flushing' :: CInt
flushing' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
flushing
Ptr Bus -> CInt -> IO ()
gst_bus_set_flushing Ptr Bus
bus' CInt
flushing'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BusSetFlushingMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsBus a) => O.MethodInfo BusSetFlushingMethodInfo a signature where
overloadedMethod = busSetFlushing
#endif
foreign import ccall "gst_bus_set_sync_handler" gst_bus_set_sync_handler ::
Ptr Bus ->
FunPtr Gst.Callbacks.C_BusSyncHandler ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
busSetSyncHandler ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Maybe (Gst.Callbacks.BusSyncHandler)
-> m ()
busSetSyncHandler :: a -> Maybe BusSyncHandler -> m ()
busSetSyncHandler bus :: a
bus func :: Maybe BusSyncHandler
func = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
FunPtr C_BusSyncHandler
maybeFunc <- case Maybe BusSyncHandler
func of
Nothing -> FunPtr C_BusSyncHandler -> IO (FunPtr C_BusSyncHandler)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_BusSyncHandler
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
Just jFunc :: BusSyncHandler
jFunc -> do
FunPtr C_BusSyncHandler
jFunc' <- C_BusSyncHandler -> IO (FunPtr C_BusSyncHandler)
Gst.Callbacks.mk_BusSyncHandler (Maybe (Ptr (FunPtr C_BusSyncHandler))
-> BusSyncHandler_WithClosures -> C_BusSyncHandler
Gst.Callbacks.wrap_BusSyncHandler Maybe (Ptr (FunPtr C_BusSyncHandler))
forall a. Maybe a
Nothing (BusSyncHandler -> BusSyncHandler_WithClosures
Gst.Callbacks.drop_closures_BusSyncHandler BusSyncHandler
jFunc))
FunPtr C_BusSyncHandler -> IO (FunPtr C_BusSyncHandler)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_BusSyncHandler
jFunc'
let userData :: Ptr ()
userData = FunPtr C_BusSyncHandler -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_BusSyncHandler
maybeFunc
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
safeFreeFunPtrPtr
Ptr Bus
-> FunPtr C_BusSyncHandler
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_bus_set_sync_handler Ptr Bus
bus' FunPtr C_BusSyncHandler
maybeFunc Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data BusSetSyncHandlerMethodInfo
instance (signature ~ (Maybe (Gst.Callbacks.BusSyncHandler) -> m ()), MonadIO m, IsBus a) => O.MethodInfo BusSetSyncHandlerMethodInfo a signature where
overloadedMethod = busSetSyncHandler
#endif
foreign import ccall "gst_bus_sync_signal_handler" gst_bus_sync_signal_handler ::
Ptr Bus ->
Ptr Gst.Message.Message ->
Ptr () ->
IO CUInt
busSyncSignalHandler ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Gst.Message.Message
-> Ptr ()
-> m Gst.Enums.BusSyncReply
busSyncSignalHandler :: a -> Message -> Ptr () -> m BusSyncReply
busSyncSignalHandler bus :: a
bus message :: Message
message data_ :: Ptr ()
data_ = IO BusSyncReply -> m BusSyncReply
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BusSyncReply -> m BusSyncReply)
-> IO BusSyncReply -> m BusSyncReply
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Message
message' <- Message -> IO (Ptr Message)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Message
message
CUInt
result <- C_BusSyncHandler
gst_bus_sync_signal_handler Ptr Bus
bus' Ptr Message
message' Ptr ()
data_
let result' :: BusSyncReply
result' = (Int -> BusSyncReply
forall a. Enum a => Int -> a
toEnum (Int -> BusSyncReply) -> (CUInt -> Int) -> CUInt -> BusSyncReply
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
BusMessageCallback
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Message
message
BusSyncReply -> IO BusSyncReply
forall (m :: * -> *) a. Monad m => a -> m a
return BusSyncReply
result'
#if defined(ENABLE_OVERLOADING)
data BusSyncSignalHandlerMethodInfo
instance (signature ~ (Gst.Message.Message -> Ptr () -> m Gst.Enums.BusSyncReply), MonadIO m, IsBus a) => O.MethodInfo BusSyncSignalHandlerMethodInfo a signature where
overloadedMethod = busSyncSignalHandler
#endif
foreign import ccall "gst_bus_timed_pop" gst_bus_timed_pop ::
Ptr Bus ->
Word64 ->
IO (Ptr Gst.Message.Message)
busTimedPop ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Word64
-> m (Maybe Gst.Message.Message)
busTimedPop :: a -> Word64 -> m (Maybe Message)
busTimedPop bus :: a
bus timeout :: Word64
timeout = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
Ptr Message
result <- Ptr Bus -> Word64 -> IO (Ptr Message)
gst_bus_timed_pop Ptr Bus
bus' Word64
timeout
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
data BusTimedPopMethodInfo
instance (signature ~ (Word64 -> m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusTimedPopMethodInfo a signature where
overloadedMethod = busTimedPop
#endif
foreign import ccall "gst_bus_timed_pop_filtered" gst_bus_timed_pop_filtered ::
Ptr Bus ->
Word64 ->
CUInt ->
IO (Ptr Gst.Message.Message)
busTimedPopFiltered ::
(B.CallStack.HasCallStack, MonadIO m, IsBus a) =>
a
-> Word64
-> [Gst.Flags.MessageType]
-> m (Maybe Gst.Message.Message)
busTimedPopFiltered :: a -> Word64 -> [MessageType] -> m (Maybe Message)
busTimedPopFiltered bus :: a
bus timeout :: Word64
timeout types :: [MessageType]
types = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ do
Ptr Bus
bus' <- a -> IO (Ptr Bus)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
bus
let types' :: CUInt
types' = [MessageType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [MessageType]
types
Ptr Message
result <- Ptr Bus -> Word64 -> CUInt -> IO (Ptr Message)
gst_bus_timed_pop_filtered Ptr Bus
bus' Word64
timeout CUInt
types'
Maybe Message
maybeResult <- Ptr Message -> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Message
result ((Ptr Message -> IO Message) -> IO (Maybe Message))
-> (Ptr Message -> IO Message) -> IO (Maybe Message)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Message
result' -> do
Message
result'' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Message -> Message
Gst.Message.Message) Ptr Message
result'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
bus
Maybe Message -> IO (Maybe Message)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Message
maybeResult
#if defined(ENABLE_OVERLOADING)
data BusTimedPopFilteredMethodInfo
instance (signature ~ (Word64 -> [Gst.Flags.MessageType] -> m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusTimedPopFilteredMethodInfo a signature where
overloadedMethod = busTimedPopFiltered
#endif