{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addControlBinding]("GI.Gst.Objects.Object#g:method:addControlBinding"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [canMonitor]("GI.Gst.Objects.DeviceProvider#g:method:canMonitor"), [defaultError]("GI.Gst.Objects.Object#g:method:defaultError"), [deviceAdd]("GI.Gst.Objects.DeviceProvider#g:method:deviceAdd"), [deviceChanged]("GI.Gst.Objects.DeviceProvider#g:method:deviceChanged"), [deviceRemove]("GI.Gst.Objects.DeviceProvider#g:method:deviceRemove"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasActiveControlBindings]("GI.Gst.Objects.Object#g:method:hasActiveControlBindings"), [hasAncestor]("GI.Gst.Objects.Object#g:method:hasAncestor"), [hasAsAncestor]("GI.Gst.Objects.Object#g:method:hasAsAncestor"), [hasAsParent]("GI.Gst.Objects.Object#g:method:hasAsParent"), [hideProvider]("GI.Gst.Objects.DeviceProvider#g:method:hideProvider"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isStarted]("GI.Gst.Objects.DeviceProvider#g:method:isStarted"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.Gst.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeControlBinding]("GI.Gst.Objects.Object#g:method:removeControlBinding"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [start]("GI.Gst.Objects.DeviceProvider#g:method:start"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [stop]("GI.Gst.Objects.DeviceProvider#g:method:stop"), [suggestNextSync]("GI.Gst.Objects.Object#g:method:suggestNextSync"), [syncValues]("GI.Gst.Objects.Object#g:method:syncValues"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unhideProvider]("GI.Gst.Objects.DeviceProvider#g:method:unhideProvider"), [unparent]("GI.Gst.Objects.Object#g:method:unparent"), [unref]("GI.Gst.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBus]("GI.Gst.Objects.DeviceProvider#g:method:getBus"), [getControlBinding]("GI.Gst.Objects.Object#g:method:getControlBinding"), [getControlRate]("GI.Gst.Objects.Object#g:method:getControlRate"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDevices]("GI.Gst.Objects.DeviceProvider#g:method:getDevices"), [getFactory]("GI.Gst.Objects.DeviceProvider#g:method:getFactory"), [getGValueArray]("GI.Gst.Objects.Object#g:method:getGValueArray"), [getHiddenProviders]("GI.Gst.Objects.DeviceProvider#g:method:getHiddenProviders"), [getMetadata]("GI.Gst.Objects.DeviceProvider#g:method:getMetadata"), [getName]("GI.Gst.Objects.Object#g:method:getName"), [getParent]("GI.Gst.Objects.Object#g:method:getParent"), [getPathString]("GI.Gst.Objects.Object#g:method:getPathString"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getValue]("GI.Gst.Objects.Object#g:method:getValue").
-- 
-- ==== Setters
-- [setControlBindingDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingDisabled"), [setControlBindingsDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingsDisabled"), [setControlRate]("GI.Gst.Objects.Object#g:method:setControlRate"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setName]("GI.Gst.Objects.Object#g:method:setName"), [setParent]("GI.Gst.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#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              ,


-- ** isStarted #method:isStarted#

#if defined(ENABLE_OVERLOADING)
    DeviceProviderIsStartedMethodInfo       ,
#endif
    deviceProviderIsStarted                 ,


-- ** 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#

    DeviceProviderProviderHiddenCallback    ,
#if defined(ENABLE_OVERLOADING)
    DeviceProviderProviderHiddenSignalInfo  ,
#endif
    afterDeviceProviderProviderHidden       ,
    onDeviceProviderProviderHidden          ,


-- ** providerUnhidden #signal:providerUnhidden#

    DeviceProviderProviderUnhiddenCallback  ,
#if defined(ENABLE_OVERLOADING)
    DeviceProviderProviderUnhiddenSignalInfo,
#endif
    afterDeviceProviderProviderUnhidden     ,
    onDeviceProviderProviderUnhidden        ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Bus as Gst.Bus
import {-# SOURCE #-} qualified GI.Gst.Objects.Device as Gst.Device
import {-# SOURCE #-} qualified GI.Gst.Objects.DeviceProviderFactory as Gst.DeviceProviderFactory
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin

-- | Memory-managed wrapper type.
newtype DeviceProvider = DeviceProvider (SP.ManagedPtr DeviceProvider)
    deriving (DeviceProvider -> DeviceProvider -> Bool
(DeviceProvider -> DeviceProvider -> Bool)
-> (DeviceProvider -> DeviceProvider -> Bool) -> Eq DeviceProvider
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeviceProvider -> DeviceProvider -> Bool
$c/= :: DeviceProvider -> DeviceProvider -> Bool
== :: DeviceProvider -> DeviceProvider -> Bool
$c== :: DeviceProvider -> DeviceProvider -> Bool
Eq)

instance SP.ManagedPtrNewtype DeviceProvider where
    toManagedPtr :: DeviceProvider -> ManagedPtr DeviceProvider
toManagedPtr (DeviceProvider ManagedPtr DeviceProvider
p) = ManagedPtr DeviceProvider
p

foreign import ccall "gst_device_provider_get_type"
    c_gst_device_provider_get_type :: IO B.Types.GType

instance B.Types.TypedObject DeviceProvider where
    glibType :: IO GType
glibType = IO GType
c_gst_device_provider_get_type

instance B.Types.GObject DeviceProvider

-- | Type class for types which can be safely cast to `DeviceProvider`, for instance with `toDeviceProvider`.
class (SP.GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o
instance (SP.GObject o, O.IsDescendantOf DeviceProvider o) => IsDeviceProvider o

instance O.HasParentTypes DeviceProvider
type instance O.ParentTypes DeviceProvider = '[Gst.Object.Object, GObject.Object.Object]

-- | Cast to `DeviceProvider`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDeviceProvider :: (MIO.MonadIO m, IsDeviceProvider o) => o -> m DeviceProvider
toDeviceProvider :: forall (m :: * -> *) o.
(MonadIO m, IsDeviceProvider o) =>
o -> m DeviceProvider
toDeviceProvider = IO DeviceProvider -> m DeviceProvider
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DeviceProvider -> m DeviceProvider)
-> (o -> IO DeviceProvider) -> o -> m DeviceProvider
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DeviceProvider -> DeviceProvider)
-> o -> IO DeviceProvider
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DeviceProvider -> DeviceProvider
DeviceProvider

-- | Convert 'DeviceProvider' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe DeviceProvider) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_device_provider_get_type
    gvalueSet_ :: Ptr GValue -> Maybe DeviceProvider -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DeviceProvider
P.Nothing = Ptr GValue -> Ptr DeviceProvider -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DeviceProvider
forall a. Ptr a
FP.nullPtr :: FP.Ptr DeviceProvider)
    gvalueSet_ Ptr GValue
gv (P.Just DeviceProvider
obj) = DeviceProvider -> (Ptr DeviceProvider -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DeviceProvider
obj (Ptr GValue -> Ptr DeviceProvider -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe DeviceProvider)
gvalueGet_ Ptr GValue
gv = do
        Ptr DeviceProvider
ptr <- Ptr GValue -> IO (Ptr DeviceProvider)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DeviceProvider)
        if Ptr DeviceProvider
ptr Ptr DeviceProvider -> Ptr DeviceProvider -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DeviceProvider
forall a. Ptr a
FP.nullPtr
        then DeviceProvider -> Maybe DeviceProvider
forall a. a -> Maybe a
P.Just (DeviceProvider -> Maybe DeviceProvider)
-> IO DeviceProvider -> IO (Maybe DeviceProvider)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DeviceProvider -> DeviceProvider)
-> Ptr DeviceProvider -> IO DeviceProvider
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DeviceProvider -> DeviceProvider
DeviceProvider Ptr DeviceProvider
ptr
        else Maybe DeviceProvider -> IO (Maybe DeviceProvider)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProvider
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveDeviceProviderMethod (t :: Symbol) (o :: *) :: * where
    ResolveDeviceProviderMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveDeviceProviderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDeviceProviderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDeviceProviderMethod "canMonitor" o = DeviceProviderCanMonitorMethodInfo
    ResolveDeviceProviderMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveDeviceProviderMethod "deviceAdd" o = DeviceProviderDeviceAddMethodInfo
    ResolveDeviceProviderMethod "deviceChanged" o = DeviceProviderDeviceChangedMethodInfo
    ResolveDeviceProviderMethod "deviceRemove" o = DeviceProviderDeviceRemoveMethodInfo
    ResolveDeviceProviderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDeviceProviderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDeviceProviderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDeviceProviderMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveDeviceProviderMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveDeviceProviderMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveDeviceProviderMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveDeviceProviderMethod "hideProvider" o = DeviceProviderHideProviderMethodInfo
    ResolveDeviceProviderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDeviceProviderMethod "isStarted" o = DeviceProviderIsStartedMethodInfo
    ResolveDeviceProviderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDeviceProviderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDeviceProviderMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveDeviceProviderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDeviceProviderMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveDeviceProviderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDeviceProviderMethod "start" o = DeviceProviderStartMethodInfo
    ResolveDeviceProviderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDeviceProviderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDeviceProviderMethod "stop" o = DeviceProviderStopMethodInfo
    ResolveDeviceProviderMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveDeviceProviderMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveDeviceProviderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDeviceProviderMethod "unhideProvider" o = DeviceProviderUnhideProviderMethodInfo
    ResolveDeviceProviderMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveDeviceProviderMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveDeviceProviderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDeviceProviderMethod "getBus" o = DeviceProviderGetBusMethodInfo
    ResolveDeviceProviderMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveDeviceProviderMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveDeviceProviderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDeviceProviderMethod "getDevices" o = DeviceProviderGetDevicesMethodInfo
    ResolveDeviceProviderMethod "getFactory" o = DeviceProviderGetFactoryMethodInfo
    ResolveDeviceProviderMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveDeviceProviderMethod "getHiddenProviders" o = DeviceProviderGetHiddenProvidersMethodInfo
    ResolveDeviceProviderMethod "getMetadata" o = DeviceProviderGetMetadataMethodInfo
    ResolveDeviceProviderMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveDeviceProviderMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveDeviceProviderMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveDeviceProviderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDeviceProviderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDeviceProviderMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveDeviceProviderMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveDeviceProviderMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveDeviceProviderMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveDeviceProviderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDeviceProviderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDeviceProviderMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveDeviceProviderMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveDeviceProviderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDeviceProviderMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, O.OverloadedMethod info DeviceProvider p) => OL.IsLabel t (DeviceProvider -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, O.OverloadedMethod info DeviceProvider p, R.HasField t DeviceProvider p) => R.HasField t DeviceProvider p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, O.OverloadedMethodInfo info DeviceProvider) => OL.IsLabel t (O.MethodProxy info DeviceProvider) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

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

type C_DeviceProviderProviderHiddenCallback =
    Ptr DeviceProvider ->                   -- 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_DeviceProviderProviderHiddenCallback :: 
    GObject a => (a -> DeviceProviderProviderHiddenCallback) ->
    C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback :: forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback a -> DeviceProviderProviderHiddenCallback
gi'cb Ptr DeviceProvider
gi'selfPtr CString
object Ptr ()
_ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    Ptr DeviceProvider -> (DeviceProvider -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DeviceProvider
gi'selfPtr ((DeviceProvider -> IO ()) -> IO ())
-> (DeviceProvider -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DeviceProvider
gi'self -> a -> DeviceProviderProviderHiddenCallback
gi'cb (DeviceProvider -> a
Coerce.coerce DeviceProvider
gi'self)  Text
object'


-- | 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 -> ((?self :: a) => DeviceProviderProviderHiddenCallback) -> m SignalHandlerId
onDeviceProviderProviderHidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
onDeviceProviderProviderHidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
    let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
    FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderHiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
    a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-hidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderHiddenCallback) -> m SignalHandlerId
afterDeviceProviderProviderHidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
afterDeviceProviderProviderHidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
    let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderHiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
    FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderHiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
    a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-hidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DeviceProviderProviderHiddenSignalInfo
instance SignalInfo DeviceProviderProviderHiddenSignalInfo where
    type HaskellCallbackType DeviceProviderProviderHiddenSignalInfo = DeviceProviderProviderHiddenCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DeviceProviderProviderHiddenCallback cb
        cb'' <- mk_DeviceProviderProviderHiddenCallback cb'
        connectSignalFunPtr obj "provider-hidden" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider::provider-hidden"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#g:signal:providerHidden"})

