{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.DeviceProvider
(
DeviceProvider(..) ,
IsDeviceProvider ,
toDeviceProvider ,
#if defined(ENABLE_OVERLOADING)
ResolveDeviceProviderMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DeviceProviderCanMonitorMethodInfo ,
#endif
deviceProviderCanMonitor ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderDeviceAddMethodInfo ,
#endif
deviceProviderDeviceAdd ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderDeviceChangedMethodInfo ,
#endif
deviceProviderDeviceChanged ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderDeviceRemoveMethodInfo ,
#endif
deviceProviderDeviceRemove ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderGetBusMethodInfo ,
#endif
deviceProviderGetBus ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderGetDevicesMethodInfo ,
#endif
deviceProviderGetDevices ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderGetFactoryMethodInfo ,
#endif
deviceProviderGetFactory ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderGetHiddenProvidersMethodInfo,
#endif
deviceProviderGetHiddenProviders ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderGetMetadataMethodInfo ,
#endif
deviceProviderGetMetadata ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderHideProviderMethodInfo ,
#endif
deviceProviderHideProvider ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderIsStartedMethodInfo ,
#endif
deviceProviderIsStarted ,
deviceProviderRegister ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderStartMethodInfo ,
#endif
deviceProviderStart ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderStopMethodInfo ,
#endif
deviceProviderStop ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderUnhideProviderMethodInfo ,
#endif
deviceProviderUnhideProvider ,
DeviceProviderProviderHiddenCallback ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderProviderHiddenSignalInfo ,
#endif
afterDeviceProviderProviderHidden ,
onDeviceProviderProviderHidden ,
DeviceProviderProviderUnhiddenCallback ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderProviderUnhiddenSignalInfo,
#endif
afterDeviceProviderProviderUnhidden ,
onDeviceProviderProviderUnhidden ,
) 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 {-# SOURCE #-} qualified GI.Gst.Objects.Bus as Gst.Bus
import {-# SOURCE #-} qualified GI.Gst.Objects.Device as Gst.Device
import {-# SOURCE #-} qualified GI.Gst.Objects.DeviceProviderFactory as Gst.DeviceProviderFactory
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin
newtype DeviceProvider = DeviceProvider (SP.ManagedPtr DeviceProvider)
deriving (DeviceProvider -> DeviceProvider -> Bool
(DeviceProvider -> DeviceProvider -> Bool)
-> (DeviceProvider -> DeviceProvider -> Bool) -> Eq DeviceProvider
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceProvider -> DeviceProvider -> Bool
$c/= :: DeviceProvider -> DeviceProvider -> Bool
== :: DeviceProvider -> DeviceProvider -> Bool
$c== :: DeviceProvider -> DeviceProvider -> Bool
Eq)
instance SP.ManagedPtrNewtype DeviceProvider where
toManagedPtr :: DeviceProvider -> ManagedPtr DeviceProvider
toManagedPtr (DeviceProvider ManagedPtr DeviceProvider
p) = ManagedPtr DeviceProvider
p
foreign import ccall "gst_device_provider_get_type"
c_gst_device_provider_get_type :: IO B.Types.GType
instance B.Types.TypedObject DeviceProvider where
glibType :: IO GType
glibType = IO GType
c_gst_device_provider_get_type
instance B.Types.GObject DeviceProvider
class (SP.GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o
instance (SP.GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o
instance O.HasParentTypes DeviceProvider
type instance O.ParentTypes DeviceProvider = '[Gst.Object.Object, GObject.Object.Object]
toDeviceProvider :: (MIO.MonadIO m, IsDeviceProvider o) => o -> m DeviceProvider
toDeviceProvider :: forall (m :: * -> *) o.
(MonadIO m, IsDeviceProvider o) =>
o -> m DeviceProvider
toDeviceProvider = IO DeviceProvider -> m DeviceProvider
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DeviceProvider -> m DeviceProvider)
-> (o -> IO DeviceProvider) -> o -> m DeviceProvider
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DeviceProvider -> DeviceProvider)
-> o -> IO DeviceProvider
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DeviceProvider -> DeviceProvider
DeviceProvider
instance B.GValue.IsGValue (Maybe DeviceProvider) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_device_provider_get_type
gvalueSet_ :: Ptr GValue -> Maybe DeviceProvider -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DeviceProvider
P.Nothing = Ptr GValue -> Ptr DeviceProvider -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DeviceProvider
forall a. Ptr a
FP.nullPtr :: FP.Ptr DeviceProvider)
gvalueSet_ Ptr GValue
gv (P.Just DeviceProvider
obj) = DeviceProvider -> (Ptr DeviceProvider -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DeviceProvider
obj (Ptr GValue -> Ptr DeviceProvider -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DeviceProvider)
gvalueGet_ Ptr GValue
gv = do
Ptr DeviceProvider
ptr <- Ptr GValue -> IO (Ptr DeviceProvider)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DeviceProvider)
if Ptr DeviceProvider
ptr Ptr DeviceProvider -> Ptr DeviceProvider -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DeviceProvider
forall a. Ptr a
FP.nullPtr
then DeviceProvider -> Maybe DeviceProvider
forall a. a -> Maybe a
P.Just (DeviceProvider -> Maybe DeviceProvider)
-> IO DeviceProvider -> IO (Maybe DeviceProvider)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DeviceProvider -> DeviceProvider)
-> Ptr DeviceProvider -> IO DeviceProvider
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DeviceProvider -> DeviceProvider
DeviceProvider Ptr DeviceProvider
ptr
else Maybe DeviceProvider -> IO (Maybe DeviceProvider)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProvider
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDeviceProviderMethod (t :: Symbol) (o :: *) :: * where
ResolveDeviceProviderMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveDeviceProviderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDeviceProviderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDeviceProviderMethod "canMonitor" o = DeviceProviderCanMonitorMethodInfo
ResolveDeviceProviderMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveDeviceProviderMethod "deviceAdd" o = DeviceProviderDeviceAddMethodInfo
ResolveDeviceProviderMethod "deviceChanged" o = DeviceProviderDeviceChangedMethodInfo
ResolveDeviceProviderMethod "deviceRemove" o = DeviceProviderDeviceRemoveMethodInfo
ResolveDeviceProviderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDeviceProviderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDeviceProviderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDeviceProviderMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveDeviceProviderMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveDeviceProviderMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveDeviceProviderMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveDeviceProviderMethod "hideProvider" o = DeviceProviderHideProviderMethodInfo
ResolveDeviceProviderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDeviceProviderMethod "isStarted" o = DeviceProviderIsStartedMethodInfo
ResolveDeviceProviderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDeviceProviderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDeviceProviderMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveDeviceProviderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDeviceProviderMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveDeviceProviderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDeviceProviderMethod "start" o = DeviceProviderStartMethodInfo
ResolveDeviceProviderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDeviceProviderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDeviceProviderMethod "stop" o = DeviceProviderStopMethodInfo
ResolveDeviceProviderMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveDeviceProviderMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveDeviceProviderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDeviceProviderMethod "unhideProvider" o = DeviceProviderUnhideProviderMethodInfo
ResolveDeviceProviderMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveDeviceProviderMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveDeviceProviderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDeviceProviderMethod "getBus" o = DeviceProviderGetBusMethodInfo
ResolveDeviceProviderMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveDeviceProviderMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveDeviceProviderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDeviceProviderMethod "getDevices" o = DeviceProviderGetDevicesMethodInfo
ResolveDeviceProviderMethod "getFactory" o = DeviceProviderGetFactoryMethodInfo
ResolveDeviceProviderMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveDeviceProviderMethod "getHiddenProviders" o = DeviceProviderGetHiddenProvidersMethodInfo
ResolveDeviceProviderMethod "getMetadata" o = DeviceProviderGetMetadataMethodInfo
ResolveDeviceProviderMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveDeviceProviderMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveDeviceProviderMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveDeviceProviderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDeviceProviderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDeviceProviderMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveDeviceProviderMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveDeviceProviderMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveDeviceProviderMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveDeviceProviderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDeviceProviderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDeviceProviderMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveDeviceProviderMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveDeviceProviderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDeviceProviderMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, O.OverloadedMethod info DeviceProvider p) => OL.IsLabel t (DeviceProvider -> 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 ~ ResolveDeviceProviderMethod t DeviceProvider, O.OverloadedMethod info DeviceProvider p, R.HasField t DeviceProvider p) => R.HasField t DeviceProvider p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, O.OverloadedMethodInfo info DeviceProvider) => OL.IsLabel t (O.MethodProxy info DeviceProvider) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type DeviceProviderProviderHiddenCallback =
T.Text
-> IO ()
type C_DeviceProviderProviderHiddenCallback =
Ptr DeviceProvider ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DeviceProviderProviderHiddenCallback :: C_DeviceProviderProviderHiddenCallback -> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
wrap_DeviceProviderProviderHiddenCallback ::
GObject a => (a -> DeviceProviderProviderHiddenCallback) ->
C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback :: forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback a -> DeviceProviderProviderHiddenCallback
gi'cb Ptr DeviceProvider
gi'selfPtr CString
object Ptr ()
_ = do
Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
Ptr DeviceProvider -> (DeviceProvider -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DeviceProvider
gi'selfPtr ((DeviceProvider -> IO ()) -> IO ())
-> (DeviceProvider -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DeviceProvider
gi'self -> a -> DeviceProviderProviderHiddenCallback
gi'cb (DeviceProvider -> a
Coerce.coerce DeviceProvider
gi'self) Text
object'
onDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderHiddenCallback) -> m SignalHandlerId
onDeviceProviderProviderHidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
onDeviceProviderProviderHidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
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 -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderHiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-hidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderHiddenCallback) -> m SignalHandlerId
afterDeviceProviderProviderHidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
afterDeviceProviderProviderHidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
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 -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderHiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-hidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DeviceProviderProviderHiddenSignalInfo
instance SignalInfo DeviceProviderProviderHiddenSignalInfo where
type HaskellCallbackType DeviceProviderProviderHiddenSignalInfo = DeviceProviderProviderHiddenCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DeviceProviderProviderHiddenCallback cb
cb'' <- mk_DeviceProviderProviderHiddenCallback cb'
connectSignalFunPtr obj "provider-hidden" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider::provider-hidden"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#g:signal:providerHidden"})
#endif
type DeviceProviderProviderUnhiddenCallback =
T.Text
-> IO ()
type C_DeviceProviderProviderUnhiddenCallback =
Ptr DeviceProvider ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DeviceProviderProviderUnhiddenCallback :: C_DeviceProviderProviderUnhiddenCallback -> IO (FunPtr C_DeviceProviderProviderUnhiddenCallback)
wrap_DeviceProviderProviderUnhiddenCallback ::
GObject a => (a -> DeviceProviderProviderUnhiddenCallback) ->
C_DeviceProviderProviderUnhiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback :: forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback a -> DeviceProviderProviderHiddenCallback
gi'cb Ptr DeviceProvider
gi'selfPtr CString
object Ptr ()
_ = do
Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
Ptr DeviceProvider -> (DeviceProvider -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DeviceProvider
gi'selfPtr ((DeviceProvider -> IO ()) -> IO ())
-> (DeviceProvider -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DeviceProvider
gi'self -> a -> DeviceProviderProviderHiddenCallback
gi'cb (DeviceProvider -> a
Coerce.coerce DeviceProvider
gi'self) Text
object'
onDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderUnhiddenCallback) -> m SignalHandlerId
onDeviceProviderProviderUnhidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
onDeviceProviderProviderUnhidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
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 -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderUnhiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-unhidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderUnhiddenCallback) -> m SignalHandlerId
afterDeviceProviderProviderUnhidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
afterDeviceProviderProviderUnhidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
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 -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderUnhiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-unhidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data DeviceProviderProviderUnhiddenSignalInfo
instance SignalInfo DeviceProviderProviderUnhiddenSignalInfo where
type HaskellCallbackType DeviceProviderProviderUnhiddenSignalInfo = DeviceProviderProviderUnhiddenCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
cb'' <- mk_DeviceProviderProviderUnhiddenCallback cb'
connectSignalFunPtr obj "provider-unhidden" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider::provider-unhidden"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#g:signal:providerUnhidden"})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DeviceProvider
type instance O.AttributeList DeviceProvider = DeviceProviderAttributeList
type DeviceProviderAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DeviceProvider = DeviceProviderSignalList
type DeviceProviderSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("providerHidden", DeviceProviderProviderHiddenSignalInfo), '("providerUnhidden", DeviceProviderProviderUnhiddenSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_device_provider_can_monitor" gst_device_provider_can_monitor ::
Ptr DeviceProvider ->
IO CInt
deviceProviderCanMonitor ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m Bool
deviceProviderCanMonitor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bool
deviceProviderCanMonitor a
provider = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
CInt
result <- Ptr DeviceProvider -> IO CInt
gst_device_provider_can_monitor Ptr DeviceProvider
provider'
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
provider
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderCanMonitorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderCanMonitorMethodInfo a signature where
overloadedMethod = deviceProviderCanMonitor
instance O.OverloadedMethodInfo DeviceProviderCanMonitorMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderCanMonitor",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderCanMonitor"
})
#endif
foreign import ccall "gst_device_provider_device_add" gst_device_provider_device_add ::
Ptr DeviceProvider ->
Ptr Gst.Device.Device ->
IO ()
deviceProviderDeviceAdd ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) =>
a
-> b
-> m ()
deviceProviderDeviceAdd :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDeviceProvider a, IsDevice b) =>
a -> b -> m ()
deviceProviderDeviceAdd a
provider b
device = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
Ptr DeviceProvider -> Ptr Device -> IO ()
gst_device_provider_device_add Ptr DeviceProvider
provider' Ptr Device
device'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DeviceProviderDeviceAddMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) => O.OverloadedMethod DeviceProviderDeviceAddMethodInfo a signature where
overloadedMethod = deviceProviderDeviceAdd
instance O.OverloadedMethodInfo DeviceProviderDeviceAddMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderDeviceAdd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderDeviceAdd"
})
#endif
foreign import ccall "gst_device_provider_device_changed" gst_device_provider_device_changed ::
Ptr DeviceProvider ->
Ptr Gst.Device.Device ->
Ptr Gst.Device.Device ->
IO ()
deviceProviderDeviceChanged ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b, Gst.Device.IsDevice c) =>
a
-> b
-> c
-> m ()
deviceProviderDeviceChanged :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsDeviceProvider a, IsDevice b,
IsDevice c) =>
a -> b -> c -> m ()
deviceProviderDeviceChanged a
provider b
device c
changedDevice = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
Ptr Device
changedDevice' <- c -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
changedDevice
Ptr DeviceProvider -> Ptr Device -> Ptr Device -> IO ()
gst_device_provider_device_changed Ptr DeviceProvider
provider' Ptr Device
device' Ptr Device
changedDevice'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
changedDevice
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DeviceProviderDeviceChangedMethodInfo
instance (signature ~ (b -> c -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b, Gst.Device.IsDevice c) => O.OverloadedMethod DeviceProviderDeviceChangedMethodInfo a signature where
overloadedMethod = deviceProviderDeviceChanged
instance O.OverloadedMethodInfo DeviceProviderDeviceChangedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderDeviceChanged",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderDeviceChanged"
})
#endif
foreign import ccall "gst_device_provider_device_remove" gst_device_provider_device_remove ::
Ptr DeviceProvider ->
Ptr Gst.Device.Device ->
IO ()
deviceProviderDeviceRemove ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) =>
a
-> b
-> m ()
deviceProviderDeviceRemove :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDeviceProvider a, IsDevice b) =>
a -> b -> m ()
deviceProviderDeviceRemove a
provider b
device = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
Ptr DeviceProvider -> Ptr Device -> IO ()
gst_device_provider_device_remove Ptr DeviceProvider
provider' Ptr Device
device'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DeviceProviderDeviceRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) => O.OverloadedMethod DeviceProviderDeviceRemoveMethodInfo a signature where
overloadedMethod = deviceProviderDeviceRemove
instance O.OverloadedMethodInfo DeviceProviderDeviceRemoveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderDeviceRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderDeviceRemove"
})
#endif
foreign import ccall "gst_device_provider_get_bus" gst_device_provider_get_bus ::
Ptr DeviceProvider ->
IO (Ptr Gst.Bus.Bus)
deviceProviderGetBus ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m Gst.Bus.Bus
deviceProviderGetBus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bus
deviceProviderGetBus a
provider = IO Bus -> m Bus
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bus -> m Bus) -> IO Bus -> m Bus
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr Bus
result <- Ptr DeviceProvider -> IO (Ptr Bus)
gst_device_provider_get_bus Ptr DeviceProvider
provider'
Text -> Ptr Bus -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deviceProviderGetBus" Ptr Bus
result
Bus
result' <- ((ManagedPtr Bus -> Bus) -> Ptr Bus -> IO Bus
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Bus -> Bus
Gst.Bus.Bus) Ptr Bus
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
Bus -> IO Bus
forall (m :: * -> *) a. Monad m => a -> m a
return Bus
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetBusMethodInfo
instance (signature ~ (m Gst.Bus.Bus), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetBusMethodInfo a signature where
overloadedMethod = deviceProviderGetBus
instance O.OverloadedMethodInfo DeviceProviderGetBusMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetBus",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetBus"
})
#endif
foreign import ccall "gst_device_provider_get_devices" gst_device_provider_get_devices ::
Ptr DeviceProvider ->
IO (Ptr (GList (Ptr Gst.Device.Device)))
deviceProviderGetDevices ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m [Gst.Device.Device]
deviceProviderGetDevices :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m [Device]
deviceProviderGetDevices a
provider = IO [Device] -> m [Device]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Device] -> m [Device]) -> IO [Device] -> m [Device]
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr (GList (Ptr Device))
result <- Ptr DeviceProvider -> IO (Ptr (GList (Ptr Device)))
gst_device_provider_get_devices Ptr DeviceProvider
provider'
[Ptr Device]
result' <- Ptr (GList (Ptr Device)) -> IO [Ptr Device]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Device))
result
[Device]
result'' <- (Ptr Device -> IO Device) -> [Ptr Device] -> IO [Device]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Device -> Device
Gst.Device.Device) [Ptr Device]
result'
Ptr (GList (Ptr Device)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Device))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
[Device] -> IO [Device]
forall (m :: * -> *) a. Monad m => a -> m a
return [Device]
result''
#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetDevicesMethodInfo
instance (signature ~ (m [Gst.Device.Device]), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetDevicesMethodInfo a signature where
overloadedMethod = deviceProviderGetDevices
instance O.OverloadedMethodInfo DeviceProviderGetDevicesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetDevices",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetDevices"
})
#endif
foreign import ccall "gst_device_provider_get_factory" gst_device_provider_get_factory ::
Ptr DeviceProvider ->
IO (Ptr Gst.DeviceProviderFactory.DeviceProviderFactory)
deviceProviderGetFactory ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m (Maybe Gst.DeviceProviderFactory.DeviceProviderFactory)
deviceProviderGetFactory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m (Maybe DeviceProviderFactory)
deviceProviderGetFactory a
provider = IO (Maybe DeviceProviderFactory) -> m (Maybe DeviceProviderFactory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DeviceProviderFactory)
-> m (Maybe DeviceProviderFactory))
-> IO (Maybe DeviceProviderFactory)
-> m (Maybe DeviceProviderFactory)
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr DeviceProviderFactory
result <- Ptr DeviceProvider -> IO (Ptr DeviceProviderFactory)
gst_device_provider_get_factory Ptr DeviceProvider
provider'
Maybe DeviceProviderFactory
maybeResult <- Ptr DeviceProviderFactory
-> (Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DeviceProviderFactory
result ((Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory))
-> (Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory)
forall a b. (a -> b) -> a -> b
$ \Ptr DeviceProviderFactory
result' -> do
DeviceProviderFactory
result'' <- ((ManagedPtr DeviceProviderFactory -> DeviceProviderFactory)
-> Ptr DeviceProviderFactory -> IO DeviceProviderFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DeviceProviderFactory -> DeviceProviderFactory
Gst.DeviceProviderFactory.DeviceProviderFactory) Ptr DeviceProviderFactory
result'
DeviceProviderFactory -> IO DeviceProviderFactory
forall (m :: * -> *) a. Monad m => a -> m a
return DeviceProviderFactory
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
Maybe DeviceProviderFactory -> IO (Maybe DeviceProviderFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProviderFactory
maybeResult
#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetFactoryMethodInfo
instance (signature ~ (m (Maybe Gst.DeviceProviderFactory.DeviceProviderFactory)), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetFactoryMethodInfo a signature where
overloadedMethod = deviceProviderGetFactory
instance O.OverloadedMethodInfo DeviceProviderGetFactoryMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetFactory",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetFactory"
})
#endif
foreign import ccall "gst_device_provider_get_hidden_providers" gst_device_provider_get_hidden_providers ::
Ptr DeviceProvider ->
IO (Ptr CString)
deviceProviderGetHiddenProviders ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m [T.Text]
deviceProviderGetHiddenProviders :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m [Text]
deviceProviderGetHiddenProviders a
provider = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr CString
result <- Ptr DeviceProvider -> IO (Ptr CString)
gst_device_provider_get_hidden_providers Ptr DeviceProvider
provider'
Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deviceProviderGetHiddenProviders" Ptr CString
result
[Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
[Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetHiddenProvidersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetHiddenProvidersMethodInfo a signature where
overloadedMethod = deviceProviderGetHiddenProviders
instance O.OverloadedMethodInfo DeviceProviderGetHiddenProvidersMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetHiddenProviders",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetHiddenProviders"
})
#endif
foreign import ccall "gst_device_provider_get_metadata" gst_device_provider_get_metadata ::
Ptr DeviceProvider ->
CString ->
IO CString
deviceProviderGetMetadata ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> T.Text
-> m T.Text
deviceProviderGetMetadata :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> Text -> m Text
deviceProviderGetMetadata a
provider Text
key = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
CString
key' <- Text -> IO CString
textToCString Text
key
CString
result <- Ptr DeviceProvider -> CString -> IO CString
gst_device_provider_get_metadata Ptr DeviceProvider
provider' CString
key'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deviceProviderGetMetadata" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetMetadataMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetMetadataMethodInfo a signature where
overloadedMethod = deviceProviderGetMetadata
instance O.OverloadedMethodInfo DeviceProviderGetMetadataMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetMetadata",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetMetadata"
})
#endif
foreign import ccall "gst_device_provider_hide_provider" gst_device_provider_hide_provider ::
Ptr DeviceProvider ->
CString ->
IO ()
deviceProviderHideProvider ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> T.Text
-> m ()
deviceProviderHideProvider :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> Text -> m ()
deviceProviderHideProvider a
provider Text
name = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr DeviceProvider -> CString -> IO ()
gst_device_provider_hide_provider Ptr DeviceProvider
provider' CString
name'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DeviceProviderHideProviderMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderHideProviderMethodInfo a signature where
overloadedMethod = deviceProviderHideProvider
instance O.OverloadedMethodInfo DeviceProviderHideProviderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderHideProvider",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderHideProvider"
})
#endif
foreign import ccall "gst_device_provider_is_started" gst_device_provider_is_started ::
Ptr DeviceProvider ->
IO CInt
deviceProviderIsStarted ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m Bool
deviceProviderIsStarted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bool
deviceProviderIsStarted a
provider = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
CInt
result <- Ptr DeviceProvider -> IO CInt
gst_device_provider_is_started Ptr DeviceProvider
provider'
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
provider
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderIsStartedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderIsStartedMethodInfo a signature where
overloadedMethod = deviceProviderIsStarted
instance O.OverloadedMethodInfo DeviceProviderIsStartedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderIsStarted",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderIsStarted"
})
#endif
foreign import ccall "gst_device_provider_start" gst_device_provider_start ::
Ptr DeviceProvider ->
IO CInt
deviceProviderStart ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m Bool
deviceProviderStart :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bool
deviceProviderStart a
provider = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
CInt
result <- Ptr DeviceProvider -> IO CInt
gst_device_provider_start Ptr DeviceProvider
provider'
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
provider
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderStartMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderStartMethodInfo a signature where
overloadedMethod = deviceProviderStart
instance O.OverloadedMethodInfo DeviceProviderStartMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderStart",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderStart"
})
#endif
foreign import ccall "gst_device_provider_stop" gst_device_provider_stop ::
Ptr DeviceProvider ->
IO ()
deviceProviderStop ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> m ()
deviceProviderStop :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m ()
deviceProviderStop a
provider = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
Ptr DeviceProvider -> IO ()
gst_device_provider_stop Ptr DeviceProvider
provider'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DeviceProviderStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderStopMethodInfo a signature where
overloadedMethod = deviceProviderStop
instance O.OverloadedMethodInfo DeviceProviderStopMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderStop",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderStop"
})
#endif
foreign import ccall "gst_device_provider_unhide_provider" gst_device_provider_unhide_provider ::
Ptr DeviceProvider ->
CString ->
IO ()
deviceProviderUnhideProvider ::
(B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
a
-> T.Text
-> m ()
deviceProviderUnhideProvider :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> Text -> m ()
deviceProviderUnhideProvider a
provider Text
name = 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 DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr DeviceProvider -> CString -> IO ()
gst_device_provider_unhide_provider Ptr DeviceProvider
provider' CString
name'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DeviceProviderUnhideProviderMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderUnhideProviderMethodInfo a signature where
overloadedMethod = deviceProviderUnhideProvider
instance O.OverloadedMethodInfo DeviceProviderUnhideProviderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderUnhideProvider",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderUnhideProvider"
})
#endif
foreign import ccall "gst_device_provider_register" gst_device_provider_register ::
Ptr Gst.Plugin.Plugin ->
CString ->
Word32 ->
CGType ->
IO CInt
deviceProviderRegister ::
(B.CallStack.HasCallStack, MonadIO m, Gst.Plugin.IsPlugin a) =>
Maybe (a)
-> T.Text
-> Word32
-> GType
-> m Bool
deviceProviderRegister :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
Maybe a -> Text -> Word32 -> GType -> m Bool
deviceProviderRegister Maybe a
plugin Text
name Word32
rank GType
type_ = 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 Plugin
maybePlugin <- case Maybe a
plugin of
Maybe a
Nothing -> Ptr Plugin -> IO (Ptr Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Plugin
forall a. Ptr a
nullPtr
Just a
jPlugin -> do
Ptr Plugin
jPlugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jPlugin
Ptr Plugin -> IO (Ptr Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Plugin
jPlugin'
CString
name' <- Text -> IO CString
textToCString Text
name
let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
CInt
result <- Ptr Plugin -> CString -> Word32 -> CGType -> IO CInt
gst_device_provider_register Ptr Plugin
maybePlugin CString
name' Word32
rank CGType
type_'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
plugin a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif