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


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./
-- 
-- /Since: 1.24/

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

module GI.GES.Objects.DiscovererManager
    ( 

-- * Exported types
    DiscovererManager(..)                   ,
    IsDiscovererManager                     ,
    toDiscovererManager                     ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getTimeout]("GI.GES.Objects.DiscovererManager#g:method:getTimeout"), [getUseCache]("GI.GES.Objects.DiscovererManager#g:method:getUseCache").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setTimeout]("GI.GES.Objects.DiscovererManager#g:method:setTimeout"), [setUseCache]("GI.GES.Objects.DiscovererManager#g:method:setUseCache").

#if defined(ENABLE_OVERLOADING)
    ResolveDiscovererManagerMethod          ,
#endif

-- ** getDefault #method:getDefault#

    discovererManagerGetDefault             ,


-- ** getTimeout #method:getTimeout#

#if defined(ENABLE_OVERLOADING)
    DiscovererManagerGetTimeoutMethodInfo   ,
#endif
    discovererManagerGetTimeout             ,


-- ** getUseCache #method:getUseCache#

#if defined(ENABLE_OVERLOADING)
    DiscovererManagerGetUseCacheMethodInfo  ,
#endif
    discovererManagerGetUseCache            ,


-- ** setTimeout #method:setTimeout#

#if defined(ENABLE_OVERLOADING)
    DiscovererManagerSetTimeoutMethodInfo   ,
#endif
    discovererManagerSetTimeout             ,


-- ** setUseCache #method:setUseCache#

#if defined(ENABLE_OVERLOADING)
    DiscovererManagerSetUseCacheMethodInfo  ,
#endif
    discovererManagerSetUseCache            ,




 -- * Properties


-- ** timeout #attr:timeout#
-- | The timeout (in milliseconds) for the t'GI.GstPbutils.Objects.Discoverer.Discoverer' operations
-- 
-- /Since: 1.24/

#if defined(ENABLE_OVERLOADING)
    DiscovererManagerTimeoutPropertyInfo    ,
#endif
    constructDiscovererManagerTimeout       ,
#if defined(ENABLE_OVERLOADING)
    discovererManagerTimeout                ,
#endif
    getDiscovererManagerTimeout             ,
    setDiscovererManagerTimeout             ,


-- ** useCache #attr:useCache#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    DiscovererManagerUseCachePropertyInfo   ,
#endif
    constructDiscovererManagerUseCache      ,
#if defined(ENABLE_OVERLOADING)
    discovererManagerUseCache               ,
#endif
    getDiscovererManagerUseCache            ,
    setDiscovererManagerUseCache            ,




 -- * Signals


-- ** discovered #signal:discovered#

    DiscovererManagerDiscoveredCallback     ,
#if defined(ENABLE_OVERLOADING)
    DiscovererManagerDiscoveredSignalInfo   ,
#endif
    afterDiscovererManagerDiscovered        ,
    onDiscovererManagerDiscovered           ,


-- ** loadSerializedInfo #signal:loadSerializedInfo#

    DiscovererManagerLoadSerializedInfoCallback,
#if defined(ENABLE_OVERLOADING)
    DiscovererManagerLoadSerializedInfoSignalInfo,
#endif
    afterDiscovererManagerLoadSerializedInfo,
    onDiscovererManagerLoadSerializedInfo   ,


-- ** sourceSetup #signal:sourceSetup#

    DiscovererManagerSourceSetupCallback    ,
#if defined(ENABLE_OVERLOADING)
    DiscovererManagerSourceSetupSignalInfo  ,
#endif
    afterDiscovererManagerSourceSetup       ,
    onDiscovererManagerSourceSetup          ,




    ) 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.GHashTable as B.GHT
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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.GstPbutils.Objects.DiscovererInfo as GstPbutils.DiscovererInfo

#else
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.GstPbutils.Objects.DiscovererInfo as GstPbutils.DiscovererInfo

#endif

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

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

foreign import ccall "ges_discoverer_manager_get_type"
    c_ges_discoverer_manager_get_type :: IO B.Types.GType

instance B.Types.TypedObject DiscovererManager where
    glibType :: IO GType
glibType = IO GType
c_ges_discoverer_manager_get_type

instance B.Types.GObject DiscovererManager

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

instance O.HasParentTypes DiscovererManager
type instance O.ParentTypes DiscovererManager = '[GObject.Object.Object]

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

-- | Convert 'DiscovererManager' 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 DiscovererManager) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ges_discoverer_manager_get_type
    gvalueSet_ :: Ptr GValue -> Maybe DiscovererManager -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DiscovererManager
P.Nothing = Ptr GValue -> Ptr DiscovererManager -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DiscovererManager
forall a. Ptr a
FP.nullPtr :: FP.Ptr DiscovererManager)
    gvalueSet_ Ptr GValue
gv (P.Just DiscovererManager
obj) = DiscovererManager -> (Ptr DiscovererManager -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DiscovererManager
obj (Ptr GValue -> Ptr DiscovererManager -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe DiscovererManager)
gvalueGet_ Ptr GValue
gv = do
        Ptr DiscovererManager
ptr <- Ptr GValue -> IO (Ptr DiscovererManager)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DiscovererManager)
        if Ptr DiscovererManager