#endif

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

type C_DeviceProviderProviderUnhiddenCallback =
    Ptr DeviceProvider ->                   -- 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_DeviceProviderProviderUnhiddenCallback :: 
    GObject a => (a -> DeviceProviderProviderUnhiddenCallback) ->
    C_DeviceProviderProviderUnhiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback :: forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback a -> DeviceProviderProviderHiddenCallback
gi'cb Ptr DeviceProvider
gi'selfPtr CString
object Ptr ()
_ = do
    Text
object' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
object
    Ptr DeviceProvider -> (DeviceProvider -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr DeviceProvider
gi'selfPtr ((DeviceProvider -> IO ()) -> IO ())
-> (DeviceProvider -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DeviceProvider
gi'self -> a -> DeviceProviderProviderHiddenCallback
gi'cb (DeviceProvider -> a
Coerce.coerce DeviceProvider
gi'self)  Text
object'


-- | 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 -> ((?self :: a) => DeviceProviderProviderUnhiddenCallback) -> m SignalHandlerId
onDeviceProviderProviderUnhidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
onDeviceProviderProviderUnhidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
    let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
    FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderUnhiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
    a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-unhidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | 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
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderUnhiddenCallback) -> m SignalHandlerId
afterDeviceProviderProviderUnhidden :: forall a (m :: * -> *).
(IsDeviceProvider a, MonadIO m) =>
a
-> ((?self::a) => DeviceProviderProviderHiddenCallback)
-> m SignalHandlerId
afterDeviceProviderProviderUnhidden a
obj (?self::a) => DeviceProviderProviderHiddenCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> DeviceProviderProviderHiddenCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DeviceProviderProviderHiddenCallback
DeviceProviderProviderHiddenCallback
cb
    let wrapped' :: C_DeviceProviderProviderHiddenCallback
wrapped' = (a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
forall a.
GObject a =>
(a -> DeviceProviderProviderHiddenCallback)
-> C_DeviceProviderProviderHiddenCallback
wrap_DeviceProviderProviderUnhiddenCallback a -> DeviceProviderProviderHiddenCallback
wrapped
    FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' <- C_DeviceProviderProviderHiddenCallback
-> IO (FunPtr C_DeviceProviderProviderHiddenCallback)
mk_DeviceProviderProviderUnhiddenCallback C_DeviceProviderProviderHiddenCallback
wrapped'
    a
-> Text
-> FunPtr C_DeviceProviderProviderHiddenCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"provider-unhidden" FunPtr C_DeviceProviderProviderHiddenCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DeviceProviderProviderUnhiddenSignalInfo
instance SignalInfo DeviceProviderProviderUnhiddenSignalInfo where
    type HaskellCallbackType DeviceProviderProviderUnhiddenSignalInfo = DeviceProviderProviderUnhiddenCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DeviceProviderProviderUnhiddenCallback cb
        cb'' <- mk_DeviceProviderProviderUnhiddenCallback cb'
        connectSignalFunPtr obj "provider-unhidden" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider::provider-unhidden"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#g:signal:providerUnhidden"})

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DeviceProvider
type instance O.AttributeList DeviceProvider = DeviceProviderAttributeList
type DeviceProviderAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DeviceProvider = DeviceProviderSignalList
type DeviceProviderSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("providerHidden", DeviceProviderProviderHiddenSignalInfo), '("providerUnhidden", DeviceProviderProviderUnhiddenSignalInfo)] :: [(Symbol, *)])

