{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) The 'GI.Gst.Objects.Bus.Bus' is an object responsible for delivering 'GI.Gst.Structs.Message.Message' packets in a first-in first-out way from the streaming threads (see 'GI.Gst.Objects.Task.Task') to the application. Since the application typically only wants to deal with delivery of these messages from one thread, the GstBus will marshall the messages between different threads. This is important since the actual streaming of media is done in another thread than the application. The GstBus provides support for 'GI.GLib.Structs.Source.Source' based notifications. This makes it possible to handle the delivery in the glib mainloop. The 'GI.GLib.Structs.Source.Source' callback function 'GI.Gst.Objects.Bus.busAsyncSignalFunc' can be used to convert all bus messages into signal emissions. A message is posted on the bus with the 'GI.Gst.Objects.Bus.busPost' method. With the 'GI.Gst.Objects.Bus.busPeek' and 'GI.Gst.Objects.Bus.busPop' methods one can look at or retrieve a previously posted message. The bus can be polled with the 'GI.Gst.Objects.Bus.busPoll' method. This methods blocks up to the specified timeout value until one of the specified messages types is posted on the bus. The application can then 'GI.Gst.Objects.Bus.busPop' the messages from the bus to handle them. Alternatively the application can register an asynchronous bus function using 'GI.Gst.Objects.Bus.busAddWatch' or @/gst_bus_add_watch()/@. This function will install a 'GI.GLib.Structs.Source.Source' in the default glib main loop and will deliver messages a short while after they have been posted. Note that the main loop should be running for the asynchronous callbacks. It is also possible to get messages from the bus without any thread marshalling with the 'GI.Gst.Objects.Bus.busSetSyncHandler' method. This makes it possible to react to a message in the same thread that posted the message on the bus. This should only be used if the application is able to deal with messages from different threads. Every 'GI.Gst.Objects.Pipeline.Pipeline' has one bus. Note that a 'GI.Gst.Objects.Pipeline.Pipeline' will set its bus into flushing state when changing from READY to NULL state. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gst.Objects.Bus ( -- * Exported types Bus(..) , IsBus , toBus , noBus , -- * Methods -- ** addSignalWatch #method:addSignalWatch# #if ENABLE_OVERLOADING BusAddSignalWatchMethodInfo , #endif busAddSignalWatch , -- ** addSignalWatchFull #method:addSignalWatchFull# #if ENABLE_OVERLOADING BusAddSignalWatchFullMethodInfo , #endif busAddSignalWatchFull , -- ** addWatch #method:addWatch# #if ENABLE_OVERLOADING BusAddWatchMethodInfo , #endif busAddWatch , -- ** asyncSignalFunc #method:asyncSignalFunc# #if ENABLE_OVERLOADING BusAsyncSignalFuncMethodInfo , #endif busAsyncSignalFunc , -- ** createWatch #method:createWatch# #if ENABLE_OVERLOADING BusCreateWatchMethodInfo , #endif busCreateWatch , -- ** disableSyncMessageEmission #method:disableSyncMessageEmission# #if ENABLE_OVERLOADING BusDisableSyncMessageEmissionMethodInfo , #endif busDisableSyncMessageEmission , -- ** enableSyncMessageEmission #method:enableSyncMessageEmission# #if ENABLE_OVERLOADING BusEnableSyncMessageEmissionMethodInfo , #endif busEnableSyncMessageEmission , -- ** getPollfd #method:getPollfd# #if ENABLE_OVERLOADING BusGetPollfdMethodInfo , #endif busGetPollfd , -- ** havePending #method:havePending# #if ENABLE_OVERLOADING BusHavePendingMethodInfo , #endif busHavePending , -- ** new #method:new# busNew , -- ** peek #method:peek# #if ENABLE_OVERLOADING BusPeekMethodInfo , #endif busPeek , -- ** poll #method:poll# #if ENABLE_OVERLOADING BusPollMethodInfo , #endif busPoll , -- ** pop #method:pop# #if ENABLE_OVERLOADING BusPopMethodInfo , #endif busPop , -- ** popFiltered #method:popFiltered# #if ENABLE_OVERLOADING BusPopFilteredMethodInfo , #endif busPopFiltered , -- ** post #method:post# #if ENABLE_OVERLOADING BusPostMethodInfo , #endif busPost , -- ** removeSignalWatch #method:removeSignalWatch# #if ENABLE_OVERLOADING BusRemoveSignalWatchMethodInfo , #endif busRemoveSignalWatch , -- ** removeWatch #method:removeWatch# #if ENABLE_OVERLOADING BusRemoveWatchMethodInfo , #endif busRemoveWatch , -- ** setFlushing #method:setFlushing# #if ENABLE_OVERLOADING BusSetFlushingMethodInfo , #endif busSetFlushing , -- ** setSyncHandler #method:setSyncHandler# #if ENABLE_OVERLOADING BusSetSyncHandlerMethodInfo , #endif busSetSyncHandler , -- ** syncSignalHandler #method:syncSignalHandler# #if ENABLE_OVERLOADING BusSyncSignalHandlerMethodInfo , #endif busSyncSignalHandler , -- ** timedPop #method:timedPop# #if ENABLE_OVERLOADING BusTimedPopMethodInfo , #endif busTimedPop , -- ** timedPopFiltered #method:timedPopFiltered# #if ENABLE_OVERLOADING BusTimedPopFilteredMethodInfo , #endif busTimedPopFiltered , -- * Properties -- ** enableAsync #attr:enableAsync# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING BusEnableAsyncPropertyInfo , #endif #if ENABLE_OVERLOADING busEnableAsync , #endif constructBusEnableAsync , -- * Signals -- ** message #signal:message# BusMessageCallback , #if ENABLE_OVERLOADING BusMessageSignalInfo , #endif C_BusMessageCallback , afterBusMessage , genClosure_BusMessage , mk_BusMessageCallback , noBusMessageCallback , onBusMessage , wrap_BusMessageCallback , -- ** syncMessage #signal:syncMessage# BusSyncMessageCallback , #if 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.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 -- | Memory-managed wrapper type. newtype Bus = Bus (ManagedPtr Bus) foreign import ccall "gst_bus_get_type" c_gst_bus_get_type :: IO GType instance GObject Bus where gobjectType = c_gst_bus_get_type -- | Type class for types which can be safely cast to `Bus`, for instance with `toBus`. 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] -- | Cast to `Bus`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toBus :: (MonadIO m, IsBus o) => o -> m Bus toBus = liftIO . unsafeCastTo Bus -- | A convenience alias for `Nothing` :: `Maybe` `Bus`. noBus :: Maybe Bus noBus = Nothing #if 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 (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal Bus::message {- | A message has been posted on the bus. This signal is emitted from a GSource added to the mainloop. this signal will only be emitted when there is a mainloop running. -} type BusMessageCallback = Gst.Message.Message {- ^ /@message@/: the message that has been posted asynchronously -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `BusMessageCallback`@. noBusMessageCallback :: Maybe BusMessageCallback noBusMessageCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_BusMessageCallback = Ptr () -> -- object Ptr Gst.Message.Message -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_BusMessageCallback`. foreign import ccall "wrapper" mk_BusMessageCallback :: C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback) -- | Wrap the callback into a `GClosure`. genClosure_BusMessage :: MonadIO m => BusMessageCallback -> m (GClosure C_BusMessageCallback) genClosure_BusMessage cb = liftIO $ do let cb' = wrap_BusMessageCallback cb mk_BusMessageCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `BusMessageCallback` into a `C_BusMessageCallback`. wrap_BusMessageCallback :: BusMessageCallback -> C_BusMessageCallback wrap_BusMessageCallback _cb _ message _ = do B.ManagedPtr.withTransient Gst.Message.Message message $ \message' -> do _cb message' {- | Connect a signal handler for the “@message@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' bus #message callback @ -} onBusMessage :: (IsBus a, MonadIO m) => a -> BusMessageCallback -> m SignalHandlerId onBusMessage obj cb = liftIO $ do let cb' = wrap_BusMessageCallback cb cb'' <- mk_BusMessageCallback cb' connectSignalFunPtr obj "message" cb'' SignalConnectBefore {- | Connect a signal handler for the “@message@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' bus #message callback @ -} afterBusMessage :: (IsBus a, MonadIO m) => a -> BusMessageCallback -> m SignalHandlerId afterBusMessage obj cb = liftIO $ do let cb' = wrap_BusMessageCallback cb cb'' <- mk_BusMessageCallback cb' connectSignalFunPtr obj "message" cb'' SignalConnectAfter -- signal Bus::sync-message {- | A message has been posted on the bus. This signal is emitted from the thread that posted the message so one has to be careful with locking. This signal will not be emitted by default, you have to call 'GI.Gst.Objects.Bus.busEnableSyncMessageEmission' before. -} type BusSyncMessageCallback = Gst.Message.Message {- ^ /@message@/: the message that has been posted synchronously -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `BusSyncMessageCallback`@. noBusSyncMessageCallback :: Maybe BusSyncMessageCallback noBusSyncMessageCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_BusSyncMessageCallback = Ptr () -> -- object Ptr Gst.Message.Message -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_BusSyncMessageCallback`. foreign import ccall "wrapper" mk_BusSyncMessageCallback :: C_BusSyncMessageCallback -> IO (FunPtr C_BusSyncMessageCallback) -- | Wrap the callback into a `GClosure`. genClosure_BusSyncMessage :: MonadIO m => BusSyncMessageCallback -> m (GClosure C_BusSyncMessageCallback) genClosure_BusSyncMessage cb = liftIO $ do let cb' = wrap_BusSyncMessageCallback cb mk_BusSyncMessageCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `BusSyncMessageCallback` into a `C_BusSyncMessageCallback`. wrap_BusSyncMessageCallback :: BusSyncMessageCallback -> C_BusSyncMessageCallback wrap_BusSyncMessageCallback _cb _ message _ = do B.ManagedPtr.withTransient Gst.Message.Message message $ \message' -> do _cb message' {- | Connect a signal handler for the “@sync-message@” signal, to be run before the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' bus #syncMessage callback @ -} onBusSyncMessage :: (IsBus a, MonadIO m) => a -> BusSyncMessageCallback -> m SignalHandlerId onBusSyncMessage obj cb = liftIO $ do let cb' = wrap_BusSyncMessageCallback cb cb'' <- mk_BusSyncMessageCallback cb' connectSignalFunPtr obj "sync-message" cb'' SignalConnectBefore {- | Connect a signal handler for the “@sync-message@” signal, to be run after the default handler. When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' bus #syncMessage callback @ -} afterBusSyncMessage :: (IsBus a, MonadIO m) => a -> BusSyncMessageCallback -> m SignalHandlerId afterBusSyncMessage obj cb = liftIO $ do let cb' = wrap_BusSyncMessageCallback cb cb'' <- mk_BusSyncMessageCallback cb' connectSignalFunPtr obj "sync-message" cb'' SignalConnectAfter -- VVV Prop "enable-async" -- Type: TBasicType TBoolean -- Flags: [PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Construct a `GValueConstruct` with valid value for the “@enable-async@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructBusEnableAsync :: (IsBus o) => Bool -> IO (GValueConstruct o) constructBusEnableAsync val = B.Properties.constructObjectPropertyBool "enable-async" val #if ENABLE_OVERLOADING data BusEnableAsyncPropertyInfo instance AttrInfo BusEnableAsyncPropertyInfo where type AttrAllowedOps BusEnableAsyncPropertyInfo = '[ 'AttrConstruct] type AttrSetTypeConstraint BusEnableAsyncPropertyInfo = (~) Bool type AttrBaseTypeConstraint BusEnableAsyncPropertyInfo = IsBus type AttrGetType BusEnableAsyncPropertyInfo = () type AttrLabel BusEnableAsyncPropertyInfo = "enable-async" type AttrOrigin BusEnableAsyncPropertyInfo = Bus attrGet _ = undefined attrSet _ = undefined attrConstruct _ = constructBusEnableAsync attrClear _ = undefined #endif #if 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 ENABLE_OVERLOADING busEnableAsync :: AttrLabelProxy "enableAsync" busEnableAsync = AttrLabelProxy #endif #if ENABLE_OVERLOADING data BusMessageSignalInfo instance SignalInfo BusMessageSignalInfo where type HaskellCallbackType BusMessageSignalInfo = BusMessageCallback connectSignal _ obj cb connectMode = do let cb' = wrap_BusMessageCallback cb cb'' <- mk_BusMessageCallback cb' connectSignalFunPtr obj "message" cb'' connectMode data BusSyncMessageSignalInfo instance SignalInfo BusSyncMessageSignalInfo where type HaskellCallbackType BusSyncMessageSignalInfo = BusSyncMessageCallback connectSignal _ obj cb connectMode = do let cb' = wrap_BusSyncMessageCallback cb cb'' <- mk_BusSyncMessageCallback cb' connectSignalFunPtr obj "sync-message" cb'' connectMode type instance O.SignalList Bus = BusSignalList type BusSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("message", BusMessageSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("syncMessage", BusSyncMessageSignalInfo)] :: [(Symbol, *)]) #endif -- method Bus::new -- method type : Constructor -- Args : [] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Bus"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_new" gst_bus_new :: IO (Ptr Bus) {- | Creates a new 'GI.Gst.Objects.Bus.Bus' instance. -} busNew :: (B.CallStack.HasCallStack, MonadIO m) => m Bus {- ^ __Returns:__ a new 'GI.Gst.Objects.Bus.Bus' instance -} busNew = liftIO $ do result <- gst_bus_new checkUnexpectedReturnNULL "busNew" result result' <- (wrapObject Bus) result return result' #if ENABLE_OVERLOADING #endif -- method Bus::add_signal_watch -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus on which you want to receive the \"message\" signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_add_signal_watch" gst_bus_add_signal_watch :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO () {- | Adds a bus signal watch to the default main context with the default priority ('GI.GLib.Constants.PRIORITY_DEFAULT'). It is also possible to use a non-default main context set up using 'GI.GLib.Structs.MainContext.mainContextPushThreadDefault' (before one had to create a bus watch source and attach it to the desired main context \'manually\'). After calling this statement, the bus will emit the \"message\" signal for each message posted on the bus. This function may be called multiple times. To clean up, the caller is responsible for calling 'GI.Gst.Objects.Bus.busRemoveSignalWatch' as many times as this function is called. MT safe. -} busAddSignalWatch :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' on which you want to receive the \"message\" signal -} -> m () busAddSignalWatch bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus gst_bus_add_signal_watch bus' touchManagedPtr bus return () #if ENABLE_OVERLOADING data BusAddSignalWatchMethodInfo instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusAddSignalWatchMethodInfo a signature where overloadedMethod _ = busAddSignalWatch #endif -- method Bus::add_signal_watch_full -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus on which you want to receive the \"message\" signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The priority of the watch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_add_signal_watch_full" gst_bus_add_signal_watch_full :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Int32 -> -- priority : TBasicType TInt IO () {- | Adds a bus signal watch to the default main context with the given /@priority@/ (e.g. 'GI.GLib.Constants.PRIORITY_DEFAULT'). It is also possible to use a non-default main context set up using 'GI.GLib.Structs.MainContext.mainContextPushThreadDefault' (before one had to create a bus watch source and attach it to the desired main context \'manually\'). After calling this statement, the bus will emit the \"message\" signal for each message posted on the bus when the main loop is running. This function may be called multiple times. To clean up, the caller is responsible for calling 'GI.Gst.Objects.Bus.busRemoveSignalWatch' as many times as this function is called. There can only be a single bus watch per bus, you must remove any signal watch before you can set another type of watch. MT safe. -} busAddSignalWatchFull :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' on which you want to receive the \"message\" signal -} -> Int32 {- ^ /@priority@/: The priority of the watch. -} -> m () busAddSignalWatchFull bus priority = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus gst_bus_add_signal_watch_full bus' priority touchManagedPtr bus return () #if ENABLE_OVERLOADING data BusAddSignalWatchFullMethodInfo instance (signature ~ (Int32 -> m ()), MonadIO m, IsBus a) => O.MethodInfo BusAddSignalWatchFullMethodInfo a signature where overloadedMethod _ = busAddSignalWatchFull #endif -- method Bus::add_watch -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to create the watch for.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The priority of the watch.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gst", name = "BusFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A function to call when a message is received.", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @func.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the function to call when the source is removed.", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt) -- throws : False -- Skip return : False foreign import ccall "gst_bus_add_watch_full" gst_bus_add_watch_full :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Int32 -> -- priority : TBasicType TInt FunPtr Gst.Callbacks.C_BusFunc -> -- func : TInterface (Name {namespace = "Gst", name = "BusFunc"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO Word32 {- | Adds a bus watch to the default main context with the given /@priority@/ (e.g. 'GI.GLib.Constants.PRIORITY_DEFAULT'). It is also possible to use a non-default main context set up using 'GI.GLib.Structs.MainContext.mainContextPushThreadDefault' (before one had to create a bus watch source and attach it to the desired main context \'manually\'). This function is used to receive asynchronous messages in the main loop. There can only be a single bus watch per bus, you must remove it before you can set a new one. The bus watch will only work if a GLib main loop is being run. When /@func@/ is called, the message belongs to the caller; if you want to keep a copy of it, call @/gst_message_ref()/@ before leaving /@func@/. The watch can be removed using 'GI.Gst.Objects.Bus.busRemoveWatch' or by returning 'False' from /@func@/. If the watch was added to the default main context it is also possible to remove the watch using 'GI.GLib.Functions.sourceRemove'. The bus watch will take its own reference to the /@bus@/, so it is safe to unref /@bus@/ using 'GI.Gst.Objects.Object.objectUnref' after setting the bus watch. MT safe. -} busAddWatch :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to create the watch for. -} -> Int32 {- ^ /@priority@/: The priority of the watch. -} -> Gst.Callbacks.BusFunc {- ^ /@func@/: A function to call when a message is received. -} -> m Word32 {- ^ __Returns:__ The event source id or 0 if /@bus@/ already got an event source. -} busAddWatch bus priority func = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus func' <- Gst.Callbacks.mk_BusFunc (Gst.Callbacks.wrap_BusFunc Nothing (Gst.Callbacks.drop_closures_BusFunc func)) let userData = castFunPtrToPtr func' let notify = safeFreeFunPtrPtr result <- gst_bus_add_watch_full bus' priority func' userData notify touchManagedPtr bus return result #if 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 -- method Bus::async_signal_func -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstMessage received", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bus_async_signal_func" gst_bus_async_signal_func :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Ptr Gst.Message.Message -> -- message : TInterface (Name {namespace = "Gst", name = "Message"}) Ptr () -> -- data : TBasicType TPtr IO CInt {- | A helper 'GI.Gst.Callbacks.BusFunc' that can be used to convert all asynchronous messages into signals. -} busAsyncSignalFunc :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' -} -> Gst.Message.Message {- ^ /@message@/: the 'GI.Gst.Structs.Message.Message' received -} -> Ptr () {- ^ /@data@/: user data -} -> m Bool {- ^ __Returns:__ 'True' -} busAsyncSignalFunc bus message data_ = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus message' <- unsafeManagedPtrGetPtr message result <- gst_bus_async_signal_func bus' message' data_ let result' = (/= 0) result touchManagedPtr bus touchManagedPtr message return result' #if 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 -- method Bus::create_watch -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to create the watch for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "Source"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_create_watch" gst_bus_create_watch :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO (Ptr GLib.Source.Source) {- | Create watch for this bus. The GSource will be dispatched whenever a message is on the bus. After the GSource is dispatched, the message is popped off the bus and unreffed. -} busCreateWatch :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to create the watch for -} -> m (Maybe GLib.Source.Source) {- ^ __Returns:__ a 'GI.GLib.Structs.Source.Source' that can be added to a mainloop. -} busCreateWatch bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus result <- gst_bus_create_watch bus' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed GLib.Source.Source) result' return result'' touchManagedPtr bus return maybeResult #if ENABLE_OVERLOADING data BusCreateWatchMethodInfo instance (signature ~ (m (Maybe GLib.Source.Source)), MonadIO m, IsBus a) => O.MethodInfo BusCreateWatchMethodInfo a signature where overloadedMethod _ = busCreateWatch #endif -- method Bus::disable_sync_message_emission -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus on which you previously called\ngst_bus_enable_sync_message_emission()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_disable_sync_message_emission" gst_bus_disable_sync_message_emission :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO () {- | Instructs GStreamer to stop emitting the \"sync-message\" signal for this bus. See 'GI.Gst.Objects.Bus.busEnableSyncMessageEmission' for more information. In the event that multiple pieces of code have called 'GI.Gst.Objects.Bus.busEnableSyncMessageEmission', the sync-message emissions will only be stopped after all calls to 'GI.Gst.Objects.Bus.busEnableSyncMessageEmission' were \"cancelled\" by calling this function. In this way the semantics are exactly the same as 'GI.Gst.Objects.Object.objectRef' that which calls enable should also call disable. MT safe. -} busDisableSyncMessageEmission :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' on which you previously called 'GI.Gst.Objects.Bus.busEnableSyncMessageEmission' -} -> m () busDisableSyncMessageEmission bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus gst_bus_disable_sync_message_emission bus' touchManagedPtr bus return () #if ENABLE_OVERLOADING data BusDisableSyncMessageEmissionMethodInfo instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusDisableSyncMessageEmissionMethodInfo a signature where overloadedMethod _ = busDisableSyncMessageEmission #endif -- method Bus::enable_sync_message_emission -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus on which you want to receive the \"sync-message\" signal", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_enable_sync_message_emission" gst_bus_enable_sync_message_emission :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO () {- | Instructs GStreamer to emit the \"sync-message\" signal after running the bus\'s sync handler. This function is here so that code can ensure that they can synchronously receive messages without having to affect what the bin\'s sync handler is. This function may be called multiple times. To clean up, the caller is responsible for calling 'GI.Gst.Objects.Bus.busDisableSyncMessageEmission' as many times as this function is called. While this function looks similar to 'GI.Gst.Objects.Bus.busAddSignalWatch', it is not exactly the same -- this function enables \<emphasis>synchronous\<\/emphasis> emission of signals when messages arrive; 'GI.Gst.Objects.Bus.busAddSignalWatch' adds an idle callback to pop messages off the bus \<emphasis>asynchronously\<\/emphasis>. The sync-message signal comes from the thread of whatever object posted the message; the \"message\" signal is marshalled to the main thread via the main loop. MT safe. -} busEnableSyncMessageEmission :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' on which you want to receive the \"sync-message\" signal -} -> m () busEnableSyncMessageEmission bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus gst_bus_enable_sync_message_emission bus' touchManagedPtr bus return () #if ENABLE_OVERLOADING data BusEnableSyncMessageEmissionMethodInfo instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusEnableSyncMessageEmissionMethodInfo a signature where overloadedMethod _ = busEnableSyncMessageEmission #endif -- method Bus::get_pollfd -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface (Name {namespace = "GLib", name = "PollFD"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A GPollFD to fill", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_get_pollfd" gst_bus_get_pollfd :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Ptr GLib.PollFD.PollFD -> -- fd : TInterface (Name {namespace = "GLib", name = "PollFD"}) IO () {- | Gets the file descriptor from the bus which can be used to get notified about messages being available with functions like 'GI.GLib.Functions.poll', and allows integration into other event loops based on file descriptors. Whenever a message is available, the POLLIN \/ 'GI.GLib.Flags.IOConditionIn' event is set. Warning: NEVER read or write anything to the returned fd but only use it for getting notifications via 'GI.GLib.Functions.poll' or similar and then use the normal GstBus API, e.g. 'GI.Gst.Objects.Bus.busPop'. /Since: 1.14/ -} busGetPollfd :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: A 'GI.Gst.Objects.Bus.Bus' -} -> m (GLib.PollFD.PollFD) busGetPollfd bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus fd <- callocBoxedBytes 8 :: IO (Ptr GLib.PollFD.PollFD) gst_bus_get_pollfd bus' fd fd' <- (wrapBoxed GLib.PollFD.PollFD) fd touchManagedPtr bus return fd' #if ENABLE_OVERLOADING data BusGetPollfdMethodInfo instance (signature ~ (m (GLib.PollFD.PollFD)), MonadIO m, IsBus a) => O.MethodInfo BusGetPollfdMethodInfo a signature where overloadedMethod _ = busGetPollfd #endif -- method Bus::have_pending -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to check", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bus_have_pending" gst_bus_have_pending :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO CInt {- | Check if there are pending messages on the bus that should be handled. -} busHavePending :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to check -} -> m Bool {- ^ __Returns:__ 'True' if there are messages on the bus to be handled, 'False' otherwise. MT safe. -} busHavePending bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus result <- gst_bus_have_pending bus' let result' = (/= 0) result touchManagedPtr bus return result' #if ENABLE_OVERLOADING data BusHavePendingMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBus a) => O.MethodInfo BusHavePendingMethodInfo a signature where overloadedMethod _ = busHavePending #endif -- method Bus::peek -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_peek" gst_bus_peek :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO (Ptr Gst.Message.Message) {- | Peek the message on the top of the bus\' queue. The message will remain on the bus\' message queue. A reference is returned, and needs to be unreffed by the caller. -} busPeek :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' -} -> m (Maybe Gst.Message.Message) {- ^ __Returns:__ the 'GI.Gst.Structs.Message.Message' that is on the bus, or 'Nothing' if the bus is empty. MT safe. -} busPeek bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus result <- gst_bus_peek bus' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Message.Message) result' return result'' touchManagedPtr bus return maybeResult #if ENABLE_OVERLOADING data BusPeekMethodInfo instance (signature ~ (m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusPeekMethodInfo a signature where overloadedMethod _ = busPeek #endif -- method Bus::poll -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "events", argType = TInterface (Name {namespace = "Gst", name = "MessageType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a mask of #GstMessageType, representing the set of message types to\npoll for (note special handling of extended message types below)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the poll timeout, as a #GstClockTime, or #GST_CLOCK_TIME_NONE to poll\nindefinitely.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_poll" gst_bus_poll :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) CUInt -> -- events : TInterface (Name {namespace = "Gst", name = "MessageType"}) Word64 -> -- timeout : TBasicType TUInt64 IO (Ptr Gst.Message.Message) {- | Poll the bus for messages. Will block while waiting for messages to come. You can specify a maximum time to poll with the /@timeout@/ parameter. If /@timeout@/ is negative, this function will block indefinitely. All messages not in /@events@/ will be popped off the bus and will be ignored. It is not possible to use message enums beyond @/GST_MESSAGE_EXTENDED/@ in the /@events@/ mask Because poll is implemented using the \"message\" signal enabled by 'GI.Gst.Objects.Bus.busAddSignalWatch', calling 'GI.Gst.Objects.Bus.busPoll' will cause the \"message\" signal to be emitted for every message that poll sees. Thus a \"message\" signal handler will see the same messages that this function sees -- neither will steal messages from the other. This function will run a main loop from the default main context when polling. You should never use this function, since it is pure evil. This is especially true for GUI applications based on Gtk+ or Qt, but also for any other non-trivial application that uses the GLib main loop. As this function runs a GLib main loop, any callback attached to the default GLib main context may be invoked. This could be timeouts, GUI events, I\/O events etc.; even if 'GI.Gst.Objects.Bus.busPoll' is called with a 0 timeout. Any of these callbacks may do things you do not expect, e.g. destroy the main application window or some other resource; change other application state; display a dialog and run another main loop until the user clicks it away. In short, using this function may add a lot of complexity to your code through unexpected re-entrancy and unexpected changes to your application\'s state. For 0 timeouts use 'GI.Gst.Objects.Bus.busPopFiltered' instead of this function; for other short timeouts use 'GI.Gst.Objects.Bus.busTimedPopFiltered'; everything else is better handled by setting up an asynchronous bus watch and doing things from there. -} busPoll :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' -} -> [Gst.Flags.MessageType] {- ^ /@events@/: a mask of 'GI.Gst.Flags.MessageType', representing the set of message types to poll for (note special handling of extended message types below) -} -> Word64 {- ^ /@timeout@/: the poll timeout, as a @/GstClockTime/@, or 'GI.Gst.Constants.CLOCK_TIME_NONE' to poll indefinitely. -} -> m (Maybe Gst.Message.Message) {- ^ __Returns:__ the message that was received, or 'Nothing' if the poll timed out. The message is taken from the bus and needs to be unreffed with @/gst_message_unref()/@ after usage. -} busPoll bus events timeout = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus let events' = gflagsToWord events result <- gst_bus_poll bus' events' timeout maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Message.Message) result' return result'' touchManagedPtr bus return maybeResult #if 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 -- method Bus::pop -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to pop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_pop" gst_bus_pop :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO (Ptr Gst.Message.Message) {- | Get a message from the bus. -} busPop :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to pop -} -> m (Maybe Gst.Message.Message) {- ^ __Returns:__ the 'GI.Gst.Structs.Message.Message' that is on the bus, or 'Nothing' if the bus is empty. The message is taken from the bus and needs to be unreffed with @/gst_message_unref()/@ after usage. MT safe. -} busPop bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus result <- gst_bus_pop bus' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Message.Message) result' return result'' touchManagedPtr bus return maybeResult #if ENABLE_OVERLOADING data BusPopMethodInfo instance (signature ~ (m (Maybe Gst.Message.Message)), MonadIO m, IsBus a) => O.MethodInfo BusPopMethodInfo a signature where overloadedMethod _ = busPop #endif -- method Bus::pop_filtered -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to pop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface (Name {namespace = "Gst", name = "MessageType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "message types to take into account", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_pop_filtered" gst_bus_pop_filtered :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) CUInt -> -- types : TInterface (Name {namespace = "Gst", name = "MessageType"}) IO (Ptr Gst.Message.Message) {- | Get a message matching /@type@/ from the bus. Will discard all messages on the bus that do not match /@type@/ and that have been posted before the first message that does match /@type@/. If there is no message matching /@type@/ on the bus, all messages will be discarded. It is not possible to use message enums beyond @/GST_MESSAGE_EXTENDED/@ in the /@events@/ mask. -} busPopFiltered :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to pop -} -> [Gst.Flags.MessageType] {- ^ /@types@/: message types to take into account -} -> m (Maybe Gst.Message.Message) {- ^ __Returns:__ the next 'GI.Gst.Structs.Message.Message' matching /@type@/ that is on the bus, or 'Nothing' if the bus is empty or there is no message matching /@type@/. The message is taken from the bus and needs to be unreffed with @/gst_message_unref()/@ after usage. MT safe. -} busPopFiltered bus types = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus let types' = gflagsToWord types result <- gst_bus_pop_filtered bus' types' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Message.Message) result' return result'' touchManagedPtr bus return maybeResult #if 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 -- method Bus::post -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to post on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstMessage to post", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bus_post" gst_bus_post :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Ptr Gst.Message.Message -> -- message : TInterface (Name {namespace = "Gst", name = "Message"}) IO CInt {- | Post a message on the given bus. Ownership of the message is taken by the bus. -} busPost :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to post on -} -> Gst.Message.Message {- ^ /@message@/: the 'GI.Gst.Structs.Message.Message' to post -} -> m Bool {- ^ __Returns:__ 'True' if the message could be posted, 'False' if the bus is flushing. MT safe. -} busPost bus message = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus message' <- B.ManagedPtr.disownBoxed message result <- gst_bus_post bus' message' let result' = (/= 0) result touchManagedPtr bus touchManagedPtr message return result' #if ENABLE_OVERLOADING data BusPostMethodInfo instance (signature ~ (Gst.Message.Message -> m Bool), MonadIO m, IsBus a) => O.MethodInfo BusPostMethodInfo a signature where overloadedMethod _ = busPost #endif -- method Bus::remove_signal_watch -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus you previously added a signal watch to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_remove_signal_watch" gst_bus_remove_signal_watch :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO () {- | Removes a signal watch previously added with 'GI.Gst.Objects.Bus.busAddSignalWatch'. MT safe. -} busRemoveSignalWatch :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' you previously added a signal watch to -} -> m () busRemoveSignalWatch bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus gst_bus_remove_signal_watch bus' touchManagedPtr bus return () #if ENABLE_OVERLOADING data BusRemoveSignalWatchMethodInfo instance (signature ~ (m ()), MonadIO m, IsBus a) => O.MethodInfo BusRemoveSignalWatchMethodInfo a signature where overloadedMethod _ = busRemoveSignalWatch #endif -- method Bus::remove_watch -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to remove the watch from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_bus_remove_watch" gst_bus_remove_watch :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) IO CInt {- | Removes an installed bus watch from /@bus@/. /Since: 1.6/ -} busRemoveWatch :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to remove the watch from. -} -> m Bool {- ^ __Returns:__ 'True' on success or 'False' if /@bus@/ has no event source. -} busRemoveWatch bus = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus result <- gst_bus_remove_watch bus' let result' = (/= 0) result touchManagedPtr bus return result' #if ENABLE_OVERLOADING data BusRemoveWatchMethodInfo instance (signature ~ (m Bool), MonadIO m, IsBus a) => O.MethodInfo BusRemoveWatchMethodInfo a signature where overloadedMethod _ = busRemoveWatch #endif -- method Bus::set_flushing -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not to flush the bus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_set_flushing" gst_bus_set_flushing :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) CInt -> -- flushing : TBasicType TBoolean IO () {- | If /@flushing@/, flush out and unref any messages queued in the bus. Releases references to the message origin objects. Will flush future messages until 'GI.Gst.Objects.Bus.busSetFlushing' sets /@flushing@/ to 'False'. MT safe. -} busSetFlushing :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' -} -> Bool {- ^ /@flushing@/: whether or not to flush the bus -} -> m () busSetFlushing bus flushing = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus let flushing' = (fromIntegral . fromEnum) flushing gst_bus_set_flushing bus' flushing' touchManagedPtr bus return () #if ENABLE_OVERLOADING data BusSetFlushingMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsBus a) => O.MethodInfo BusSetFlushingMethodInfo a signature where overloadedMethod _ = busSetFlushing #endif -- method Bus::set_sync_handler -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to install the handler on", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gst", name = "BusSyncHandler"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The handler function to install", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "User data that will be sent to the handler function.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "called when @user_data becomes unused", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_bus_set_sync_handler" gst_bus_set_sync_handler :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) FunPtr Gst.Callbacks.C_BusSyncHandler -> -- func : TInterface (Name {namespace = "Gst", name = "BusSyncHandler"}) Ptr () -> -- user_data : TBasicType TPtr FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"}) IO () {- | Sets the synchronous handler on the bus. The function will be called every time a new message is posted on the bus. Note that the function will be called in the same thread context as the posting object. This function is usually only called by the creator of the bus. Applications should handle messages asynchronously using the gst_bus watch and poll functions. You cannot replace an existing sync_handler. You can pass 'Nothing' to this function, which will clear the existing handler. -} busSetSyncHandler :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to install the handler on -} -> Maybe (Gst.Callbacks.BusSyncHandler) {- ^ /@func@/: The handler function to install -} -> m () busSetSyncHandler bus func = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus maybeFunc <- case func of Nothing -> return (castPtrToFunPtr nullPtr) Just jFunc -> do jFunc' <- Gst.Callbacks.mk_BusSyncHandler (Gst.Callbacks.wrap_BusSyncHandler Nothing (Gst.Callbacks.drop_closures_BusSyncHandler jFunc)) return jFunc' let userData = castFunPtrToPtr maybeFunc let notify = safeFreeFunPtrPtr gst_bus_set_sync_handler bus' maybeFunc userData notify touchManagedPtr bus return () #if ENABLE_OVERLOADING data BusSetSyncHandlerMethodInfo instance (signature ~ (Maybe (Gst.Callbacks.BusSyncHandler) -> m ()), MonadIO m, IsBus a) => O.MethodInfo BusSetSyncHandlerMethodInfo a signature where overloadedMethod _ = busSetSyncHandler #endif -- method Bus::sync_signal_handler -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface (Name {namespace = "Gst", name = "Message"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstMessage received", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "BusSyncReply"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_sync_signal_handler" gst_bus_sync_signal_handler :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Ptr Gst.Message.Message -> -- message : TInterface (Name {namespace = "Gst", name = "Message"}) Ptr () -> -- data : TBasicType TPtr IO CUInt {- | A helper GstBusSyncHandler that can be used to convert all synchronous messages into signals. -} busSyncSignalHandler :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' -} -> Gst.Message.Message {- ^ /@message@/: the 'GI.Gst.Structs.Message.Message' received -} -> Ptr () {- ^ /@data@/: user data -} -> m Gst.Enums.BusSyncReply {- ^ __Returns:__ GST_BUS_PASS -} busSyncSignalHandler bus message data_ = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus message' <- unsafeManagedPtrGetPtr message result <- gst_bus_sync_signal_handler bus' message' data_ let result' = (toEnum . fromIntegral) result touchManagedPtr bus touchManagedPtr message return result' #if 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 -- method Bus::timed_pop -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to pop", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timeout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_timed_pop" gst_bus_timed_pop :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Word64 -> -- timeout : TBasicType TUInt64 IO (Ptr Gst.Message.Message) {- | Get a message from the bus, waiting up to the specified timeout. If /@timeout@/ is 0, this function behaves like 'GI.Gst.Objects.Bus.busPop'. If /@timeout@/ is 'GI.Gst.Constants.CLOCK_TIME_NONE', this function will block forever until a message was posted on the bus. -} busTimedPop :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to pop -} -> Word64 {- ^ /@timeout@/: a timeout -} -> m (Maybe Gst.Message.Message) {- ^ __Returns:__ the 'GI.Gst.Structs.Message.Message' that is on the bus after the specified timeout or 'Nothing' if the bus is empty after the timeout expired. The message is taken from the bus and needs to be unreffed with @/gst_message_unref()/@ after usage. MT safe. -} busTimedPop bus timeout = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus result <- gst_bus_timed_pop bus' timeout maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Message.Message) result' return result'' touchManagedPtr bus return maybeResult #if 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 -- method Bus::timed_pop_filtered -- method type : OrdinaryMethod -- Args : [Arg {argCName = "bus", argType = TInterface (Name {namespace = "Gst", name = "Bus"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstBus to pop from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a timeout in nanoseconds, or GST_CLOCK_TIME_NONE to wait forever", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface (Name {namespace = "Gst", name = "MessageType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "message types to take into account, GST_MESSAGE_ANY for any type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Message"})) -- throws : False -- Skip return : False foreign import ccall "gst_bus_timed_pop_filtered" gst_bus_timed_pop_filtered :: Ptr Bus -> -- bus : TInterface (Name {namespace = "Gst", name = "Bus"}) Word64 -> -- timeout : TBasicType TUInt64 CUInt -> -- types : TInterface (Name {namespace = "Gst", name = "MessageType"}) IO (Ptr Gst.Message.Message) {- | Get a message from the bus whose type matches the message type mask /@types@/, waiting up to the specified timeout (and discarding any messages that do not match the mask provided). If /@timeout@/ is 0, this function behaves like 'GI.Gst.Objects.Bus.busPopFiltered'. If /@timeout@/ is 'GI.Gst.Constants.CLOCK_TIME_NONE', this function will block forever until a matching message was posted on the bus. -} busTimedPopFiltered :: (B.CallStack.HasCallStack, MonadIO m, IsBus a) => a {- ^ /@bus@/: a 'GI.Gst.Objects.Bus.Bus' to pop from -} -> Word64 {- ^ /@timeout@/: a timeout in nanoseconds, or GST_CLOCK_TIME_NONE to wait forever -} -> [Gst.Flags.MessageType] {- ^ /@types@/: message types to take into account, GST_MESSAGE_ANY for any type -} -> m (Maybe Gst.Message.Message) {- ^ __Returns:__ a 'GI.Gst.Structs.Message.Message' matching the filter in /@types@/, or 'Nothing' if no matching message was found on the bus until the timeout expired. The message is taken from the bus and needs to be unreffed with @/gst_message_unref()/@ after usage. MT safe. -} busTimedPopFiltered bus timeout types = liftIO $ do bus' <- unsafeManagedPtrCastPtr bus let types' = gflagsToWord types result <- gst_bus_timed_pop_filtered bus' timeout types' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Gst.Message.Message) result' return result'' touchManagedPtr bus return maybeResult #if 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