{-# LANGUAGE 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 ,
noDeviceProvider ,
#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 ,
deviceProviderRegister ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderStartMethodInfo ,
#endif
deviceProviderStart ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderStopMethodInfo ,
#endif
deviceProviderStop ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderUnhideProviderMethodInfo ,
#endif
deviceProviderUnhideProvider ,
C_DeviceProviderProviderHiddenCallback ,
DeviceProviderProviderHiddenCallback ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderProviderHiddenSignalInfo ,
#endif
afterDeviceProviderProviderHidden ,
genClosure_DeviceProviderProviderHidden ,
mk_DeviceProviderProviderHiddenCallback ,
noDeviceProviderProviderHiddenCallback ,
onDeviceProviderProviderHidden ,
wrap_DeviceProviderProviderHiddenCallback,
C_DeviceProviderProviderUnhiddenCallback,
DeviceProviderProviderUnhiddenCallback ,
#if defined(ENABLE_OVERLOADING)
DeviceProviderProviderUnhiddenSignalInfo,
#endif
afterDeviceProviderProviderUnhidden ,
genClosure_DeviceProviderProviderUnhidden,
mk_DeviceProviderProviderUnhiddenCallback,
noDeviceProviderProviderUnhiddenCallback,
onDeviceProviderProviderUnhidden ,
wrap_DeviceProviderProviderUnhiddenCallback,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.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 (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)
foreign import ccall "gst_device_provider_get_type"
c_gst_device_provider_get_type :: IO GType
instance GObject DeviceProvider where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_device_provider_get_type
instance B.GValue.IsGValue DeviceProvider where
toGValue :: DeviceProvider -> IO GValue
toGValue o :: DeviceProvider
o = do
GType
gtype <- IO GType
c_gst_device_provider_get_type
DeviceProvider -> (Ptr DeviceProvider -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DeviceProvider
o (GType
-> (GValue -> Ptr DeviceProvider -> IO ())
-> Ptr DeviceProvider
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr DeviceProvider -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO DeviceProvider
fromGValue gv :: GValue
gv = do
Ptr DeviceProvider
ptr <- GValue -> IO (Ptr DeviceProvider)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr DeviceProvider)
(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
class (GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o
instance (GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o
instance O.HasParentTypes DeviceProvider
type instance O.ParentTypes DeviceProvider = '[Gst.Object.Object, GObject.Object.Object]
toDeviceProvider :: (MonadIO m, IsDeviceProvider o) => o -> m DeviceProvider
toDeviceProvider :: o -> m DeviceProvider
toDeviceProvider = IO DeviceProvider -> m DeviceProvider
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr DeviceProvider -> DeviceProvider
DeviceProvider
noDeviceProvider :: Maybe DeviceProvider
noDeviceProvider :: Maybe DeviceProvider
noDeviceProvider = Maybe DeviceProvider
forall a. Maybe a
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 "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.MethodInfo 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
#endif
type DeviceProviderProviderHiddenCallback =
T.Text
-> IO ()
noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderHiddenCallback = Maybe DeviceProviderProviderHiddenCallback
forall a. Maybe a
Nothing
type C_DeviceProviderProviderHiddenCallback =
Ptr () ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DeviceProviderProviderHiddenCallback :: C_DeviceProviderProviderHiddenCallback -> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
genClosure_DeviceProviderProviderHidden :: MonadIO m => DeviceProviderProviderHiddenCallback -> m (GClosure C_DeviceProviderProviderHiddenCallback)
genClosure_DeviceProviderProviderHidden :: DeviceProviderProviderHiddenCallback
-> m (GClosure C_DeviceProviderProviderHiddenCallback)
genClosure_DeviceProviderProviderHidden cb :: DeviceProviderProviderHiddenCallback
cb = IO (GClosure C_DeviceProviderProviderHiddenCallback)
-> m (GClosure C_DeviceProviderProviderHiddenCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DeviceProviderProviderHiddenCallback)
-> m (GClosure C_DeviceProviderProviderHiddenCallback))
-> IO (GClosure C_DeviceProviderProviderHiddenCallback)
-> m (GClosure C_DeviceProviderProviderHiddenCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DeviceProviderProviderHiddenCallback
cb' = DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback DeviceProviderProviderHiddenCallback
cb
C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderHiddenCallback C_DeviceProviderProviderHiddenCallback
cb' IO (FunPtr C_DeviceProviderProviderHiddenCallback)
-> (FunPtr C_DeviceProviderProviderHiddenCallback
-> IO (GClosure C_DeviceProviderProviderHiddenCallback))
-> IO (GClosure C_DeviceProviderProviderHiddenCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DeviceProviderProviderHiddenCallback
-> IO (GClosure C_DeviceProviderProviderHiddenCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DeviceProviderProviderHiddenCallback ::
DeviceProviderProviderHiddenCallback ->
C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback :: DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback _cb :: DeviceProviderProviderHiddenCallback
_cb _ object :: CString
object _ = do
Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
DeviceProviderProviderHiddenCallback
_cb Text
object'
onDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
onDeviceProviderProviderHidden :: a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
onDeviceProviderProviderHidden obj :: a
obj cb :: 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 cb' :: C_DeviceProviderProviderHiddenCallback
cb' = DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback DeviceProviderProviderHiddenCallback
cb
FunPtr C_DeviceProviderProviderHiddenCallback
cb'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderHiddenCallback C_DeviceProviderProviderHiddenCallback
cb'
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 "provider-hidden" FunPtr C_DeviceProviderProviderHiddenCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderHidden :: a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderHidden obj :: a
obj cb :: 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 cb' :: C_DeviceProviderProviderHiddenCallback
cb' = DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback DeviceProviderProviderHiddenCallback
cb
FunPtr C_DeviceProviderProviderHiddenCallback
cb'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderHiddenCallback C_DeviceProviderProviderHiddenCallback
cb'
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 "provider-hidden" FunPtr C_DeviceProviderProviderHiddenCallback
cb'' 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
#endif
type DeviceProviderProviderUnhiddenCallback =
T.Text
-> IO ()
noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderUnhiddenCallback
noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderUnhiddenCallback = Maybe DeviceProviderProviderHiddenCallback
forall a. Maybe a
Nothing
type C_DeviceProviderProviderUnhiddenCallback =
Ptr () ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_DeviceProviderProviderUnhiddenCallback :: C_DeviceProviderProviderUnhiddenCallback -> IO (FunPtr C_DeviceProviderProviderUnhiddenCallback)
genClosure_DeviceProviderProviderUnhidden :: MonadIO m => DeviceProviderProviderUnhiddenCallback -> m (GClosure C_DeviceProviderProviderUnhiddenCallback)
genClosure_DeviceProviderProviderUnhidden :: DeviceProviderProviderHiddenCallback
-> m (GClosure C_DeviceProviderProviderHiddenCallback)
genClosure_DeviceProviderProviderUnhidden cb :: DeviceProviderProviderHiddenCallback
cb = IO (GClosure C_DeviceProviderProviderHiddenCallback)
-> m (GClosure C_DeviceProviderProviderHiddenCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_DeviceProviderProviderHiddenCallback)
-> m (GClosure C_DeviceProviderProviderHiddenCallback))
-> IO (GClosure C_DeviceProviderProviderHiddenCallback)
-> m (GClosure C_DeviceProviderProviderHiddenCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_DeviceProviderProviderHiddenCallback
cb' = DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback DeviceProviderProviderHiddenCallback
cb
C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderUnhiddenCallback C_DeviceProviderProviderHiddenCallback
cb' IO (FunPtr C_DeviceProviderProviderHiddenCallback)
-> (FunPtr C_DeviceProviderProviderHiddenCallback
-> IO (GClosure C_DeviceProviderProviderHiddenCallback))
-> IO (GClosure C_DeviceProviderProviderHiddenCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_DeviceProviderProviderHiddenCallback
-> IO (GClosure C_DeviceProviderProviderHiddenCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_DeviceProviderProviderUnhiddenCallback ::
DeviceProviderProviderUnhiddenCallback ->
C_DeviceProviderProviderUnhiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback :: DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback _cb :: DeviceProviderProviderHiddenCallback
_cb _ object :: CString
object _ = do
Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
DeviceProviderProviderHiddenCallback
_cb Text
object'
onDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
onDeviceProviderProviderUnhidden :: a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
onDeviceProviderProviderUnhidden obj :: a
obj cb :: 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 cb' :: C_DeviceProviderProviderHiddenCallback
cb' = DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback DeviceProviderProviderHiddenCallback
cb
FunPtr C_DeviceProviderProviderHiddenCallback
cb'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderUnhiddenCallback C_DeviceProviderProviderHiddenCallback
cb'
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 "provider-unhidden" FunPtr C_DeviceProviderProviderHiddenCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderUnhidden :: a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
afterDeviceProviderProviderUnhidden obj :: a
obj cb :: 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 cb' :: C_DeviceProviderProviderHiddenCallback
cb' = DeviceProviderProviderHiddenCallback
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback DeviceProviderProviderHiddenCallback
cb
FunPtr C_DeviceProviderProviderHiddenCallback
cb'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderUnhiddenCallback C_DeviceProviderProviderHiddenCallback
cb'
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 "provider-unhidden" FunPtr C_DeviceProviderProviderHiddenCallback
cb'' 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
#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 :: a -> m Bool
deviceProviderCanMonitor provider :: 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
/= 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.MethodInfo DeviceProviderCanMonitorMethodInfo a signature where
overloadedMethod = 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 :: a -> b -> m ()
deviceProviderDeviceAdd provider :: a
provider device :: 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.MethodInfo DeviceProviderDeviceAddMethodInfo a signature where
overloadedMethod = 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 :: a -> b -> c -> m ()
deviceProviderDeviceChanged provider :: a
provider device :: b
device changedDevice :: 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.MethodInfo DeviceProviderDeviceChangedMethodInfo a signature where
overloadedMethod = 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 :: a -> b -> m ()
deviceProviderDeviceRemove provider :: a
provider device :: 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.MethodInfo DeviceProviderDeviceRemoveMethodInfo a signature where
overloadedMethod = 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 :: a -> m Bus
deviceProviderGetBus provider :: 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 "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.MethodInfo DeviceProviderGetBusMethodInfo a signature where
overloadedMethod = 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 :: a -> m [Device]
deviceProviderGetDevices provider :: 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.MethodInfo DeviceProviderGetDevicesMethodInfo a signature where
overloadedMethod = 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 Gst.DeviceProviderFactory.DeviceProviderFactory
deviceProviderGetFactory :: a -> m DeviceProviderFactory
deviceProviderGetFactory provider :: a
provider = IO DeviceProviderFactory -> m DeviceProviderFactory
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DeviceProviderFactory -> m DeviceProviderFactory)
-> IO DeviceProviderFactory -> m 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'
Text -> Ptr DeviceProviderFactory -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "deviceProviderGetFactory" Ptr DeviceProviderFactory
result
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
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
DeviceProviderFactory -> IO DeviceProviderFactory
forall (m :: * -> *) a. Monad m => a -> m a
return DeviceProviderFactory
result'
#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetFactoryMethodInfo
instance (signature ~ (m Gst.DeviceProviderFactory.DeviceProviderFactory), MonadIO m, IsDeviceProvider a) => O.MethodInfo DeviceProviderGetFactoryMethodInfo a signature where
overloadedMethod = 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 :: a -> m [Text]
deviceProviderGetHiddenProviders provider :: 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 "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.MethodInfo DeviceProviderGetHiddenProvidersMethodInfo a signature where
overloadedMethod = 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 :: a -> Text -> m Text
deviceProviderGetMetadata provider :: a
provider key :: 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 "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.MethodInfo DeviceProviderGetMetadataMethodInfo a signature where
overloadedMethod = 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 :: a -> Text -> m ()
deviceProviderHideProvider provider :: a
provider name :: 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.MethodInfo DeviceProviderHideProviderMethodInfo a signature where
overloadedMethod = deviceProviderHideProvider
#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 :: a -> m Bool
deviceProviderStart provider :: 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
/= 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.MethodInfo DeviceProviderStartMethodInfo a signature where
overloadedMethod = 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 :: a -> m ()
deviceProviderStop provider :: 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.MethodInfo DeviceProviderStopMethodInfo a signature where
overloadedMethod = 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 :: a -> Text -> m ()
deviceProviderUnhideProvider provider :: a
provider name :: 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.MethodInfo DeviceProviderUnhideProviderMethodInfo a signature where
overloadedMethod = 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 :: Maybe a -> Text -> Word32 -> GType -> m Bool
deviceProviderRegister plugin :: Maybe a
plugin name :: Text
name rank :: Word32
rank type_ :: 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
Nothing -> Ptr Plugin -> IO (Ptr Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Plugin
forall a. Ptr a
nullPtr
Just jPlugin :: 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
/= 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