#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bool
deviceProviderCanMonitor a
provider = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CInt
result <- Ptr DeviceProvider -> IO CInt
gst_device_provider_can_monitor Ptr DeviceProvider
provider'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DeviceProviderCanMonitorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderCanMonitorMethodInfo a signature where
    overloadedMethod = deviceProviderCanMonitor

instance O.OverloadedMethodInfo DeviceProviderCanMonitorMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderCanMonitor",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderCanMonitor"
        })


#endif

-- 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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDeviceProvider a, IsDevice b) =>
a -> b -> m ()
deviceProviderDeviceAdd a
provider b
device = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
    Ptr DeviceProvider -> Ptr Device -> IO ()
gst_device_provider_device_add Ptr DeviceProvider
provider' Ptr Device
device'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeviceProviderDeviceAddMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) => O.OverloadedMethod DeviceProviderDeviceAddMethodInfo a signature where
    overloadedMethod = deviceProviderDeviceAdd

instance O.OverloadedMethodInfo DeviceProviderDeviceAddMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderDeviceAdd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderDeviceAdd"
        })


#endif

-- 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 updated"
--                 , 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 updated
    -> m ()
deviceProviderDeviceChanged :: forall (m :: * -> *) a b c.
(HasCallStack, MonadIO m, IsDeviceProvider a, IsDevice b,
 IsDevice c) =>