ptr Ptr DiscovererManager -> Ptr DiscovererManager -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr DiscovererManager
forall a. Ptr a
FP.nullPtr
        then DiscovererManager -> Maybe DiscovererManager
forall a. a -> Maybe a
P.Just (DiscovererManager -> Maybe DiscovererManager)
-> IO DiscovererManager -> IO (Maybe DiscovererManager)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr DiscovererManager -> DiscovererManager)
-> Ptr DiscovererManager -> IO DiscovererManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DiscovererManager -> DiscovererManager
DiscovererManager Ptr DiscovererManager
ptr
        else Maybe DiscovererManager -> IO (Maybe DiscovererManager)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DiscovererManager
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveDiscovererManagerMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveDiscovererManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDiscovererManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDiscovererManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDiscovererManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDiscovererManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDiscovererManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDiscovererManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDiscovererManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDiscovererManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDiscovererManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDiscovererManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDiscovererManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDiscovererManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDiscovererManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDiscovererManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDiscovererManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDiscovererManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDiscovererManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDiscovererManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDiscovererManagerMethod "getTimeout" o = DiscovererManagerGetTimeoutMethodInfo
    ResolveDiscovererManagerMethod "getUseCache" o = DiscovererManagerGetUseCacheMethodInfo
    ResolveDiscovererManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDiscovererManagerMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDiscovererManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDiscovererManagerMethod "setTimeout" o = DiscovererManagerSetTimeoutMethodInfo
    ResolveDiscovererManagerMethod "setUseCache" o = DiscovererManagerSetUseCacheMethodInfo
    ResolveDiscovererManagerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDiscovererManagerMethod t DiscovererManager, O.OverloadedMethod info DiscovererManager p) => OL.IsLabel t (DiscovererManager -> 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 ~ ResolveDiscovererManagerMethod t DiscovererManager, O.OverloadedMethod info DiscovererManager p, R.HasField t DiscovererManager p) => R.HasField t DiscovererManager p where
    getField = O.overloadedMethod @info

#endif

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

#endif

-- signal DiscovererManager::discovered
-- | /No description available in the introspection data./
-- 
-- /Since: 1.24/
type DiscovererManagerDiscoveredCallback =
    GstPbutils.DiscovererInfo.DiscovererInfo
    -- ^ /@info@/: The t'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' representing the discovered URI
    -> Maybe GError
    -- ^ /@error@/: The t'GError' that occurred, or 'P.Nothing'
    -> IO ()

type C_DiscovererManagerDiscoveredCallback =
    Ptr DiscovererManager ->                -- object
    Ptr GstPbutils.DiscovererInfo.DiscovererInfo ->
    Ptr GError ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DiscovererManagerDiscoveredCallback :: 
    GObject a => (a -> DiscovererManagerDiscoveredCallback) ->
    C_DiscovererManagerDiscoveredCallback
wrap_DiscovererManagerDiscoveredCallback :: forall a.
GObject a =>
(a -> DiscovererManagerDiscoveredCallback)
-> C_DiscovererManagerDiscoveredCallback
wrap_DiscovererManagerDiscoveredCallback a -> DiscovererManagerDiscoveredCallback
gi'cb Ptr DiscovererManager
gi'selfPtr Ptr DiscovererInfo
info Ptr GError
error_ Ptr ()
_ = do
    DiscovererInfo
info' <- ((ManagedPtr DiscovererInfo -> DiscovererInfo)
-> Ptr DiscovererInfo -> IO DiscovererInfo
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DiscovererInfo -> DiscovererInfo
GstPbutils.DiscovererInfo.DiscovererInfo) Ptr DiscovererInfo
info
    Maybe GError
maybeError_ <-
        if Ptr GError
error_ Ptr GError -> Ptr GError -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr GError
forall a. Ptr a
nullPtr
        then Maybe GError -> IO (Maybe GError)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe GError
forall a. Maybe a
Nothing
        else do
            GError
error_' <- ((ManagedPtr GError -> GError) -> Ptr GError -> IO GError
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GError -> GError
GError) Ptr GError
error_
            Maybe GError -> IO (Maybe GError)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe GError -> IO (Maybe GError))
