{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Gst.Objects.DeviceProvider.DeviceProvider' subclass is provided by a plugin that handles devices
-- if there is a way to programmatically list connected devices. It can also
-- optionally provide updates to the list of connected devices.
-- 
-- Each t'GI.Gst.Objects.DeviceProvider.DeviceProvider' subclass is a singleton, a plugin should
-- normally provide a single subclass for all devices.
-- 
-- Applications would normally use a t'GI.Gst.Objects.DeviceMonitor.DeviceMonitor' to monitor devices
-- from all relevant providers.
-- 
-- /Since: 1.4/

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gst.Objects.DeviceProvider
    ( 

-- * Exported types
    DeviceProvider(..)                      ,
    IsDeviceProvider                        ,
    toDeviceProvider                        ,
    noDeviceProvider                        ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveDeviceProviderMethod             ,
#endif


-- ** canMonitor #method:canMonitor#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderCanMonitorMethodInfo      ,
#endif
    deviceProviderCanMonitor                ,


-- ** deviceAdd #method:deviceAdd#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderDeviceAddMethodInfo       ,
#endif
    deviceProviderDeviceAdd                 ,


-- ** deviceChanged #method:deviceChanged#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderDeviceChangedMethodInfo   ,
#endif
    deviceProviderDeviceChanged             ,


-- ** deviceRemove #method:deviceRemove#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderDeviceRemoveMethodInfo    ,
#endif
    deviceProviderDeviceRemove              ,


-- ** getBus #method:getBus#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderGetBusMethodInfo          ,
#endif
    deviceProviderGetBus                    ,


-- ** getDevices #method:getDevices#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderGetDevicesMethodInfo      ,
#endif
    deviceProviderGetDevices                ,


-- ** getFactory #method:getFactory#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderGetFactoryMethodInfo      ,
#endif
    deviceProviderGetFactory                ,


-- ** getHiddenProviders #method:getHiddenProviders#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderGetHiddenProvidersMethodInfo,
#endif
    deviceProviderGetHiddenProviders        ,


-- ** getMetadata #method:getMetadata#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderGetMetadataMethodInfo     ,
#endif
    deviceProviderGetMetadata               ,


-- ** hideProvider #method:hideProvider#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderHideProviderMethodInfo    ,
#endif
    deviceProviderHideProvider              ,


-- ** register #method:register#

    deviceProviderRegister                  ,


-- ** start #method:start#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderStartMethodInfo           ,
#endif
    deviceProviderStart                     ,


-- ** stop #method:stop#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderStopMethodInfo            ,
#endif
    deviceProviderStop                      ,


-- ** unhideProvider #method:unhideProvider#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderUnhideProviderMethodInfo  ,
#endif
    deviceProviderUnhideProvider            ,




 -- * Signals
-- ** providerHidden #signal:providerHidden#

    C_DeviceProviderProviderHiddenCallback  ,
    DeviceProviderProviderHiddenCallback    ,
#if defined(ENABLE_OVERLOADING)
    DeviceProviderProviderHiddenSignalInfo  ,
#endif
    afterDeviceProviderProviderHidden       ,
    genClosure_DeviceProviderProviderHidden ,
    mk_DeviceProviderProviderHiddenCallback ,
    noDeviceProviderProviderHiddenCallback  ,
    onDeviceProviderProviderHidden          ,
    wrap_DeviceProviderProviderHiddenCallback,


-- ** providerUnhidden #signal:providerUnhidden#

    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

-- | Memory-managed wrapper type.
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
    

-- | Convert 'DeviceProvider' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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
        
    

-- | Type class for types which can be safely cast to `DeviceProvider`, for instance with `toDeviceProvider`.
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]

-- | Cast to `DeviceProvider`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- | A convenience alias for `Nothing` :: `Maybe` `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

-- signal DeviceProvider::provider-hidden
-- | /No description available in the introspection data./
type DeviceProviderProviderHiddenCallback =
    T.Text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DeviceProviderProviderHiddenCallback`@.
noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderHiddenCallback = Maybe DeviceProviderProviderHiddenCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DeviceProviderProviderHiddenCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DeviceProviderProviderHiddenCallback`.
foreign import ccall "wrapper"
    mk_DeviceProviderProviderHiddenCallback :: C_DeviceProviderProviderHiddenCallback -> IO (FunPtr C_DeviceProviderProviderHiddenCallback)

-- | Wrap the callback into a `GClosure`.
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 a `DeviceProviderProviderHiddenCallback` into a `C_DeviceProviderProviderHiddenCallback`.
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'


-- | Connect a signal handler for the [providerHidden](#signal:providerHidden) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' deviceProvider #providerHidden callback
-- @
-- 
-- 
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

-- | Connect a signal handler for the [providerHidden](#signal:providerHidden) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' deviceProvider #providerHidden callback
-- @
-- 
-- 
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

-- signal DeviceProvider::provider-unhidden
-- | /No description available in the introspection data./
type DeviceProviderProviderUnhiddenCallback =
    T.Text
    -> IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `DeviceProviderProviderUnhiddenCallback`@.
noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderUnhiddenCallback
noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
noDeviceProviderProviderUnhiddenCallback = Maybe DeviceProviderProviderHiddenCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_DeviceProviderProviderUnhiddenCallback =
    Ptr () ->                               -- object
    CString ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_DeviceProviderProviderUnhiddenCallback`.
foreign import ccall "wrapper"
    mk_DeviceProviderProviderUnhiddenCallback :: C_DeviceProviderProviderUnhiddenCallback -> IO (FunPtr C_DeviceProviderProviderUnhiddenCallback)

-- | Wrap the callback into a `GClosure`.
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 a `DeviceProviderProviderUnhiddenCallback` into a `C_DeviceProviderProviderUnhiddenCallback`.
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'


-- | Connect a signal handler for the [providerUnhidden](#signal:providerUnhidden) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' deviceProvider #providerUnhidden callback
-- @
-- 
-- 
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

-- | Connect a signal handler for the [providerUnhidden](#signal:providerUnhidden) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' deviceProvider #providerUnhidden callback
-- @
-- 
-- 
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

-- method DeviceProvider::can_monitor
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_can_monitor" gst_device_provider_can_monitor :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO CInt

-- | /No description available in the introspection data./
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

-- method DeviceProvider::device_add
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "device"
--           , argType = TInterface Name { namespace = "Gst" , name = "Device" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDevice that has been added"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_device_add" gst_device_provider_device_add :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    Ptr Gst.Device.Device ->                -- device : TInterface (Name {namespace = "Gst", name = "Device"})
    IO ()

-- | Posts a message on the provider\'s t'GI.Gst.Objects.Bus.Bus' to inform applications that
-- a new device has been added.
-- 
-- This is for use by subclasses.
-- 
-- /@device@/\'s reference count will be incremented, and any floating reference
-- will be removed (see @/gst_object_ref_sink()/@).
-- 
-- /Since: 1.4/
deviceProviderDeviceAdd ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> b
    -- ^ /@device@/: a t'GI.Gst.Objects.Device.Device' that has been added
    -> 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

-- method DeviceProvider::device_changed
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "device"
--           , argType = TInterface Name { namespace = "Gst" , name = "Device" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new version of @changed_device"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "changed_device"
--           , argType = TInterface Name { namespace = "Gst" , name = "Device" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the old version of the device that has been udpated"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_device_changed" gst_device_provider_device_changed :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    Ptr Gst.Device.Device ->                -- device : TInterface (Name {namespace = "Gst", name = "Device"})
    Ptr Gst.Device.Device ->                -- changed_device : TInterface (Name {namespace = "Gst", name = "Device"})
    IO ()

-- | This function is used when /@changedDevice@/ was modified into its new form
-- /@device@/. This will post a @DEVICE_CHANGED@ message on the bus to let
-- the application know that the device was modified. t'GI.Gst.Objects.Device.Device' is immutable
-- for MT. safety purposes so this is an \"atomic\" way of letting the application
-- know when a device was modified.
-- 
-- /Since: 1.16/
deviceProviderDeviceChanged ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b, Gst.Device.IsDevice c) =>
    a
    -> b
    -- ^ /@device@/: the new version of /@changedDevice@/
    -> c
    -- ^ /@changedDevice@/: the old version of the device that has been udpated
    -> 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

-- method DeviceProvider::device_remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "device"
--           , argType = TInterface Name { namespace = "Gst" , name = "Device" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDevice that has been removed"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_device_remove" gst_device_provider_device_remove :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    Ptr Gst.Device.Device ->                -- device : TInterface (Name {namespace = "Gst", name = "Device"})
    IO ()

-- | Posts a message on the provider\'s t'GI.Gst.Objects.Bus.Bus' to inform applications that
-- a device has been removed.
-- 
-- This is for use by subclasses.
-- 
-- /Since: 1.4/
deviceProviderDeviceRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> b
    -- ^ /@device@/: a t'GI.Gst.Objects.Device.Device' that has been removed
    -> 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

-- method DeviceProvider::get_bus
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Bus" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_bus" gst_device_provider_get_bus :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr Gst.Bus.Bus)

-- | Gets the t'GI.Gst.Objects.Bus.Bus' of this t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
-- 
-- /Since: 1.4/
deviceProviderGetBus ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> m Gst.Bus.Bus
    -- ^ __Returns:__ a t'GI.Gst.Objects.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

-- method DeviceProvider::get_devices
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList (TInterface Name { namespace = "Gst" , name = "Device" }))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_devices" gst_device_provider_get_devices :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr (GList (Ptr Gst.Device.Device)))

-- | Gets a list of devices that this provider understands. This may actually
-- probe the hardware if the provider is not currently started.
-- 
-- /Since: 1.4/
deviceProviderGetDevices ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: A t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> m [Gst.Device.Device]
    -- ^ __Returns:__ a t'GI.GLib.Structs.List.List' of
    --   t'GI.Gst.Objects.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

-- method DeviceProvider::get_factory
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GstDeviceProvider to request the device provider factory of."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gst" , name = "DeviceProviderFactory" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_factory" gst_device_provider_get_factory :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr Gst.DeviceProviderFactory.DeviceProviderFactory)

-- | Retrieves the factory that was used to create this device provider.
-- 
-- /Since: 1.4/
deviceProviderGetFactory ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider' to request the device provider factory of.
    -> m Gst.DeviceProviderFactory.DeviceProviderFactory
    -- ^ __Returns:__ the t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' used for
    --     creating this device provider. no refcounting is needed.
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

-- method DeviceProvider::get_hidden_providers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_hidden_providers" gst_device_provider_get_hidden_providers :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO (Ptr CString)

-- | Get the provider factory names of the t'GI.Gst.Objects.DeviceProvider.DeviceProvider' instances that
-- are hidden by /@provider@/.
-- 
-- /Since: 1.6/
deviceProviderGetHiddenProviders ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> m [T.Text]
    -- ^ __Returns:__ 
    --   a list of hidden providers factory names or 'P.Nothing' when
    --   nothing is hidden by /@provider@/. Free with g_strfreev.
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

-- method DeviceProvider::get_metadata
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "provider to get metadata for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "key"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the key to get" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_get_metadata" gst_device_provider_get_metadata :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    CString ->                              -- key : TBasicType TUTF8
    IO CString

-- | Get metadata with /@key@/ in /@provider@/.
-- 
-- /Since: 1.14/
deviceProviderGetMetadata ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: provider to get metadata for
    -> T.Text
    -- ^ /@key@/: the key to get
    -> m T.Text
    -- ^ __Returns:__ the metadata for /@key@/.
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

-- method DeviceProvider::hide_provider
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a provider factory name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_hide_provider" gst_device_provider_hide_provider :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Make /@provider@/ hide the devices from the factory with /@name@/.
-- 
-- This function is used when /@provider@/ will also provide the devices reported
-- by provider factory /@name@/. A monitor should stop monitoring the
-- device provider with /@name@/ to avoid duplicate devices.
-- 
-- /Since: 1.6/
deviceProviderHideProvider ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> T.Text
    -- ^ /@name@/: a provider factory name
    -> 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

-- method DeviceProvider::start
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_start" gst_device_provider_start :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO CInt

-- | Starts providering the devices. This will cause @/GST_MESSAGE_DEVICE_ADDED/@
-- and @/GST_MESSAGE_DEVICE_REMOVED/@ messages to be posted on the provider\'s bus
-- when devices are added or removed from the system.
-- 
-- Since the t'GI.Gst.Objects.DeviceProvider.DeviceProvider' is a singleton,
-- 'GI.Gst.Objects.DeviceProvider.deviceProviderStart' may already have been called by another
-- user of the object, 'GI.Gst.Objects.DeviceProvider.deviceProviderStop' needs to be called the same
-- number of times.
-- 
-- /Since: 1.4/
deviceProviderStart ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: A t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the device providering could be started
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

-- method DeviceProvider::stop
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_stop" gst_device_provider_stop :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO ()

-- | Decreases the use-count by one. If the use count reaches zero, this
-- t'GI.Gst.Objects.DeviceProvider.DeviceProvider' will stop providering the devices. This needs to be
-- called the same number of times that 'GI.Gst.Objects.DeviceProvider.deviceProviderStart' was called.
-- 
-- /Since: 1.4/
deviceProviderStop ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: A t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> 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

-- method DeviceProvider::unhide_provider
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "provider"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "DeviceProvider" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstDeviceProvider"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a provider factory name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_unhide_provider" gst_device_provider_unhide_provider :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Make /@provider@/ unhide the devices from factory /@name@/.
-- 
-- This function is used when /@provider@/ will no longer provide the devices
-- reported by provider factory /@name@/. A monitor should start
-- monitoring the devices from provider factory /@name@/ in order to see
-- all devices again.
-- 
-- /Since: 1.6/
deviceProviderUnhideProvider ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> T.Text
    -- ^ /@name@/: a provider factory name
    -> 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

-- method DeviceProvider::register
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "plugin"
--           , argType = TInterface Name { namespace = "Gst" , name = "Plugin" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "#GstPlugin to register the device provider with, or %NULL for\n    a static device provider."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "name of device providers of this type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "rank"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "rank of device provider (higher rank means more importance when autoplugging)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "type"
--           , argType = TBasicType TGType
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "GType of device provider to register"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_device_provider_register" gst_device_provider_register :: 
    Ptr Gst.Plugin.Plugin ->                -- plugin : TInterface (Name {namespace = "Gst", name = "Plugin"})
    CString ->                              -- name : TBasicType TUTF8
    Word32 ->                               -- rank : TBasicType TUInt
    CGType ->                               -- type : TBasicType TGType
    IO CInt

-- | Create a new device providerfactory capable of instantiating objects of the
-- /@type@/ and add the factory to /@plugin@/.
-- 
-- /Since: 1.4/
deviceProviderRegister ::
    (B.CallStack.HasCallStack, MonadIO m, Gst.Plugin.IsPlugin a) =>
    Maybe (a)
    -- ^ /@plugin@/: t'GI.Gst.Objects.Plugin.Plugin' to register the device provider with, or 'P.Nothing' for
    --     a static device provider.
    -> T.Text
    -- ^ /@name@/: name of device providers of this type
    -> Word32
    -- ^ /@rank@/: rank of device provider (higher rank means more importance when autoplugging)
    -> GType
    -- ^ /@type@/: GType of device provider to register
    -> m Bool
    -- ^ __Returns:__ 'P.True', if the registering succeeded, 'P.False' on error
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