a -> b -> c -> m ()
deviceProviderDeviceChanged a
provider b
device c
changedDevice = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
    Ptr Device
changedDevice' <- c -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
changedDevice
    Ptr DeviceProvider -> Ptr Device -> Ptr Device -> IO ()
gst_device_provider_device_changed Ptr DeviceProvider
provider' Ptr Device
device' Ptr Device
changedDevice'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
    c -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr c
changedDevice
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeviceProviderDeviceChangedMethodInfo
instance (signature ~ (b -> c -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b, Gst.Device.IsDevice c) => O.OverloadedMethod DeviceProviderDeviceChangedMethodInfo a signature where
    overloadedMethod = deviceProviderDeviceChanged

instance O.OverloadedMethodInfo DeviceProviderDeviceChangedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderDeviceChanged",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderDeviceChanged"
        })


#endif

-- 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 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDeviceProvider a, IsDevice b) =>
a -> b -> m ()
deviceProviderDeviceRemove a
provider b
device = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr Device
device' <- b -> IO (Ptr Device)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
device
    Ptr DeviceProvider -> Ptr Device -> IO ()
gst_device_provider_device_remove Ptr DeviceProvider
provider' Ptr Device
device'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
device
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeviceProviderDeviceRemoveMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDeviceProvider a, Gst.Device.IsDevice b) => O.OverloadedMethod DeviceProviderDeviceRemoveMethodInfo a signature where
    overloadedMethod = deviceProviderDeviceRemove