-> Maybe GError -> IO (Maybe GError)
forall a b. (a -> b) -> a -> b
$ GError -> Maybe GError
forall a. a -> Maybe a
Just GError
error_'
    Ptr DiscovererManager -> (DiscovererManager -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DiscovererManager
gi'selfPtr ((DiscovererManager -> IO ()) -> IO ())
-> (DiscovererManager -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DiscovererManager
gi'self -> a -> DiscovererManagerDiscoveredCallback
gi'cb (DiscovererManager -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DiscovererManager
gi'self)  DiscovererInfo
info' Maybe GError
maybeError_


-- | Connect a signal handler for the [discovered](#signal:discovered) 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' discovererManager #discovered callback
-- @
-- 
-- 
onDiscovererManagerDiscovered :: (IsDiscovererManager a, MonadIO m) => a -> ((?self :: a) => DiscovererManagerDiscoveredCallback) -> m SignalHandlerId
onDiscovererManagerDiscovered :: forall a (m :: * -> *).
(IsDiscovererManager a, MonadIO m) =>
a
-> ((?self::a) => DiscovererManagerDiscoveredCallback)
-> m SignalHandlerId
onDiscovererManagerDiscovered a
obj (?self::a) => DiscovererManagerDiscoveredCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DiscovererManagerDiscoveredCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererManagerDiscoveredCallback
DiscovererManagerDiscoveredCallback
cb
    let wrapped' :: C_DiscovererManagerDiscoveredCallback
wrapped' = (a -> DiscovererManagerDiscoveredCallback)
-> C_DiscovererManagerDiscoveredCallback
forall a.
GObject a =>
(a -> DiscovererManagerDiscoveredCallback)
-> C_DiscovererManagerDiscoveredCallback
wrap_DiscovererManagerDiscoveredCallback a -> DiscovererManagerDiscoveredCallback
wrapped
    FunPtr C_DiscovererManagerDiscoveredCallback
wrapped'' <- C_DiscovererManagerDiscoveredCallback
-> IO (FunPtr C_DiscovererManagerDiscoveredCallback)
mk_DiscovererManagerDiscoveredCallback C_DiscovererManagerDiscoveredCallback
wrapped'
    a
-> Text
-> FunPtr C_DiscovererManagerDiscoveredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"discovered" FunPtr C_DiscovererManagerDiscoveredCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [discovered](#signal:discovered) 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' discovererManager #discovered 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.
-- 
afterDiscovererManagerDiscovered :: (IsDiscovererManager a, MonadIO m) => a -> ((?self :: a) => DiscovererManagerDiscoveredCallback) -> m SignalHandlerId
afterDiscovererManagerDiscovered :: forall a (m :: * -> *).
(IsDiscovererManager a, MonadIO m) =>
a
-> ((?self::a) => DiscovererManagerDiscoveredCallback)
-> m SignalHandlerId
afterDiscovererManagerDiscovered a
obj (?self::a) => DiscovererManagerDiscoveredCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DiscovererManagerDiscoveredCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererManagerDiscoveredCallback
DiscovererManagerDiscoveredCallback
cb
    let wrapped' :: C_DiscovererManagerDiscoveredCallback
wrapped' = (a -> DiscovererManagerDiscoveredCallback)
-> C_DiscovererManagerDiscoveredCallback
forall a.
GObject a =>
(a -> DiscovererManagerDiscoveredCallback)
-> C_DiscovererManagerDiscoveredCallback
wrap_DiscovererManagerDiscoveredCallback a -> DiscovererManagerDiscoveredCallback
wrapped
    FunPtr C_DiscovererManagerDiscoveredCallback
wrapped'' <- C_DiscovererManagerDiscoveredCallback
-> IO (FunPtr C_DiscovererManagerDiscoveredCallback)
mk_DiscovererManagerDiscoveredCallback C_DiscovererManagerDiscoveredCallback
wrapped'
    a
-> Text
-> FunPtr C_DiscovererManagerDiscoveredCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"discovered" FunPtr C_DiscovererManagerDiscoveredCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DiscovererManagerDiscoveredSignalInfo
instance SignalInfo DiscovererManagerDiscoveredSignalInfo where
    type HaskellCallbackType DiscovererManagerDiscoveredSignalInfo = DiscovererManagerDiscoveredCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DiscovererManagerDiscoveredCallback cb
        cb'' <- mk_DiscovererManagerDiscoveredCallback cb'
        connectSignalFunPtr obj "discovered" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager::discovered"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#g:signal:discovered"})

#endif

-- signal DiscovererManager::load-serialized-info
-- | Retrieves information about a URI from and external source of information,
-- like a cache file. This is used by the discoverer to speed up the
-- discovery.
-- 
-- /Since: 1.24/
type DiscovererManagerLoadSerializedInfoCallback =
    T.Text
    -- ^ /@uri@/: The URI to load the serialized info for
    -> IO (Maybe GstPbutils.DiscovererInfo.DiscovererInfo)
    -- ^ __Returns:__ The t'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' representing
    -- /@uri@/, or 'P.Nothing' if no information

type C_DiscovererManagerLoadSerializedInfoCallback =
    Ptr DiscovererManager ->                -- object
    CString ->
    Ptr () ->                               -- user_data
    IO (Ptr GstPbutils.DiscovererInfo.DiscovererInfo)

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

wrap_DiscovererManagerLoadSerializedInfoCallback :: 
    GObject a => (a -> DiscovererManagerLoadSerializedInfoCallback) ->
    C_DiscovererManagerLoadSerializedInfoCallback
wrap_DiscovererManagerLoadSerializedInfoCallback :: forall a.
GObject a =>
(a -> DiscovererManagerLoadSerializedInfoCallback)
-> C_DiscovererManagerLoadSerializedInfoCallback
wrap_DiscovererManagerLoadSerializedInfoCallback a -> DiscovererManagerLoadSerializedInfoCallback
gi'cb Ptr DiscovererManager
gi'selfPtr CString
uri Ptr ()
_ = do
    Text
uri' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
uri
    Maybe DiscovererInfo
result <- Ptr DiscovererManager
-> (DiscovererManager -> IO (Maybe DiscovererInfo))
-> IO (Maybe DiscovererInfo)
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DiscovererManager
gi'selfPtr ((DiscovererManager -> IO (Maybe DiscovererInfo))
 -> IO (Maybe DiscovererInfo))
-> (DiscovererManager -> IO (Maybe DiscovererInfo))
-> IO (Maybe DiscovererInfo)
forall a b. (a -> b) -> a -> b
$ \DiscovererManager
gi'self -> a -> DiscovererManagerLoadSerializedInfoCallback
gi'cb (DiscovererManager -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DiscovererManager
gi'self)  Text
uri'
    Ptr DiscovererInfo
-> Maybe DiscovererInfo
-> (DiscovererInfo -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo)
forall (m :: * -> *) b a.
Monad m =>
b -> Maybe a -> (a -> m b) -> m b
maybeM Ptr DiscovererInfo
forall a. Ptr a
FP.nullPtr Maybe DiscovererInfo
result ((DiscovererInfo -> IO (Ptr DiscovererInfo))
 -> IO (Ptr DiscovererInfo))
-> (DiscovererInfo -> IO (Ptr DiscovererInfo))
-> IO (Ptr DiscovererInfo)
forall a b. (a -> b) -> a -> b
$ \DiscovererInfo
result' -> do
        Ptr DiscovererInfo
result'' <- DiscovererInfo -> IO (Ptr DiscovererInfo)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject DiscovererInfo
result'
        Ptr DiscovererInfo -> IO (Ptr DiscovererInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DiscovererInfo
result''


-- | Connect a signal handler for the [loadSerializedInfo](#signal:loadSerializedInfo) 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' discovererManager #loadSerializedInfo callback
-- @
-- 
-- 
onDiscovererManagerLoadSerializedInfo :: (IsDiscovererManager a, MonadIO m) => a -> ((?self :: a) => DiscovererManagerLoadSerializedInfoCallback) -> m SignalHandlerId
onDiscovererManagerLoadSerializedInfo :: forall a (m :: * -> *).
(IsDiscovererManager a, MonadIO m) =>
a
-> ((?self::a) => DiscovererManagerLoadSerializedInfoCallback)
-> m SignalHandlerId
onDiscovererManagerLoadSerializedInfo a
obj (?self::a) => DiscovererManagerLoadSerializedInfoCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DiscovererManagerLoadSerializedInfoCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererManagerLoadSerializedInfoCallback
DiscovererManagerLoadSerializedInfoCallback
cb
    let wrapped' :: C_DiscovererManagerLoadSerializedInfoCallback
wrapped' = (a -> DiscovererManagerLoadSerializedInfoCallback)
-> C_DiscovererManagerLoadSerializedInfoCallback
forall a.
GObject a =>
(a -> DiscovererManagerLoadSerializedInfoCallback)
-> C_DiscovererManagerLoadSerializedInfoCallback
wrap_DiscovererManagerLoadSerializedInfoCallback a -> DiscovererManagerLoadSerializedInfoCallback
wrapped
    FunPtr C_DiscovererManagerLoadSerializedInfoCallback
wrapped'' <- C_DiscovererManagerLoadSerializedInfoCallback
-> IO (FunPtr C_DiscovererManagerLoadSerializedInfoCallback)
mk_DiscovererManagerLoadSerializedInfoCallback C_DiscovererManagerLoadSerializedInfoCallback
wrapped'
    a
-> Text
-> FunPtr C_DiscovererManagerLoadSerializedInfoCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"load-serialized-info" FunPtr C_DiscovererManagerLoadSerializedInfoCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [loadSerializedInfo](#signal:loadSerializedInfo) 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' discovererManager #loadSerializedInfo 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.
-- 
afterDiscovererManagerLoadSerializedInfo :: (IsDiscovererManager a, MonadIO m) => a -> ((?self :: a) => DiscovererManagerLoadSerializedInfoCallback) -> m SignalHandlerId
afterDiscovererManagerLoadSerializedInfo :: forall a (m :: * -> *).
(IsDiscovererManager a, MonadIO m) =>
a
-> ((?self::a) => DiscovererManagerLoadSerializedInfoCallback)
-> m SignalHandlerId
afterDiscovererManagerLoadSerializedInfo a
obj (?self::a) => DiscovererManagerLoadSerializedInfoCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DiscovererManagerLoadSerializedInfoCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererManagerLoadSerializedInfoCallback
DiscovererManagerLoadSerializedInfoCallback
cb
    let wrapped' :: C_DiscovererManagerLoadSerializedInfoCallback
wrapped' = (a -> DiscovererManagerLoadSerializedInfoCallback)
-> C_DiscovererManagerLoadSerializedInfoCallback
forall a.
GObject a =>
(a -> DiscovererManagerLoadSerializedInfoCallback)
-> C_DiscovererManagerLoadSerializedInfoCallback
wrap_DiscovererManagerLoadSerializedInfoCallback a -> DiscovererManagerLoadSerializedInfoCallback
wrapped
    FunPtr C_DiscovererManagerLoadSerializedInfoCallback
wrapped'' <- C_DiscovererManagerLoadSerializedInfoCallback
-> IO (FunPtr C_DiscovererManagerLoadSerializedInfoCallback)
mk_DiscovererManagerLoadSerializedInfoCallback C_DiscovererManagerLoadSerializedInfoCallback
wrapped'
    a
-> Text
-> FunPtr C_DiscovererManagerLoadSerializedInfoCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"load-serialized-info" FunPtr C_DiscovererManagerLoadSerializedInfoCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DiscovererManagerLoadSerializedInfoSignalInfo
instance SignalInfo DiscovererManagerLoadSerializedInfoSignalInfo where
    type HaskellCallbackType DiscovererManagerLoadSerializedInfoSignalInfo = DiscovererManagerLoadSerializedInfoCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DiscovererManagerLoadSerializedInfoCallback cb
        cb'' <- mk_DiscovererManagerLoadSerializedInfoCallback cb'
        connectSignalFunPtr obj "load-serialized-info" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager::load-serialized-info"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#g:signal:loadSerializedInfo"})

#endif

-- signal DiscovererManager::source-setup
-- | Allows to setup the source element before the discoverer runs.
-- 
-- /Since: 1.24/
type DiscovererManagerSourceSetupCallback =
    Gst.Element.Element
    -- ^ /@source@/: The source t'GI.Gst.Objects.Element.Element' to setup
    -> IO ()

type C_DiscovererManagerSourceSetupCallback =
    Ptr DiscovererManager ->                -- object
    Ptr Gst.Element.Element ->
    Ptr () ->                               -- user_data
    IO ()

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

wrap_DiscovererManagerSourceSetupCallback :: 
    GObject a => (a -> DiscovererManagerSourceSetupCallback) ->
    C_DiscovererManagerSourceSetupCallback
wrap_DiscovererManagerSourceSetupCallback :: forall a.
GObject a =>
(a -> DiscovererManagerSourceSetupCallback)
-> C_DiscovererManagerSourceSetupCallback
wrap_DiscovererManagerSourceSetupCallback a -> DiscovererManagerSourceSetupCallback
gi'cb Ptr DiscovererManager
gi'selfPtr Ptr Element
source Ptr ()
_ = do
    Element
source' <- ((ManagedPtr Element -> Element) -> Ptr Element -> IO Element
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
source
    Ptr DiscovererManager -> (DiscovererManager -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr DiscovererManager
gi'selfPtr ((DiscovererManager -> IO ()) -> IO ())
-> (DiscovererManager -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \DiscovererManager
gi'self -> a -> DiscovererManagerSourceSetupCallback
gi'cb (DiscovererManager -> a
forall a b. Coercible a b => a -> b
Coerce.coerce DiscovererManager
gi'self)  Element
source'


-- | Connect a signal handler for the [sourceSetup](#signal:sourceSetup) 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' discovererManager #sourceSetup callback
-- @
-- 
-- 
onDiscovererManagerSourceSetup :: (IsDiscovererManager a, MonadIO m) => a -> ((?self :: a) => DiscovererManagerSourceSetupCallback) -> m SignalHandlerId
onDiscovererManagerSourceSetup :: forall a (m :: * -> *).
(IsDiscovererManager a, MonadIO m) =>
a
-> ((?self::a) => DiscovererManagerSourceSetupCallback)
-> m SignalHandlerId
onDiscovererManagerSourceSetup a
obj (?self::a) => DiscovererManagerSourceSetupCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DiscovererManagerSourceSetupCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererManagerSourceSetupCallback
DiscovererManagerSourceSetupCallback
cb
    let wrapped' :: C_DiscovererManagerSourceSetupCallback
wrapped' = (a -> DiscovererManagerSourceSetupCallback)
-> C_DiscovererManagerSourceSetupCallback
forall a.
GObject a =>
(a -> DiscovererManagerSourceSetupCallback)
-> C_DiscovererManagerSourceSetupCallback
wrap_DiscovererManagerSourceSetupCallback a -> DiscovererManagerSourceSetupCallback
wrapped
    FunPtr C_DiscovererManagerSourceSetupCallback
wrapped'' <- C_DiscovererManagerSourceSetupCallback
-> IO (FunPtr C_DiscovererManagerSourceSetupCallback)
mk_DiscovererManagerSourceSetupCallback C_DiscovererManagerSourceSetupCallback
wrapped'
    a
-> Text
-> FunPtr C_DiscovererManagerSourceSetupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"source-setup" FunPtr C_DiscovererManagerSourceSetupCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [sourceSetup](#signal:sourceSetup) 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' discovererManager #sourceSetup 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.
-- 
afterDiscovererManagerSourceSetup :: (IsDiscovererManager a, MonadIO m) => a -> ((?self :: a) => DiscovererManagerSourceSetupCallback) -> m SignalHandlerId
afterDiscovererManagerSourceSetup :: forall a (m :: * -> *).
(IsDiscovererManager a, MonadIO m) =>
a
-> ((?self::a) => DiscovererManagerSourceSetupCallback)
-> m SignalHandlerId
afterDiscovererManagerSourceSetup a
obj (?self::a) => DiscovererManagerSourceSetupCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
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 -> DiscovererManagerSourceSetupCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => DiscovererManagerSourceSetupCallback
DiscovererManagerSourceSetupCallback
cb
    let wrapped' :: C_DiscovererManagerSourceSetupCallback
wrapped' = (a -> DiscovererManagerSourceSetupCallback)
-> C_DiscovererManagerSourceSetupCallback
forall a.
GObject a =>
(a -> DiscovererManagerSourceSetupCallback)
-> C_DiscovererManagerSourceSetupCallback
wrap_DiscovererManagerSourceSetupCallback a -> DiscovererManagerSourceSetupCallback
wrapped
    FunPtr C_DiscovererManagerSourceSetupCallback
wrapped'' <- C_DiscovererManagerSourceSetupCallback
-> IO (FunPtr C_DiscovererManagerSourceSetupCallback)
mk_DiscovererManagerSourceSetupCallback C_DiscovererManagerSourceSetupCallback
wrapped'
    a
-> Text
-> FunPtr C_DiscovererManagerSourceSetupCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"source-setup" FunPtr C_DiscovererManagerSourceSetupCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data DiscovererManagerSourceSetupSignalInfo
instance SignalInfo DiscovererManagerSourceSetupSignalInfo where
    type HaskellCallbackType DiscovererManagerSourceSetupSignalInfo = DiscovererManagerSourceSetupCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_DiscovererManagerSourceSetupCallback cb
        cb'' <- mk_DiscovererManagerSourceSetupCallback cb'
        connectSignalFunPtr obj "source-setup" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager::source-setup"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#g:signal:sourceSetup"})

#endif

-- VVV Prop "timeout"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@timeout@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' discovererManager #timeout
-- @
getDiscovererManagerTimeout :: (MonadIO m, IsDiscovererManager o) => o -> m Word64
getDiscovererManagerTimeout :: forall (m :: * -> *) o.
(MonadIO m, IsDiscovererManager o) =>
o -> m Word64
getDiscovererManagerTimeout o
obj = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word64
forall a. GObject a => a -> String -> IO Word64
B.Properties.getObjectPropertyUInt64 o
obj String
"timeout"

-- | Set the value of the “@timeout@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' discovererManager [ #timeout 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiscovererManagerTimeout :: (MonadIO m, IsDiscovererManager o) => o -> Word64 -> m ()
setDiscovererManagerTimeout :: forall (m :: * -> *) o.
(MonadIO m, IsDiscovererManager o) =>
o -> Word64 -> m ()
setDiscovererManagerTimeout o
obj Word64
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word64 -> IO ()
forall a. GObject a => a -> String -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj String
"timeout" Word64
val

-- | Construct a `GValueConstruct` with valid value for the “@timeout@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructDiscovererManagerTimeout :: (IsDiscovererManager o, MIO.MonadIO m) => Word64 -> m (GValueConstruct o)
constructDiscovererManagerTimeout :: forall o (m :: * -> *).
(IsDiscovererManager o, MonadIO m) =>
Word64 -> m (GValueConstruct o)
constructDiscovererManagerTimeout Word64
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word64 -> IO (GValueConstruct o)
forall o. String -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 String
"timeout" Word64
val

#if defined(ENABLE_OVERLOADING)
data DiscovererManagerTimeoutPropertyInfo
instance AttrInfo DiscovererManagerTimeoutPropertyInfo where
    type AttrAllowedOps DiscovererManagerTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiscovererManagerTimeoutPropertyInfo = IsDiscovererManager
    type AttrSetTypeConstraint DiscovererManagerTimeoutPropertyInfo = (~) Word64
    type AttrTransferTypeConstraint DiscovererManagerTimeoutPropertyInfo = (~) Word64
    type AttrTransferType DiscovererManagerTimeoutPropertyInfo = Word64
    type AttrGetType DiscovererManagerTimeoutPropertyInfo = Word64
    type AttrLabel DiscovererManagerTimeoutPropertyInfo = "timeout"
    type AttrOrigin DiscovererManagerTimeoutPropertyInfo = DiscovererManager
    attrGet = getDiscovererManagerTimeout
    attrSet = setDiscovererManagerTimeout
    attrTransfer _ v = do
        return v
    attrConstruct = constructDiscovererManagerTimeout
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager.timeout"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#g:attr:timeout"
        })
#endif

-- VVV Prop "use-cache"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@use-cache@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' discovererManager #useCache
-- @
getDiscovererManagerUseCache :: (MonadIO m, IsDiscovererManager o) => o -> m Bool
getDiscovererManagerUseCache :: forall (m :: * -> *) o.
(MonadIO m, IsDiscovererManager o) =>
o -> m Bool
getDiscovererManagerUseCache o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"use-cache"

-- | Set the value of the “@use-cache@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' discovererManager [ #useCache 'Data.GI.Base.Attributes.:=' value ]
-- @
setDiscovererManagerUseCache :: (MonadIO m, IsDiscovererManager o) => o -> Bool -> m ()
setDiscovererManagerUseCache :: forall (m :: * -> *) o.
(MonadIO m, IsDiscovererManager o) =>
o -> Bool -> m ()
setDiscovererManagerUseCache o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"use-cache" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@use-cache@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructDiscovererManagerUseCache :: (IsDiscovererManager o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructDiscovererManagerUseCache :: forall o (m :: * -> *).
(IsDiscovererManager o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructDiscovererManagerUseCache Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"use-cache" Bool
val

#if defined(ENABLE_OVERLOADING)
data DiscovererManagerUseCachePropertyInfo
instance AttrInfo DiscovererManagerUseCachePropertyInfo where
    type AttrAllowedOps DiscovererManagerUseCachePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint DiscovererManagerUseCachePropertyInfo = IsDiscovererManager
    type AttrSetTypeConstraint DiscovererManagerUseCachePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint DiscovererManagerUseCachePropertyInfo = (~) Bool
    type AttrTransferType DiscovererManagerUseCachePropertyInfo = Bool
    type AttrGetType DiscovererManagerUseCachePropertyInfo = Bool
    type AttrLabel DiscovererManagerUseCachePropertyInfo = "use-cache"
    type AttrOrigin DiscovererManagerUseCachePropertyInfo = DiscovererManager
    attrGet = getDiscovererManagerUseCache
    attrSet = setDiscovererManagerUseCache
    attrTransfer _ v = do
        return v
    attrConstruct = constructDiscovererManagerUseCache
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager.useCache"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#g:attr:useCache"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DiscovererManager
type instance O.AttributeList DiscovererManager = DiscovererManagerAttributeList
type DiscovererManagerAttributeList = ('[ '("timeout", DiscovererManagerTimeoutPropertyInfo), '("useCache", DiscovererManagerUseCachePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
discovererManagerTimeout :: AttrLabelProxy "timeout"
discovererManagerTimeout = AttrLabelProxy

discovererManagerUseCache :: AttrLabelProxy "useCache"
discovererManagerUseCache = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DiscovererManager = DiscovererManagerSignalList
type DiscovererManagerSignalList = ('[ '("discovered", DiscovererManagerDiscoveredSignalInfo), '("loadSerializedInfo", DiscovererManagerLoadSerializedInfoSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sourceSetup", DiscovererManagerSourceSetupSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method DiscovererManager::get_timeout
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "DiscovererManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESDiscovererManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "ges_discoverer_manager_get_timeout" ges_discoverer_manager_get_timeout :: 
    Ptr DiscovererManager ->                -- self : TInterface (Name {namespace = "GES", name = "DiscovererManager"})
    IO Word64

-- | /No description available in the introspection data./
-- 
-- /Since: 1.24/
discovererManagerGetTimeout ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererManager a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.DiscovererManager.DiscovererManager'
    -> m Word64
    -- ^ __Returns:__ The timeout to use for the discoverer
discovererManagerGetTimeout :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererManager a) =>
a -> m Word64
discovererManagerGetTimeout a
self = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiscovererManager
self' <- a -> IO (Ptr DiscovererManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word64
result <- Ptr DiscovererManager -> IO Word64
ges_discoverer_manager_get_timeout Ptr DiscovererManager
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word64 -> IO Word64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data DiscovererManagerGetTimeoutMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsDiscovererManager a) => O.OverloadedMethod DiscovererManagerGetTimeoutMethodInfo a signature where
    overloadedMethod = discovererManagerGetTimeout

instance O.OverloadedMethodInfo DiscovererManagerGetTimeoutMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager.discovererManagerGetTimeout",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#v:discovererManagerGetTimeout"
        })


#endif

-- method DiscovererManager::get_use_cache
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "DiscovererManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESDiscovererManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_discoverer_manager_get_use_cache" ges_discoverer_manager_get_use_cache :: 
    Ptr DiscovererManager ->                -- self : TInterface (Name {namespace = "GES", name = "DiscovererManager"})
    IO CInt

-- | /No description available in the introspection data./
-- 
-- /Since: 1.24/
discovererManagerGetUseCache ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererManager a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.DiscovererManager.DiscovererManager'
    -> m Bool
    -- ^ __Returns:__ Whether to use the cache or not
discovererManagerGetUseCache :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererManager a) =>
a -> m Bool
discovererManagerGetUseCache a
self = IO Bool -> m Bool
forall a. IO a -> m a
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 DiscovererManager
self' <- a -> IO (Ptr DiscovererManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr DiscovererManager -> IO CInt
ges_discoverer_manager_get_use_cache Ptr DiscovererManager
self'
    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
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data DiscovererManagerGetUseCacheMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDiscovererManager a) => O.OverloadedMethod DiscovererManagerGetUseCacheMethodInfo a signature where
    overloadedMethod = discovererManagerGetUseCache

