{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GstPbutils.Objects.Discoverer
(
Discoverer(..) ,
IsDiscoverer ,
toDiscoverer ,
#if defined(ENABLE_OVERLOADING)
ResolveDiscovererMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DiscovererDiscoverUriMethodInfo ,
#endif
discovererDiscoverUri ,
#if defined(ENABLE_OVERLOADING)
DiscovererDiscoverUriAsyncMethodInfo ,
#endif
discovererDiscoverUriAsync ,
discovererNew ,
#if defined(ENABLE_OVERLOADING)
DiscovererStartMethodInfo ,
#endif
discovererStart ,
#if defined(ENABLE_OVERLOADING)
DiscovererStopMethodInfo ,
#endif
discovererStop ,
#if defined(ENABLE_OVERLOADING)
DiscovererTimeoutPropertyInfo ,
#endif
constructDiscovererTimeout ,
#if defined(ENABLE_OVERLOADING)
discovererTimeout ,
#endif
getDiscovererTimeout ,
setDiscovererTimeout ,
#if defined(ENABLE_OVERLOADING)
DiscovererUseCachePropertyInfo ,
#endif
constructDiscovererUseCache ,
#if defined(ENABLE_OVERLOADING)
discovererUseCache ,
#endif
getDiscovererUseCache ,
setDiscovererUseCache ,
C_DiscovererDiscoveredCallback ,
DiscovererDiscoveredCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererDiscoveredSignalInfo ,
#endif
afterDiscovererDiscovered ,
genClosure_DiscovererDiscovered ,
mk_DiscovererDiscoveredCallback ,
noDiscovererDiscoveredCallback ,
onDiscovererDiscovered ,
wrap_DiscovererDiscoveredCallback ,
C_DiscovererFinishedCallback ,
DiscovererFinishedCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererFinishedSignalInfo ,
#endif
afterDiscovererFinished ,
genClosure_DiscovererFinished ,
mk_DiscovererFinishedCallback ,
noDiscovererFinishedCallback ,
onDiscovererFinished ,
wrap_DiscovererFinishedCallback ,
C_DiscovererSourceSetupCallback ,
DiscovererSourceSetupCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererSourceSetupSignalInfo ,
#endif
afterDiscovererSourceSetup ,
genClosure_DiscovererSourceSetup ,
mk_DiscovererSourceSetupCallback ,
noDiscovererSourceSetupCallback ,
onDiscovererSourceSetup ,
wrap_DiscovererSourceSetupCallback ,
C_DiscovererStartingCallback ,
DiscovererStartingCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererStartingSignalInfo ,
#endif
afterDiscovererStarting ,
genClosure_DiscovererStarting ,
mk_DiscovererStartingCallback ,
noDiscovererStartingCallback ,
onDiscovererStarting ,
wrap_DiscovererStartingCallback ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
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 Control.Monad.IO.Class as MIO
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 GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Objects.Element as Gst.Element
import {-# SOURCE #-} qualified GI.GstPbutils.Objects.DiscovererInfo as GstPbutils.DiscovererInfo
newtype Discoverer = Discoverer (SP.ManagedPtr Discoverer)
deriving (Discoverer -> Discoverer -> Bool
(Discoverer -> Discoverer -> Bool)
-> (Discoverer -> Discoverer -> Bool) -> Eq Discoverer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Discoverer -> Discoverer -> Bool
$c/= :: Discoverer -> Discoverer -> Bool
== :: Discoverer -> Discoverer -> Bool
$c== :: Discoverer -> Discoverer -> Bool
Eq)
instance SP.ManagedPtrNewtype Discoverer where
toManagedPtr :: Discoverer -> ManagedPtr Discoverer
toManagedPtr (Discoverer ManagedPtr Discoverer
p) = ManagedPtr Discoverer
p
foreign import ccall "gst_discoverer_get_type"
c_gst_discoverer_get_type :: IO B.Types.GType
instance B.Types.TypedObject Discoverer where
glibType :: IO GType
glibType = IO GType
c_gst_discoverer_get_type
instance B.Types.GObject Discoverer
class (SP.GObject o, O.IsDescendantOf Discoverer o) => IsDiscoverer o
instance (SP.GObject o, O.IsDescendantOf Discoverer o) => IsDiscoverer o
instance O.HasParentTypes Discoverer
type instance O.ParentTypes Discoverer = '[GObject.Object.Object]
toDiscoverer :: (MIO.MonadIO m, IsDiscoverer o) => o -> m Discoverer
toDiscoverer :: forall (m :: * -> *) o.
(MonadIO m, IsDiscoverer o) =>
o -> m Discoverer
toDiscoverer = IO Discoverer -> m Discoverer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Discoverer -> m Discoverer)
-> (o -> IO Discoverer) -> o -> m Discoverer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Discoverer -> Discoverer) -> o -> IO Discoverer
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Discoverer -> Discoverer
Discoverer
instance B.GValue.IsGValue (Maybe Discoverer) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_discoverer_get_type
gvalueSet_ :: Ptr GValue -> Maybe Discoverer -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Discoverer
P.Nothing = Ptr GValue -> Ptr Discoverer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Discoverer
forall a. Ptr a
FP.nullPtr :: FP.Ptr Discoverer)
gvalueSet_ Ptr GValue
gv (P.Just Discoverer
obj) = Discoverer -> (Ptr Discoverer -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Discoverer
obj (Ptr GValue -> Ptr Discoverer -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Discoverer)
gvalueGet_ Ptr GValue
gv = do
Ptr Discoverer
ptr <- Ptr GValue -> IO (Ptr Discoverer)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Discoverer)
if Ptr Discoverer
ptr Ptr Discoverer -> Ptr Discoverer -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Discoverer
forall a. Ptr a
FP.nullPtr
then Discoverer -> Maybe Discoverer
forall a. a -> Maybe a
P.Just (Discoverer -> Maybe Discoverer)
-> IO Discoverer -> IO (Maybe Discoverer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Discoverer -> Discoverer)
-> Ptr Discoverer -> IO Discoverer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Discoverer -> Discoverer
Discoverer Ptr Discoverer
ptr
else Maybe Discoverer -> IO (Maybe Discoverer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Discoverer
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDiscovererMethod (t :: Symbol) (o :: *) :: * where
ResolveDiscovererMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDiscovererMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDiscovererMethod "discoverUri" o = DiscovererDiscoverUriMethodInfo
ResolveDiscovererMethod "discoverUriAsync" o = DiscovererDiscoverUriAsyncMethodInfo
ResolveDiscovererMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDiscovererMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDiscovererMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDiscovererMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDiscovererMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDiscovererMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDiscovererMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDiscovererMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDiscovererMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDiscovererMethod "start" o = DiscovererStartMethodInfo
ResolveDiscovererMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDiscovererMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDiscovererMethod "stop" o = DiscovererStopMethodInfo
ResolveDiscovererMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDiscovererMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDiscovererMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDiscovererMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDiscovererMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDiscovererMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDiscovererMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDiscovererMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDiscovererMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDiscovererMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDiscovererMethod t Discoverer, O.OverloadedMethod info Discoverer p) => OL.IsLabel t (Discoverer -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDiscovererMethod t Discoverer, O.OverloadedMethod info Discoverer p, R.HasField t Discoverer p) => R.HasField t Discoverer p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDiscovererMethod t Discoverer, O.OverloadedMethodInfo info Discoverer) => OL.IsLabel t (O.MethodProxy info Discoverer) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type DiscovererDiscoveredCallback =
GstPbutils.DiscovererInfo.DiscovererInfo
-> Maybe GError
-> IO ()
noDiscovererDiscoveredCallback :: Maybe DiscovererDiscoveredCallback
noDiscovererDiscoveredCallback :: Maybe DiscovererDiscoveredCallback
noDiscovererDiscoveredCallback = Maybe DiscovererDiscoveredCallback
forall a. Maybe a
Nothing
type C_DiscovererDiscoveredCallback =
Ptr () ->
Ptr GstPbutils.DiscovererInfo.DiscovererInfo ->
Ptr GError ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererDiscoveredCallback :: C_DiscovererDiscoveredCallback -> IO (FunPtr C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered :: MonadIO m => DiscovererDiscoveredCallback -> m (GClosure C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered :: forall (m :: * -> *).
MonadIO m =>
DiscovererDiscoveredCallback
-> m (GClosure C_DiscovererDiscoveredCallback)
genClosure_DiscovererDiscovered DiscovererDiscoveredCallback
cb = IO (GClosure C_DiscovererDiscoveredCallback)
-> m (GClosure C_DiscovererDiscoveredCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererDiscoveredCallback)
-> m (GClosure C_DiscovererDiscoveredCallback))
-> IO (GClosure C_DiscovererDiscoveredCallback)
-> m (GClosure C_DiscovererDiscoveredCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererDiscoveredCallback
cb' = DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback DiscovererDiscoveredCallback
cb
C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
cb' IO (FunPtr C_DiscovererDiscoveredCallback)
-> (FunPtr C_DiscovererDiscoveredCallback
-> IO (GClosure C_DiscovererDiscoveredCallback))
-> IO (GClosure C_DiscovererDiscoveredCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererDiscoveredCallback
-> IO (GClosure C_DiscovererDiscoveredCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererDiscoveredCallback ::
DiscovererDiscoveredCallback ->
C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback :: DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback DiscovererDiscoveredCallback
_cb Ptr ()
_ Ptr DiscovererInfo
info Ptr GError
error_ Ptr ()
_ = do
DiscovererInfo
info' <- ((ManagedPtr DiscovererInfo -> DiscovererInfo)
-> Ptr DiscovererInfo -> IO DiscovererInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DiscovererInfo -> DiscovererInfo
GstPbutils.DiscovererInfo.DiscovererInfo) Ptr DiscovererInfo
info
Maybe GError
maybeError_ <-
if Ptr GError
error_ Ptr GError -> Ptr GError -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr GError
forall a. Ptr a
nullPtr
then Maybe GError -> IO (Maybe GError)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GError
forall a. Maybe a
Nothing
else do
GError
error_' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GError -> GError
GError) Ptr GError
error_
Maybe GError -> IO (Maybe GError)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe GError -> IO (Maybe GError))
-> Maybe GError -> IO (Maybe GError)
forall a b. (a -> b) -> a -> b
$ GError -> Maybe GError
forall a. a -> Maybe a
Just GError
error_'
DiscovererDiscoveredCallback
_cb DiscovererInfo
info' Maybe GError
maybeError_
onDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId
onDiscovererDiscovered :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> DiscovererDiscoveredCallback -> m SignalHandlerId
onDiscovererDiscovered a
obj DiscovererDiscoveredCallback
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_DiscovererDiscoveredCallback
cb' = DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback DiscovererDiscoveredCallback
cb
FunPtr C_DiscovererDiscoveredCallback
cb'' <- C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
cb'
a
-> Text
-> FunPtr C_DiscovererDiscoveredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"discovered" FunPtr C_DiscovererDiscoveredCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> DiscovererDiscoveredCallback -> m SignalHandlerId
afterDiscovererDiscovered :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> DiscovererDiscoveredCallback -> m SignalHandlerId
afterDiscovererDiscovered a
obj DiscovererDiscoveredCallback
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_DiscovererDiscoveredCallback
cb' = DiscovererDiscoveredCallback -> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback DiscovererDiscoveredCallback
cb
FunPtr C_DiscovererDiscoveredCallback
cb'' <- C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
cb'
a
-> Text
-> FunPtr C_DiscovererDiscoveredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"discovered" FunPtr C_DiscovererDiscoveredCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererDiscoveredSignalInfo
instance SignalInfo DiscovererDiscoveredSignalInfo where
type HaskellCallbackType DiscovererDiscoveredSignalInfo = DiscovererDiscoveredCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererDiscoveredCallback cb
cb'' <- mk_DiscovererDiscoveredCallback cb'
connectSignalFunPtr obj "discovered" cb'' connectMode detail
#endif
type DiscovererFinishedCallback =
IO ()
noDiscovererFinishedCallback :: Maybe DiscovererFinishedCallback
noDiscovererFinishedCallback :: Maybe (IO ())
noDiscovererFinishedCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_DiscovererFinishedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererFinishedCallback :: C_DiscovererFinishedCallback -> IO (FunPtr C_DiscovererFinishedCallback)
genClosure_DiscovererFinished :: MonadIO m => DiscovererFinishedCallback -> m (GClosure C_DiscovererFinishedCallback)
genClosure_DiscovererFinished :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_DiscovererFinishedCallback)
genClosure_DiscovererFinished IO ()
cb = IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback IO ()
cb
C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
cb' IO (FunPtr C_DiscovererFinishedCallback)
-> (FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererFinishedCallback ::
DiscovererFinishedCallback ->
C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback :: IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId
onDiscovererFinished :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onDiscovererFinished a
obj IO ()
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_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"finished" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> DiscovererFinishedCallback -> m SignalHandlerId
afterDiscovererFinished :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterDiscovererFinished a
obj IO ()
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_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"finished" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererFinishedSignalInfo
instance SignalInfo DiscovererFinishedSignalInfo where
type HaskellCallbackType DiscovererFinishedSignalInfo = DiscovererFinishedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererFinishedCallback cb
cb'' <- mk_DiscovererFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' connectMode detail
#endif
type DiscovererSourceSetupCallback =
Gst.Element.Element
-> IO ()
noDiscovererSourceSetupCallback :: Maybe DiscovererSourceSetupCallback
noDiscovererSourceSetupCallback :: Maybe DiscovererSourceSetupCallback
noDiscovererSourceSetupCallback = Maybe DiscovererSourceSetupCallback
forall a. Maybe a
Nothing
type C_DiscovererSourceSetupCallback =
Ptr () ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererSourceSetupCallback :: C_DiscovererSourceSetupCallback -> IO (FunPtr C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup :: MonadIO m => DiscovererSourceSetupCallback -> m (GClosure C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup :: forall (m :: * -> *).
MonadIO m =>
DiscovererSourceSetupCallback
-> m (GClosure C_DiscovererSourceSetupCallback)
genClosure_DiscovererSourceSetup DiscovererSourceSetupCallback
cb = IO (GClosure C_DiscovererSourceSetupCallback)
-> m (GClosure C_DiscovererSourceSetupCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererSourceSetupCallback)
-> m (GClosure C_DiscovererSourceSetupCallback))
-> IO (GClosure C_DiscovererSourceSetupCallback)
-> m (GClosure C_DiscovererSourceSetupCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererSourceSetupCallback
cb' = DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback DiscovererSourceSetupCallback
cb
C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
cb' IO (FunPtr C_DiscovererSourceSetupCallback)
-> (FunPtr C_DiscovererSourceSetupCallback
-> IO (GClosure C_DiscovererSourceSetupCallback))
-> IO (GClosure C_DiscovererSourceSetupCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererSourceSetupCallback
-> IO (GClosure C_DiscovererSourceSetupCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererSourceSetupCallback ::
DiscovererSourceSetupCallback ->
C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback :: DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback DiscovererSourceSetupCallback
_cb Ptr ()
_ Ptr Element
source Ptr ()
_ = do
Element
source' <- ((ManagedPtr Element -> Element) -> Ptr Element -> IO Element
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
source
DiscovererSourceSetupCallback
_cb Element
source'
onDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId
onDiscovererSourceSetup :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> DiscovererSourceSetupCallback -> m SignalHandlerId
onDiscovererSourceSetup a
obj DiscovererSourceSetupCallback
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_DiscovererSourceSetupCallback
cb' = DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback DiscovererSourceSetupCallback
cb
FunPtr C_DiscovererSourceSetupCallback
cb'' <- C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
cb'
a
-> Text
-> FunPtr C_DiscovererSourceSetupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"source-setup" FunPtr C_DiscovererSourceSetupCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> DiscovererSourceSetupCallback -> m SignalHandlerId
afterDiscovererSourceSetup :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> DiscovererSourceSetupCallback -> m SignalHandlerId
afterDiscovererSourceSetup a
obj DiscovererSourceSetupCallback
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_DiscovererSourceSetupCallback
cb' = DiscovererSourceSetupCallback -> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback DiscovererSourceSetupCallback
cb
FunPtr C_DiscovererSourceSetupCallback
cb'' <- C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
cb'
a
-> Text
-> FunPtr C_DiscovererSourceSetupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"source-setup" FunPtr C_DiscovererSourceSetupCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererSourceSetupSignalInfo
instance SignalInfo DiscovererSourceSetupSignalInfo where
type HaskellCallbackType DiscovererSourceSetupSignalInfo = DiscovererSourceSetupCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererSourceSetupCallback cb
cb'' <- mk_DiscovererSourceSetupCallback cb'
connectSignalFunPtr obj "source-setup" cb'' connectMode detail
#endif
type DiscovererStartingCallback =
IO ()
noDiscovererStartingCallback :: Maybe DiscovererStartingCallback
noDiscovererStartingCallback :: Maybe (IO ())
noDiscovererStartingCallback = Maybe (IO ())
forall a. Maybe a
Nothing
type C_DiscovererStartingCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererStartingCallback :: C_DiscovererStartingCallback -> IO (FunPtr C_DiscovererStartingCallback)
genClosure_DiscovererStarting :: MonadIO m => DiscovererStartingCallback -> m (GClosure C_DiscovererStartingCallback)
genClosure_DiscovererStarting :: forall (m :: * -> *).
MonadIO m =>
IO () -> m (GClosure C_DiscovererFinishedCallback)
genClosure_DiscovererStarting IO ()
cb = IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
-> m (GClosure C_DiscovererFinishedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback IO ()
cb
C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
cb' IO (FunPtr C_DiscovererFinishedCallback)
-> (FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback))
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DiscovererFinishedCallback
-> IO (GClosure C_DiscovererFinishedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DiscovererStartingCallback ::
DiscovererStartingCallback ->
C_DiscovererStartingCallback
wrap_DiscovererStartingCallback :: IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback IO ()
_cb Ptr ()
_ Ptr ()
_ = do
IO ()
_cb
onDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId
onDiscovererStarting :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
onDiscovererStarting a
obj IO ()
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_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"starting" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> DiscovererStartingCallback -> m SignalHandlerId
afterDiscovererStarting :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> IO () -> m SignalHandlerId
afterDiscovererStarting a
obj IO ()
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_DiscovererFinishedCallback
cb' = IO () -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback IO ()
cb
FunPtr C_DiscovererFinishedCallback
cb'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
cb'
a
-> Text
-> FunPtr C_DiscovererFinishedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"starting" FunPtr C_DiscovererFinishedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DiscovererStartingSignalInfo
instance SignalInfo DiscovererStartingSignalInfo where
type HaskellCallbackType DiscovererStartingSignalInfo = DiscovererStartingCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DiscovererStartingCallback cb
cb'' <- mk_DiscovererStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' connectMode detail
#endif
getDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> m Word64
getDiscovererTimeout :: forall (m :: * -> *) o.
(MonadIO m, IsDiscoverer o) =>
o -> m Word64
getDiscovererTimeout o
obj = IO Word64 -> m Word64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word64
forall a. GObject a => a -> String -> IO Word64
B.Properties.getObjectPropertyUInt64 o
obj String
"timeout"
setDiscovererTimeout :: (MonadIO m, IsDiscoverer o) => o -> Word64 -> m ()
setDiscovererTimeout :: forall (m :: * -> *) o.
(MonadIO m, IsDiscoverer o) =>
o -> Word64 -> m ()
setDiscovererTimeout o
obj Word64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Word64 -> IO ()
forall a. GObject a => a -> String -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj String
"timeout" Word64
val
constructDiscovererTimeout :: (IsDiscoverer o, MIO.MonadIO m) => Word64 -> m (GValueConstruct o)
constructDiscovererTimeout :: forall o (m :: * -> *).
(IsDiscoverer o, MonadIO m) =>
Word64 -> m (GValueConstruct o)
constructDiscovererTimeout Word64
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word64 -> IO (GValueConstruct o)
forall o. String -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 String
"timeout" Word64
val
#if defined(ENABLE_OVERLOADING)
data DiscovererTimeoutPropertyInfo
instance AttrInfo DiscovererTimeoutPropertyInfo where
type AttrAllowedOps DiscovererTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiscovererTimeoutPropertyInfo = IsDiscoverer
type AttrSetTypeConstraint DiscovererTimeoutPropertyInfo = (~) Word64
type AttrTransferTypeConstraint DiscovererTimeoutPropertyInfo = (~) Word64
type AttrTransferType DiscovererTimeoutPropertyInfo = Word64
type AttrGetType DiscovererTimeoutPropertyInfo = Word64
type AttrLabel DiscovererTimeoutPropertyInfo = "timeout"
type AttrOrigin DiscovererTimeoutPropertyInfo = Discoverer
attrGet = getDiscovererTimeout
attrSet = setDiscovererTimeout
attrTransfer _ v = do
return v
attrConstruct = constructDiscovererTimeout
attrClear = undefined
#endif
getDiscovererUseCache :: (MonadIO m, IsDiscoverer o) => o -> m Bool
getDiscovererUseCache :: forall (m :: * -> *) o. (MonadIO m, IsDiscoverer o) => o -> m Bool
getDiscovererUseCache o
obj = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"use-cache"
setDiscovererUseCache :: (MonadIO m, IsDiscoverer o) => o -> Bool -> m ()
setDiscovererUseCache :: forall (m :: * -> *) o.
(MonadIO m, IsDiscoverer o) =>
o -> Bool -> m ()
setDiscovererUseCache o
obj Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"use-cache" Bool
val
constructDiscovererUseCache :: (IsDiscoverer o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructDiscovererUseCache :: forall o (m :: * -> *).
(IsDiscoverer o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructDiscovererUseCache Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"use-cache" Bool
val
#if defined(ENABLE_OVERLOADING)
data DiscovererUseCachePropertyInfo
instance AttrInfo DiscovererUseCachePropertyInfo where
type AttrAllowedOps DiscovererUseCachePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DiscovererUseCachePropertyInfo = IsDiscoverer
type AttrSetTypeConstraint DiscovererUseCachePropertyInfo = (~) Bool
type AttrTransferTypeConstraint DiscovererUseCachePropertyInfo = (~) Bool
type AttrTransferType DiscovererUseCachePropertyInfo = Bool
type AttrGetType DiscovererUseCachePropertyInfo = Bool
type AttrLabel DiscovererUseCachePropertyInfo = "use-cache"
type AttrOrigin DiscovererUseCachePropertyInfo = Discoverer
attrGet = getDiscovererUseCache
attrSet = setDiscovererUseCache
attrTransfer _ v = do
return v
attrConstruct = constructDiscovererUseCache
attrClear = undefined
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Discoverer
type instance O.AttributeList Discoverer = DiscovererAttributeList
type DiscovererAttributeList = ('[ '("timeout", DiscovererTimeoutPropertyInfo), '("useCache", DiscovererUseCachePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
discovererTimeout :: AttrLabelProxy "timeout"
discovererTimeout = AttrLabelProxy
discovererUseCache :: AttrLabelProxy "useCache"
discovererUseCache = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Discoverer = DiscovererSignalList
type DiscovererSignalList = ('[ '("discovered", DiscovererDiscoveredSignalInfo), '("finished", DiscovererFinishedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sourceSetup", DiscovererSourceSetupSignalInfo), '("starting", DiscovererStartingSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_discoverer_new" gst_discoverer_new ::
Word64 ->
Ptr (Ptr GError) ->
IO (Ptr Discoverer)
discovererNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word64
-> m Discoverer
discovererNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word64 -> m Discoverer
discovererNew Word64
timeout = IO Discoverer -> m Discoverer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Discoverer -> m Discoverer) -> IO Discoverer -> m Discoverer
forall a b. (a -> b) -> a -> b
$ do
IO Discoverer -> IO () -> IO Discoverer
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Discoverer
result <- (Ptr (Ptr GError) -> IO (Ptr Discoverer)) -> IO (Ptr Discoverer)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Discoverer)) -> IO (Ptr Discoverer))
-> (Ptr (Ptr GError) -> IO (Ptr Discoverer)) -> IO (Ptr Discoverer)
forall a b. (a -> b) -> a -> b
$ Word64 -> Ptr (Ptr GError) -> IO (Ptr Discoverer)
gst_discoverer_new Word64
timeout
Text -> Ptr Discoverer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererNew" Ptr Discoverer
result
Discoverer
result' <- ((ManagedPtr Discoverer -> Discoverer)
-> Ptr Discoverer -> IO Discoverer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Discoverer -> Discoverer
Discoverer) Ptr Discoverer
result
Discoverer -> IO Discoverer
forall (m :: * -> *) a. Monad m => a -> m a
return Discoverer
result'
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_discoverer_discover_uri" gst_discoverer_discover_uri ::
Ptr Discoverer ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GstPbutils.DiscovererInfo.DiscovererInfo)
discovererDiscoverUri ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> T.Text
-> m GstPbutils.DiscovererInfo.DiscovererInfo
discovererDiscoverUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscoverer a) =>
a -> Text -> m DiscovererInfo
discovererDiscoverUri a
discoverer Text
uri = IO DiscovererInfo -> m DiscovererInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiscovererInfo -> m DiscovererInfo)
-> IO DiscovererInfo -> m DiscovererInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
CString
uri' <- Text -> IO CString
textToCString Text
uri
IO DiscovererInfo -> IO () -> IO DiscovererInfo
forall a b. IO a -> IO b -> IO a
onException (do
Ptr DiscovererInfo
result <- (Ptr (Ptr GError) -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo))
-> (Ptr (Ptr GError) -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo)
forall a b. (a -> b) -> a -> b
$ Ptr Discoverer
-> CString -> Ptr (Ptr GError) -> IO (Ptr DiscovererInfo)
gst_discoverer_discover_uri Ptr Discoverer
discoverer' CString
uri'
Text -> Ptr DiscovererInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererDiscoverUri" Ptr DiscovererInfo
result
DiscovererInfo
result' <- ((ManagedPtr DiscovererInfo -> DiscovererInfo)
-> Ptr DiscovererInfo -> IO DiscovererInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DiscovererInfo -> DiscovererInfo
GstPbutils.DiscovererInfo.DiscovererInfo) Ptr DiscovererInfo
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
discoverer
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
DiscovererInfo -> IO DiscovererInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DiscovererInfo
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
)
#if defined(ENABLE_OVERLOADING)
data DiscovererDiscoverUriMethodInfo
instance (signature ~ (T.Text -> m GstPbutils.DiscovererInfo.DiscovererInfo), MonadIO m, IsDiscoverer a) => O.OverloadedMethod DiscovererDiscoverUriMethodInfo a signature where
overloadedMethod = discovererDiscoverUri
instance O.OverloadedMethodInfo DiscovererDiscoverUriMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.Discoverer.discovererDiscoverUri",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-Discoverer.html#v:discovererDiscoverUri"
}
#endif
foreign import ccall "gst_discoverer_discover_uri_async" gst_discoverer_discover_uri_async ::
Ptr Discoverer ->
CString ->
IO CInt
discovererDiscoverUriAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> T.Text
-> m Bool
discovererDiscoverUriAsync :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscoverer a) =>
a -> Text -> m Bool
discovererDiscoverUriAsync a
discoverer Text
uri = 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 Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
CString
uri' <- Text -> IO CString
textToCString Text
uri
CInt
result <- Ptr Discoverer -> CString -> IO CInt
gst_discoverer_discover_uri_async Ptr Discoverer
discoverer' CString
uri'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
discoverer
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DiscovererDiscoverUriAsyncMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m, IsDiscoverer a) => O.OverloadedMethod DiscovererDiscoverUriAsyncMethodInfo a signature where
overloadedMethod = discovererDiscoverUriAsync
instance O.OverloadedMethodInfo DiscovererDiscoverUriAsyncMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.Discoverer.discovererDiscoverUriAsync",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-Discoverer.html#v:discovererDiscoverUriAsync"
}
#endif
foreign import ccall "gst_discoverer_start" gst_discoverer_start ::
Ptr Discoverer ->
IO ()
discovererStart ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> m ()
discovererStart :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscoverer a) =>
a -> m ()
discovererStart a
discoverer = 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 Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
Ptr Discoverer -> IO ()
gst_discoverer_start Ptr Discoverer
discoverer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
discoverer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiscovererStartMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDiscoverer a) => O.OverloadedMethod DiscovererStartMethodInfo a signature where
overloadedMethod = discovererStart
instance O.OverloadedMethodInfo DiscovererStartMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.Discoverer.discovererStart",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-Discoverer.html#v:discovererStart"
}
#endif
foreign import ccall "gst_discoverer_stop" gst_discoverer_stop ::
Ptr Discoverer ->
IO ()
discovererStop ::
(B.CallStack.HasCallStack, MonadIO m, IsDiscoverer a) =>
a
-> m ()
discovererStop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscoverer a) =>
a -> m ()
discovererStop a
discoverer = 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 Discoverer
discoverer' <- a -> IO (Ptr Discoverer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
discoverer
Ptr Discoverer -> IO ()
gst_discoverer_stop Ptr Discoverer
discoverer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
discoverer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DiscovererStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDiscoverer a) => O.OverloadedMethod DiscovererStopMethodInfo a signature where
overloadedMethod = discovererStop
instance O.OverloadedMethodInfo DiscovererStopMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.GstPbutils.Objects.Discoverer.discovererStop",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.23/docs/GI-GstPbutils-Objects-Discoverer.html#v:discovererStop"
}
#endif