instance O.OverloadedMethodInfo DeviceProviderDeviceRemoveMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderDeviceRemove",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderDeviceRemove"
        })


#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bus
deviceProviderGetBus a
provider = IO Bus -> m Bus
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bus -> m Bus) -> IO Bus -> m Bus
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr Bus
result <- Ptr DeviceProvider -> IO (Ptr Bus)
gst_device_provider_get_bus Ptr DeviceProvider
provider'
    Text -> Ptr Bus -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deviceProviderGetBus" Ptr Bus
result
    Bus
result' <- ((ManagedPtr Bus -> Bus) -> Ptr Bus -> IO Bus
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Bus -> Bus
Gst.Bus.Bus) Ptr Bus
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Bus -> IO Bus
forall (m :: * -> *) a. Monad m => a -> m a
return Bus
result'

#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetBusMethodInfo
instance (signature ~ (m Gst.Bus.Bus), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetBusMethodInfo a signature where
    overloadedMethod = deviceProviderGetBus

instance O.OverloadedMethodInfo DeviceProviderGetBusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetBus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetBus"
        })


#endif

-- 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.
-- 
-- If the provider has been started, this will returned the same t'GI.Gst.Objects.Device.Device'
-- objedcts that have been returned by the @/GST_MESSAGE_DEVICE_ADDED/@ messages.
-- 
-- /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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m [Device]
deviceProviderGetDevices a
provider = IO [Device] -> m [Device]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Device] -> m [Device]) -> IO [Device] -> m [Device]
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr (GList (Ptr Device))
result <- Ptr DeviceProvider -> IO (Ptr (GList (Ptr Device)))
gst_device_provider_get_devices Ptr DeviceProvider
provider'
    [Ptr Device]
result' <- Ptr (GList (Ptr Device)) -> IO [Ptr Device]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Device))
result
    [Device]
result'' <- (Ptr Device -> IO Device) -> [Ptr Device] -> IO [Device]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Device -> Device) -> Ptr Device -> IO Device
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Device -> Device
Gst.Device.Device) [Ptr Device]
result'
    Ptr (GList (Ptr Device)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Device))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    [Device] -> IO [Device]
forall (m :: * -> *) a. Monad m => a -> m a
return [Device]
result''