instance O.OverloadedMethodInfo DiscovererManagerGetUseCacheMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager.discovererManagerGetUseCache",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#v:discovererManagerGetUseCache"
        })


#endif

-- method DiscovererManager::set_timeout
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "DiscovererManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESDiscovererManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeout"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The timeout to set" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_discoverer_manager_set_timeout" ges_discoverer_manager_set_timeout :: 
    Ptr DiscovererManager ->                -- self : TInterface (Name {namespace = "GES", name = "DiscovererManager"})
    Word64 ->                               -- timeout : TBasicType TUInt64
    IO ()

-- | Sets the timeout to use for the discoverer
-- 
-- /Since: 1.24/
discovererManagerSetTimeout ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererManager a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.DiscovererManager.DiscovererManager'
    -> Word64
    -- ^ /@timeout@/: The timeout to set
    -> m ()
discovererManagerSetTimeout :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererManager a) =>
a -> Word64 -> m ()
discovererManagerSetTimeout a
self Word64
timeout = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiscovererManager
self' <- a -> IO (Ptr DiscovererManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DiscovererManager -> Word64 -> IO ()
ges_discoverer_manager_set_timeout Ptr DiscovererManager
self' Word64
timeout
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DiscovererManagerSetTimeoutMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsDiscovererManager a) => O.OverloadedMethod DiscovererManagerSetTimeoutMethodInfo a signature where
    overloadedMethod = discovererManagerSetTimeout

instance O.OverloadedMethodInfo DiscovererManagerSetTimeoutMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager.discovererManagerSetTimeout",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#v:discovererManagerSetTimeout"
        })


#endif

-- method DiscovererManager::set_use_cache
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "DiscovererManager" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The #GESDiscovererManager"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "use_cache"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Whether to use the cache"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_discoverer_manager_set_use_cache" ges_discoverer_manager_set_use_cache :: 
    Ptr DiscovererManager ->                -- self : TInterface (Name {namespace = "GES", name = "DiscovererManager"})
    CInt ->                                 -- use_cache : TBasicType TBoolean
    IO ()

-- | Sets whether to use the cache or not
-- 
-- /Since: 1.24/
discovererManagerSetUseCache ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererManager a) =>
    a
    -- ^ /@self@/: The t'GI.GES.Objects.DiscovererManager.DiscovererManager'
    -> Bool
    -- ^ /@useCache@/: Whether to use the cache
    -> m ()
discovererManagerSetUseCache :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDiscovererManager a) =>
a -> Bool -> m ()
discovererManagerSetUseCache a
self Bool
useCache = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiscovererManager
self' <- a -> IO (Ptr DiscovererManager)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let useCache' :: CInt
useCache' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
useCache
    Ptr DiscovererManager -> CInt -> IO ()
ges_discoverer_manager_set_use_cache Ptr DiscovererManager
self' CInt
useCache'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data DiscovererManagerSetUseCacheMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDiscovererManager a) => O.OverloadedMethod DiscovererManagerSetUseCacheMethodInfo a signature where
    overloadedMethod = discovererManagerSetUseCache

instance O.OverloadedMethodInfo DiscovererManagerSetUseCacheMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.DiscovererManager.discovererManagerSetUseCache",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-DiscovererManager.html#v:discovererManagerSetUseCache"
        })


#endif

-- method DiscovererManager::get_default
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GES" , name = "DiscovererManager" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_discoverer_manager_get_default" ges_discoverer_manager_get_default :: 
    IO (Ptr DiscovererManager)

-- | /No description available in the introspection data./
-- 
-- /Since: 1.24/
discovererManagerGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m DiscovererManager
    -- ^ __Returns:__ The default t'GI.GES.Objects.DiscovererManager.DiscovererManager'
discovererManagerGetDefault :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m DiscovererManager
discovererManagerGetDefault  = IO DiscovererManager -> m DiscovererManager
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DiscovererManager -> m DiscovererManager)
-> IO DiscovererManager -> m DiscovererManager
forall a b. (a -> b) -> a -> b
$ do
    Ptr DiscovererManager
result <- IO (Ptr DiscovererManager)
ges_discoverer_manager_get_default
    Text -> Ptr DiscovererManager -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"discovererManagerGetDefault" Ptr DiscovererManager
result
    DiscovererManager
result' <- ((ManagedPtr DiscovererManager -> DiscovererManager)
-> Ptr DiscovererManager -> IO DiscovererManager
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr DiscovererManager -> DiscovererManager
DiscovererManager) Ptr DiscovererManager
result
    DiscovererManager -> IO DiscovererManager
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DiscovererManager
result'

#if defined(ENABLE_OVERLOADING)
#endif