{-# LANGUAGE ImplicitParams, RankNTypes, 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 ,
DiscovererDiscoveredCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererDiscoveredSignalInfo ,
#endif
afterDiscovererDiscovered ,
onDiscovererDiscovered ,
DiscovererFinishedCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererFinishedSignalInfo ,
#endif
afterDiscovererFinished ,
onDiscovererFinished ,
DiscovererSourceSetupCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererSourceSetupSignalInfo ,
#endif
afterDiscovererSourceSetup ,
onDiscovererSourceSetup ,
DiscovererStartingCallback ,
#if defined(ENABLE_OVERLOADING)
DiscovererStartingSignalInfo ,
#endif
afterDiscovererStarting ,
onDiscovererStarting ,
) 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.Coerce as Coerce
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 ()
type C_DiscovererDiscoveredCallback =
Ptr Discoverer ->
Ptr GstPbutils.DiscovererInfo.DiscovererInfo ->
Ptr GError ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererDiscoveredCallback :: C_DiscovererDiscoveredCallback -> IO (FunPtr C_DiscovererDiscoveredCallback)
wrap_DiscovererDiscoveredCallback ::
GObject a => (a -> DiscovererDiscoveredCallback) ->
C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback :: forall a.
GObject a =>
(a -> DiscovererDiscoveredCallback)
-> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback a -> DiscovererDiscoveredCallback
gi'cb Ptr Discoverer
gi'selfPtr 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_'
Ptr Discoverer -> (Discoverer -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Discoverer
gi'selfPtr ((Discoverer -> IO ()) -> IO ()) -> (Discoverer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Discoverer
gi'self -> a -> DiscovererDiscoveredCallback
gi'cb (Discoverer -> a
Coerce.coerce Discoverer
gi'self) DiscovererInfo
info' Maybe GError
maybeError_
onDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererDiscoveredCallback) -> m SignalHandlerId
onDiscovererDiscovered :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a
-> ((?self::a) => DiscovererDiscoveredCallback)
-> m SignalHandlerId
onDiscovererDiscovered a
obj (?self::a) => 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 wrapped :: a -> DiscovererDiscoveredCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererDiscoveredCallback
DiscovererDiscoveredCallback
cb
let wrapped' :: C_DiscovererDiscoveredCallback
wrapped' = (a -> DiscovererDiscoveredCallback)
-> C_DiscovererDiscoveredCallback
forall a.
GObject a =>
(a -> DiscovererDiscoveredCallback)
-> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback a -> DiscovererDiscoveredCallback
wrapped
FunPtr C_DiscovererDiscoveredCallback
wrapped'' <- C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
wrapped'
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
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererDiscovered :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererDiscoveredCallback) -> m SignalHandlerId
afterDiscovererDiscovered :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a
-> ((?self::a) => DiscovererDiscoveredCallback)
-> m SignalHandlerId
afterDiscovererDiscovered a
obj (?self::a) => 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 wrapped :: a -> DiscovererDiscoveredCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererDiscoveredCallback
DiscovererDiscoveredCallback
cb
let wrapped' :: C_DiscovererDiscoveredCallback
wrapped' = (a -> DiscovererDiscoveredCallback)
-> C_DiscovererDiscoveredCallback
forall a.
GObject a =>
(a -> DiscovererDiscoveredCallback)
-> C_DiscovererDiscoveredCallback
wrap_DiscovererDiscoveredCallback a -> DiscovererDiscoveredCallback
wrapped
FunPtr C_DiscovererDiscoveredCallback
wrapped'' <- C_DiscovererDiscoveredCallback
-> IO (FunPtr C_DiscovererDiscoveredCallback)
mk_DiscovererDiscoveredCallback C_DiscovererDiscoveredCallback
wrapped'
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
wrapped'' 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
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer::discovered"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/docs/GI-GstPbutils-Objects-Discoverer.html#g:signal:discovered"})
#endif
type DiscovererFinishedCallback =
IO ()
type C_DiscovererFinishedCallback =
Ptr Discoverer ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererFinishedCallback :: C_DiscovererFinishedCallback -> IO (FunPtr C_DiscovererFinishedCallback)
wrap_DiscovererFinishedCallback ::
GObject a => (a -> DiscovererFinishedCallback) ->
C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback :: forall a. GObject a => (a -> IO ()) -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback a -> IO ()
gi'cb Ptr Discoverer
gi'selfPtr Ptr ()
_ = do
Ptr Discoverer -> (Discoverer -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Discoverer
gi'selfPtr ((Discoverer -> IO ()) -> IO ()) -> (Discoverer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Discoverer
gi'self -> a -> IO ()
gi'cb (Discoverer -> a
Coerce.coerce Discoverer
gi'self)
onDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererFinishedCallback) -> m SignalHandlerId
onDiscovererFinished :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onDiscovererFinished a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_DiscovererFinishedCallback
wrapped' = (a -> IO ()) -> C_DiscovererFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback a -> IO ()
wrapped
FunPtr C_DiscovererFinishedCallback
wrapped'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
wrapped'
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
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererFinished :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererFinishedCallback) -> m SignalHandlerId
afterDiscovererFinished :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterDiscovererFinished a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_DiscovererFinishedCallback
wrapped' = (a -> IO ()) -> C_DiscovererFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_DiscovererFinishedCallback
wrap_DiscovererFinishedCallback a -> IO ()
wrapped
FunPtr C_DiscovererFinishedCallback
wrapped'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererFinishedCallback C_DiscovererFinishedCallback
wrapped'
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
wrapped'' 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
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer::finished"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/docs/GI-GstPbutils-Objects-Discoverer.html#g:signal:finished"})
#endif
type DiscovererSourceSetupCallback =
Gst.Element.Element
-> IO ()
type C_DiscovererSourceSetupCallback =
Ptr Discoverer ->
Ptr Gst.Element.Element ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererSourceSetupCallback :: C_DiscovererSourceSetupCallback -> IO (FunPtr C_DiscovererSourceSetupCallback)
wrap_DiscovererSourceSetupCallback ::
GObject a => (a -> DiscovererSourceSetupCallback) ->
C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback :: forall a.
GObject a =>
(a -> DiscovererSourceSetupCallback)
-> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback a -> DiscovererSourceSetupCallback
gi'cb Ptr Discoverer
gi'selfPtr 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
Ptr Discoverer -> (Discoverer -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Discoverer
gi'selfPtr ((Discoverer -> IO ()) -> IO ()) -> (Discoverer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Discoverer
gi'self -> a -> DiscovererSourceSetupCallback
gi'cb (Discoverer -> a
Coerce.coerce Discoverer
gi'self) Element
source'
onDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererSourceSetupCallback) -> m SignalHandlerId
onDiscovererSourceSetup :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a
-> ((?self::a) => DiscovererSourceSetupCallback)
-> m SignalHandlerId
onDiscovererSourceSetup a
obj (?self::a) => 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 wrapped :: a -> DiscovererSourceSetupCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererSourceSetupCallback
DiscovererSourceSetupCallback
cb
let wrapped' :: C_DiscovererSourceSetupCallback
wrapped' = (a -> DiscovererSourceSetupCallback)
-> C_DiscovererSourceSetupCallback
forall a.
GObject a =>
(a -> DiscovererSourceSetupCallback)
-> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback a -> DiscovererSourceSetupCallback
wrapped
FunPtr C_DiscovererSourceSetupCallback
wrapped'' <- C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
wrapped'
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
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererSourceSetup :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererSourceSetupCallback) -> m SignalHandlerId
afterDiscovererSourceSetup :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a
-> ((?self::a) => DiscovererSourceSetupCallback)
-> m SignalHandlerId
afterDiscovererSourceSetup a
obj (?self::a) => 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 wrapped :: a -> DiscovererSourceSetupCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererSourceSetupCallback
DiscovererSourceSetupCallback
cb
let wrapped' :: C_DiscovererSourceSetupCallback
wrapped' = (a -> DiscovererSourceSetupCallback)
-> C_DiscovererSourceSetupCallback
forall a.
GObject a =>
(a -> DiscovererSourceSetupCallback)
-> C_DiscovererSourceSetupCallback
wrap_DiscovererSourceSetupCallback a -> DiscovererSourceSetupCallback
wrapped
FunPtr C_DiscovererSourceSetupCallback
wrapped'' <- C_DiscovererSourceSetupCallback
-> IO (FunPtr C_DiscovererSourceSetupCallback)
mk_DiscovererSourceSetupCallback C_DiscovererSourceSetupCallback
wrapped'
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
wrapped'' 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
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer::source-setup"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/docs/GI-GstPbutils-Objects-Discoverer.html#g:signal:sourceSetup"})
#endif
type DiscovererStartingCallback =
IO ()
type C_DiscovererStartingCallback =
Ptr Discoverer ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DiscovererStartingCallback :: C_DiscovererStartingCallback -> IO (FunPtr C_DiscovererStartingCallback)
wrap_DiscovererStartingCallback ::
GObject a => (a -> DiscovererStartingCallback) ->
C_DiscovererStartingCallback
wrap_DiscovererStartingCallback :: forall a. GObject a => (a -> IO ()) -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback a -> IO ()
gi'cb Ptr Discoverer
gi'selfPtr Ptr ()
_ = do
Ptr Discoverer -> (Discoverer -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Discoverer
gi'selfPtr ((Discoverer -> IO ()) -> IO ()) -> (Discoverer -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Discoverer
gi'self -> a -> IO ()
gi'cb (Discoverer -> a
Coerce.coerce Discoverer
gi'self)
onDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererStartingCallback) -> m SignalHandlerId
onDiscovererStarting :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onDiscovererStarting a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_DiscovererFinishedCallback
wrapped' = (a -> IO ()) -> C_DiscovererFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback a -> IO ()
wrapped
FunPtr C_DiscovererFinishedCallback
wrapped'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
wrapped'
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
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDiscovererStarting :: (IsDiscoverer a, MonadIO m) => a -> ((?self :: a) => DiscovererStartingCallback) -> m SignalHandlerId
afterDiscovererStarting :: forall a (m :: * -> *).
(IsDiscoverer a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterDiscovererStarting a
obj (?self::a) => 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 wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
let wrapped' :: C_DiscovererFinishedCallback
wrapped' = (a -> IO ()) -> C_DiscovererFinishedCallback
forall a. GObject a => (a -> IO ()) -> C_DiscovererFinishedCallback
wrap_DiscovererStartingCallback a -> IO ()
wrapped
FunPtr C_DiscovererFinishedCallback
wrapped'' <- C_DiscovererFinishedCallback
-> IO (FunPtr C_DiscovererFinishedCallback)
mk_DiscovererStartingCallback C_DiscovererFinishedCallback
wrapped'
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
wrapped'' 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
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer::starting"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/docs/GI-GstPbutils-Objects-Discoverer.html#g:signal:starting"})
#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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer.timeout"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/docs/GI-GstPbutils-Objects-Discoverer.html#g:attr:timeout"
})
#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
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer.useCache"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/docs/GI-GstPbutils-Objects-Discoverer.html#g:attr:useCache"
})
#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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer.discovererDiscoverUri",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer.discovererDiscoverUriAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer.discovererStart",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/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 = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GstPbutils.Objects.Discoverer.discovererStop",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstpbutils-1.0.24/docs/GI-GstPbutils-Objects-Discoverer.html#v:discovererStop"
})
#endif