#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetDevicesMethodInfo
instance (signature ~ (m [Gst.Device.Device]), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetDevicesMethodInfo a signature where
    overloadedMethod = deviceProviderGetDevices

instance O.OverloadedMethodInfo DeviceProviderGetDevicesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetDevices",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetDevices"
        })


#endif

-- 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 (Maybe Gst.DeviceProviderFactory.DeviceProviderFactory)
    -- ^ __Returns:__ the t'GI.Gst.Objects.DeviceProviderFactory.DeviceProviderFactory' used for
    --     creating this device provider. no refcounting is needed.
deviceProviderGetFactory :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m (Maybe DeviceProviderFactory)
deviceProviderGetFactory a
provider = IO (Maybe DeviceProviderFactory) -> m (Maybe DeviceProviderFactory)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DeviceProviderFactory)
 -> m (Maybe DeviceProviderFactory))
-> IO (Maybe DeviceProviderFactory)
-> m (Maybe DeviceProviderFactory)
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr DeviceProviderFactory
result <- Ptr DeviceProvider -> IO (Ptr DeviceProviderFactory)
gst_device_provider_get_factory Ptr DeviceProvider
provider'
    Maybe DeviceProviderFactory
maybeResult <- Ptr DeviceProviderFactory
-> (Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DeviceProviderFactory
result ((Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
 -> IO (Maybe DeviceProviderFactory))
-> (Ptr DeviceProviderFactory -> IO DeviceProviderFactory)
-> IO (Maybe DeviceProviderFactory)
forall a b. (a -> b) -> a -> b
$ \Ptr DeviceProviderFactory
result' -> do
        DeviceProviderFactory
result'' <- ((ManagedPtr DeviceProviderFactory -> DeviceProviderFactory)
-> Ptr DeviceProviderFactory -> IO DeviceProviderFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DeviceProviderFactory -> DeviceProviderFactory
Gst.DeviceProviderFactory.DeviceProviderFactory) Ptr DeviceProviderFactory
result'
        DeviceProviderFactory -> IO DeviceProviderFactory
forall (m :: * -> *) a. Monad m => a -> m a
return DeviceProviderFactory
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Maybe DeviceProviderFactory -> IO (Maybe DeviceProviderFactory)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DeviceProviderFactory
maybeResult

#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetFactoryMethodInfo
instance (signature ~ (m (Maybe Gst.DeviceProviderFactory.DeviceProviderFactory)), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetFactoryMethodInfo a signature where
    overloadedMethod = deviceProviderGetFactory

instance O.OverloadedMethodInfo DeviceProviderGetFactoryMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetFactory",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetFactory"
        })


#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m [Text]
deviceProviderGetHiddenProviders a
provider = IO [Text] -> m [Text]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr CString
result <- Ptr DeviceProvider -> IO (Ptr CString)
gst_device_provider_get_hidden_providers Ptr DeviceProvider
provider'
    Text -> Ptr CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deviceProviderGetHiddenProviders" Ptr CString
result
    [Text]
result' <- HasCallStack => Ptr CString -> IO [Text]
Ptr CString -> IO [Text]
unpackZeroTerminatedUTF8CArray Ptr CString
result
    (CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    [Text] -> IO [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result'

#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetHiddenProvidersMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetHiddenProvidersMethodInfo a signature where
    overloadedMethod = deviceProviderGetHiddenProviders

instance O.OverloadedMethodInfo DeviceProviderGetHiddenProvidersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetHiddenProviders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetHiddenProviders"
        })


#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> Text -> m Text
deviceProviderGetMetadata a
provider Text
key = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CString
key' <- Text -> IO CString
textToCString Text
key
    CString
result <- Ptr DeviceProvider -> CString -> IO CString
gst_device_provider_get_metadata Ptr DeviceProvider
provider' CString
key'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"deviceProviderGetMetadata" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
key'
    Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data DeviceProviderGetMetadataMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderGetMetadataMethodInfo a signature where
    overloadedMethod = deviceProviderGetMetadata

instance O.OverloadedMethodInfo DeviceProviderGetMetadataMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderGetMetadata",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderGetMetadata"
        })


#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> Text -> m ()
deviceProviderHideProvider a
provider Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr DeviceProvider -> CString -> IO ()
gst_device_provider_hide_provider Ptr DeviceProvider
provider' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeviceProviderHideProviderMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderHideProviderMethodInfo a signature where
    overloadedMethod = deviceProviderHideProvider

instance O.OverloadedMethodInfo DeviceProviderHideProviderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderHideProvider",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderHideProvider"
        })


#endif

-- method DeviceProvider::is_started
-- 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_is_started" gst_device_provider_is_started :: 
    Ptr DeviceProvider ->                   -- provider : TInterface (Name {namespace = "Gst", name = "DeviceProvider"})
    IO CInt

-- | This function can be used to know if the /@provider@/ was successfully started.
-- 
-- /Since: 1.20/
deviceProviderIsStarted ::
    (B.CallStack.HasCallStack, MonadIO m, IsDeviceProvider a) =>
    a
    -- ^ /@provider@/: a t'GI.Gst.Objects.DeviceProvider.DeviceProvider'
    -> m Bool
deviceProviderIsStarted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bool
deviceProviderIsStarted a
provider = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CInt
result <- Ptr DeviceProvider -> IO CInt
gst_device_provider_is_started Ptr DeviceProvider
provider'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DeviceProviderIsStartedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderIsStartedMethodInfo a signature where
    overloadedMethod = deviceProviderIsStarted

instance O.OverloadedMethodInfo DeviceProviderIsStartedMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderIsStarted",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderIsStarted"
        })


#endif

-- 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.
-- 
-- After this function has been called, 'GI.Gst.Objects.DeviceProvider.deviceProviderGetDevices' will
-- return the same objects that have been received from the
-- @/GST_MESSAGE_DEVICE_ADDED/@ messages and will no longer probe.
-- 
-- /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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m Bool
deviceProviderStart a
provider = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CInt
result <- Ptr DeviceProvider -> IO CInt
gst_device_provider_start Ptr DeviceProvider
provider'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DeviceProviderStartMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderStartMethodInfo a signature where
    overloadedMethod = deviceProviderStart

instance O.OverloadedMethodInfo DeviceProviderStartMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderStart",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderStart"
        })


#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> m ()
deviceProviderStop a
provider = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    Ptr DeviceProvider -> IO ()
gst_device_provider_stop Ptr DeviceProvider
provider'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeviceProviderStopMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderStopMethodInfo a signature where
    overloadedMethod = deviceProviderStop

instance O.OverloadedMethodInfo DeviceProviderStopMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderStop",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderStop"
        })


#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDeviceProvider a) =>
a -> Text -> m ()
deviceProviderUnhideProvider a
provider Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DeviceProvider
provider' <- a -> IO (Ptr DeviceProvider)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
provider
    CString
name' <- Text -> IO CString
textToCString Text
name
    Ptr DeviceProvider -> CString -> IO ()
gst_device_provider_unhide_provider Ptr DeviceProvider
provider' CString
name'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
provider
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DeviceProviderUnhideProviderMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDeviceProvider a) => O.OverloadedMethod DeviceProviderUnhideProviderMethodInfo a signature where
    overloadedMethod = deviceProviderUnhideProvider

instance O.OverloadedMethodInfo DeviceProviderUnhideProviderMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Objects.DeviceProvider.deviceProviderUnhideProvider",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-DeviceProvider.html#v:deviceProviderUnhideProvider"
        })


#endif

-- 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 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPlugin a) =>
Maybe a -> Text -> Word32 -> GType -> m Bool
deviceProviderRegister Maybe a
plugin Text
name Word32
rank GType
type_ = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr Plugin
maybePlugin <- case Maybe a
plugin of
        Maybe a
Nothing -> Ptr Plugin -> IO (Ptr Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Plugin
forall a. Ptr a
nullPtr
        Just a
jPlugin -> do
            Ptr Plugin
jPlugin' <- a -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jPlugin
            Ptr Plugin -> IO (Ptr Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Plugin
jPlugin'
    CString
name' <- Text -> IO CString
textToCString Text
name
    let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
    CInt
result <- Ptr Plugin -> CString -> Word32 -> CGType -> IO CInt
gst_device_provider_register Ptr Plugin
maybePlugin CString
name' Word32
rank CGType
type_'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Maybe a -> (a -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
plugin a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
#endif