{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Registry
(
Registry(..) ,
IsRegistry ,
toRegistry ,
noRegistry ,
#if defined(ENABLE_OVERLOADING)
ResolveRegistryMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RegistryAddFeatureMethodInfo ,
#endif
registryAddFeature ,
#if defined(ENABLE_OVERLOADING)
RegistryAddPluginMethodInfo ,
#endif
registryAddPlugin ,
#if defined(ENABLE_OVERLOADING)
RegistryCheckFeatureVersionMethodInfo ,
#endif
registryCheckFeatureVersion ,
#if defined(ENABLE_OVERLOADING)
RegistryFeatureFilterMethodInfo ,
#endif
registryFeatureFilter ,
#if defined(ENABLE_OVERLOADING)
RegistryFindFeatureMethodInfo ,
#endif
registryFindFeature ,
#if defined(ENABLE_OVERLOADING)
RegistryFindPluginMethodInfo ,
#endif
registryFindPlugin ,
registryForkIsEnabled ,
registryForkSetEnabled ,
registryGet ,
#if defined(ENABLE_OVERLOADING)
RegistryGetFeatureListMethodInfo ,
#endif
registryGetFeatureList ,
#if defined(ENABLE_OVERLOADING)
RegistryGetFeatureListByPluginMethodInfo,
#endif
registryGetFeatureListByPlugin ,
#if defined(ENABLE_OVERLOADING)
RegistryGetFeatureListCookieMethodInfo ,
#endif
registryGetFeatureListCookie ,
#if defined(ENABLE_OVERLOADING)
RegistryGetPluginListMethodInfo ,
#endif
registryGetPluginList ,
#if defined(ENABLE_OVERLOADING)
RegistryLookupMethodInfo ,
#endif
registryLookup ,
#if defined(ENABLE_OVERLOADING)
RegistryLookupFeatureMethodInfo ,
#endif
registryLookupFeature ,
#if defined(ENABLE_OVERLOADING)
RegistryPluginFilterMethodInfo ,
#endif
registryPluginFilter ,
#if defined(ENABLE_OVERLOADING)
RegistryRemoveFeatureMethodInfo ,
#endif
registryRemoveFeature ,
#if defined(ENABLE_OVERLOADING)
RegistryRemovePluginMethodInfo ,
#endif
registryRemovePlugin ,
#if defined(ENABLE_OVERLOADING)
RegistryScanPathMethodInfo ,
#endif
registryScanPath ,
C_RegistryFeatureAddedCallback ,
RegistryFeatureAddedCallback ,
#if defined(ENABLE_OVERLOADING)
RegistryFeatureAddedSignalInfo ,
#endif
afterRegistryFeatureAdded ,
genClosure_RegistryFeatureAdded ,
mk_RegistryFeatureAddedCallback ,
noRegistryFeatureAddedCallback ,
onRegistryFeatureAdded ,
wrap_RegistryFeatureAddedCallback ,
C_RegistryPluginAddedCallback ,
RegistryPluginAddedCallback ,
#if defined(ENABLE_OVERLOADING)
RegistryPluginAddedSignalInfo ,
#endif
afterRegistryPluginAdded ,
genClosure_RegistryPluginAdded ,
mk_RegistryPluginAddedCallback ,
noRegistryPluginAddedCallback ,
onRegistryPluginAdded ,
wrap_RegistryPluginAddedCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin
import {-# SOURCE #-} qualified GI.Gst.Objects.PluginFeature as Gst.PluginFeature
newtype Registry = Registry (ManagedPtr Registry)
deriving (Registry -> Registry -> Bool
(Registry -> Registry -> Bool)
-> (Registry -> Registry -> Bool) -> Eq Registry
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Registry -> Registry -> Bool
$c/= :: Registry -> Registry -> Bool
== :: Registry -> Registry -> Bool
$c== :: Registry -> Registry -> Bool
Eq)
foreign import ccall "gst_registry_get_type"
c_gst_registry_get_type :: IO GType
instance GObject Registry where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_registry_get_type
instance B.GValue.IsGValue Registry where
toGValue :: Registry -> IO GValue
toGValue o :: Registry
o = do
GType
gtype <- IO GType
c_gst_registry_get_type
Registry -> (Ptr Registry -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Registry
o (GType
-> (GValue -> Ptr Registry -> IO ()) -> Ptr Registry -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr Registry -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO Registry
fromGValue gv :: GValue
gv = do
Ptr Registry
ptr <- GValue -> IO (Ptr Registry)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr Registry)
(ManagedPtr Registry -> Registry) -> Ptr Registry -> IO Registry
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Registry -> Registry
Registry Ptr Registry
ptr
class (GObject o, O.IsDescendantOf Registry o) => IsRegistry o
instance (GObject o, O.IsDescendantOf Registry o) => IsRegistry o
instance O.HasParentTypes Registry
type instance O.ParentTypes Registry = '[Gst.Object.Object, GObject.Object.Object]
toRegistry :: (MonadIO m, IsRegistry o) => o -> m Registry
toRegistry :: o -> m Registry
toRegistry = IO Registry -> m Registry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Registry -> m Registry)
-> (o -> IO Registry) -> o -> m Registry
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Registry -> Registry) -> o -> IO Registry
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Registry -> Registry
Registry
noRegistry :: Maybe Registry
noRegistry :: Maybe Registry
noRegistry = Maybe Registry
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveRegistryMethod (t :: Symbol) (o :: *) :: * where
ResolveRegistryMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveRegistryMethod "addFeature" o = RegistryAddFeatureMethodInfo
ResolveRegistryMethod "addPlugin" o = RegistryAddPluginMethodInfo
ResolveRegistryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveRegistryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveRegistryMethod "checkFeatureVersion" o = RegistryCheckFeatureVersionMethodInfo
ResolveRegistryMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveRegistryMethod "featureFilter" o = RegistryFeatureFilterMethodInfo
ResolveRegistryMethod "findFeature" o = RegistryFindFeatureMethodInfo
ResolveRegistryMethod "findPlugin" o = RegistryFindPluginMethodInfo
ResolveRegistryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveRegistryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveRegistryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveRegistryMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveRegistryMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveRegistryMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveRegistryMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveRegistryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveRegistryMethod "lookup" o = RegistryLookupMethodInfo
ResolveRegistryMethod "lookupFeature" o = RegistryLookupFeatureMethodInfo
ResolveRegistryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveRegistryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveRegistryMethod "pluginFilter" o = RegistryPluginFilterMethodInfo
ResolveRegistryMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveRegistryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveRegistryMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveRegistryMethod "removeFeature" o = RegistryRemoveFeatureMethodInfo
ResolveRegistryMethod "removePlugin" o = RegistryRemovePluginMethodInfo
ResolveRegistryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveRegistryMethod "scanPath" o = RegistryScanPathMethodInfo
ResolveRegistryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveRegistryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveRegistryMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveRegistryMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveRegistryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveRegistryMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveRegistryMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveRegistryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveRegistryMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveRegistryMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveRegistryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveRegistryMethod "getFeatureList" o = RegistryGetFeatureListMethodInfo
ResolveRegistryMethod "getFeatureListByPlugin" o = RegistryGetFeatureListByPluginMethodInfo
ResolveRegistryMethod "getFeatureListCookie" o = RegistryGetFeatureListCookieMethodInfo
ResolveRegistryMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveRegistryMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveRegistryMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveRegistryMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveRegistryMethod "getPluginList" o = RegistryGetPluginListMethodInfo
ResolveRegistryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveRegistryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveRegistryMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveRegistryMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveRegistryMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveRegistryMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveRegistryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveRegistryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveRegistryMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveRegistryMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveRegistryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveRegistryMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRegistryMethod t Registry, O.MethodInfo info Registry p) => OL.IsLabel t (Registry -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
type RegistryFeatureAddedCallback =
Gst.PluginFeature.PluginFeature
-> IO ()
noRegistryFeatureAddedCallback :: Maybe RegistryFeatureAddedCallback
noRegistryFeatureAddedCallback :: Maybe RegistryFeatureAddedCallback
noRegistryFeatureAddedCallback = Maybe RegistryFeatureAddedCallback
forall a. Maybe a
Nothing
type C_RegistryFeatureAddedCallback =
Ptr () ->
Ptr Gst.PluginFeature.PluginFeature ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_RegistryFeatureAddedCallback :: C_RegistryFeatureAddedCallback -> IO (FunPtr C_RegistryFeatureAddedCallback)
genClosure_RegistryFeatureAdded :: MonadIO m => RegistryFeatureAddedCallback -> m (GClosure C_RegistryFeatureAddedCallback)
genClosure_RegistryFeatureAdded :: RegistryFeatureAddedCallback
-> m (GClosure C_RegistryFeatureAddedCallback)
genClosure_RegistryFeatureAdded cb :: RegistryFeatureAddedCallback
cb = IO (GClosure C_RegistryFeatureAddedCallback)
-> m (GClosure C_RegistryFeatureAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RegistryFeatureAddedCallback)
-> m (GClosure C_RegistryFeatureAddedCallback))
-> IO (GClosure C_RegistryFeatureAddedCallback)
-> m (GClosure C_RegistryFeatureAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryFeatureAddedCallback
cb' = RegistryFeatureAddedCallback -> C_RegistryFeatureAddedCallback
wrap_RegistryFeatureAddedCallback RegistryFeatureAddedCallback
cb
C_RegistryFeatureAddedCallback
-> IO (FunPtr C_RegistryFeatureAddedCallback)
mk_RegistryFeatureAddedCallback C_RegistryFeatureAddedCallback
cb' IO (FunPtr C_RegistryFeatureAddedCallback)
-> (FunPtr C_RegistryFeatureAddedCallback
-> IO (GClosure C_RegistryFeatureAddedCallback))
-> IO (GClosure C_RegistryFeatureAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RegistryFeatureAddedCallback
-> IO (GClosure C_RegistryFeatureAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RegistryFeatureAddedCallback ::
RegistryFeatureAddedCallback ->
C_RegistryFeatureAddedCallback
wrap_RegistryFeatureAddedCallback :: RegistryFeatureAddedCallback -> C_RegistryFeatureAddedCallback
wrap_RegistryFeatureAddedCallback _cb :: RegistryFeatureAddedCallback
_cb _ feature :: Ptr PluginFeature
feature _ = do
PluginFeature
feature' <- ((ManagedPtr PluginFeature -> PluginFeature)
-> Ptr PluginFeature -> IO PluginFeature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PluginFeature -> PluginFeature
Gst.PluginFeature.PluginFeature) Ptr PluginFeature
feature
RegistryFeatureAddedCallback
_cb PluginFeature
feature'
onRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId
onRegistryFeatureAdded :: a -> RegistryFeatureAddedCallback -> m SignalHandlerId
onRegistryFeatureAdded obj :: a
obj cb :: RegistryFeatureAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryFeatureAddedCallback
cb' = RegistryFeatureAddedCallback -> C_RegistryFeatureAddedCallback
wrap_RegistryFeatureAddedCallback RegistryFeatureAddedCallback
cb
FunPtr C_RegistryFeatureAddedCallback
cb'' <- C_RegistryFeatureAddedCallback
-> IO (FunPtr C_RegistryFeatureAddedCallback)
mk_RegistryFeatureAddedCallback C_RegistryFeatureAddedCallback
cb'
a
-> Text
-> FunPtr C_RegistryFeatureAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "feature-added" FunPtr C_RegistryFeatureAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId
afterRegistryFeatureAdded :: a -> RegistryFeatureAddedCallback -> m SignalHandlerId
afterRegistryFeatureAdded obj :: a
obj cb :: RegistryFeatureAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryFeatureAddedCallback
cb' = RegistryFeatureAddedCallback -> C_RegistryFeatureAddedCallback
wrap_RegistryFeatureAddedCallback RegistryFeatureAddedCallback
cb
FunPtr C_RegistryFeatureAddedCallback
cb'' <- C_RegistryFeatureAddedCallback
-> IO (FunPtr C_RegistryFeatureAddedCallback)
mk_RegistryFeatureAddedCallback C_RegistryFeatureAddedCallback
cb'
a
-> Text
-> FunPtr C_RegistryFeatureAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "feature-added" FunPtr C_RegistryFeatureAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data RegistryFeatureAddedSignalInfo
instance SignalInfo RegistryFeatureAddedSignalInfo where
type HaskellCallbackType RegistryFeatureAddedSignalInfo = RegistryFeatureAddedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_RegistryFeatureAddedCallback cb
cb'' <- mk_RegistryFeatureAddedCallback cb'
connectSignalFunPtr obj "feature-added" cb'' connectMode detail
#endif
type RegistryPluginAddedCallback =
Gst.Plugin.Plugin
-> IO ()
noRegistryPluginAddedCallback :: Maybe RegistryPluginAddedCallback
noRegistryPluginAddedCallback :: Maybe RegistryPluginAddedCallback
noRegistryPluginAddedCallback = Maybe RegistryPluginAddedCallback
forall a. Maybe a
Nothing
type C_RegistryPluginAddedCallback =
Ptr () ->
Ptr Gst.Plugin.Plugin ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_RegistryPluginAddedCallback :: C_RegistryPluginAddedCallback -> IO (FunPtr C_RegistryPluginAddedCallback)
genClosure_RegistryPluginAdded :: MonadIO m => RegistryPluginAddedCallback -> m (GClosure C_RegistryPluginAddedCallback)
genClosure_RegistryPluginAdded :: RegistryPluginAddedCallback
-> m (GClosure C_RegistryPluginAddedCallback)
genClosure_RegistryPluginAdded cb :: RegistryPluginAddedCallback
cb = IO (GClosure C_RegistryPluginAddedCallback)
-> m (GClosure C_RegistryPluginAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_RegistryPluginAddedCallback)
-> m (GClosure C_RegistryPluginAddedCallback))
-> IO (GClosure C_RegistryPluginAddedCallback)
-> m (GClosure C_RegistryPluginAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryPluginAddedCallback
cb' = RegistryPluginAddedCallback -> C_RegistryPluginAddedCallback
wrap_RegistryPluginAddedCallback RegistryPluginAddedCallback
cb
C_RegistryPluginAddedCallback
-> IO (FunPtr C_RegistryPluginAddedCallback)
mk_RegistryPluginAddedCallback C_RegistryPluginAddedCallback
cb' IO (FunPtr C_RegistryPluginAddedCallback)
-> (FunPtr C_RegistryPluginAddedCallback
-> IO (GClosure C_RegistryPluginAddedCallback))
-> IO (GClosure C_RegistryPluginAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_RegistryPluginAddedCallback
-> IO (GClosure C_RegistryPluginAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_RegistryPluginAddedCallback ::
RegistryPluginAddedCallback ->
C_RegistryPluginAddedCallback
wrap_RegistryPluginAddedCallback :: RegistryPluginAddedCallback -> C_RegistryPluginAddedCallback
wrap_RegistryPluginAddedCallback _cb :: RegistryPluginAddedCallback
_cb _ plugin :: Ptr Plugin
plugin _ = do
Plugin
plugin' <- ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Plugin -> Plugin
Gst.Plugin.Plugin) Ptr Plugin
plugin
RegistryPluginAddedCallback
_cb Plugin
plugin'
onRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId
onRegistryPluginAdded :: a -> RegistryPluginAddedCallback -> m SignalHandlerId
onRegistryPluginAdded obj :: a
obj cb :: RegistryPluginAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryPluginAddedCallback
cb' = RegistryPluginAddedCallback -> C_RegistryPluginAddedCallback
wrap_RegistryPluginAddedCallback RegistryPluginAddedCallback
cb
FunPtr C_RegistryPluginAddedCallback
cb'' <- C_RegistryPluginAddedCallback
-> IO (FunPtr C_RegistryPluginAddedCallback)
mk_RegistryPluginAddedCallback C_RegistryPluginAddedCallback
cb'
a
-> Text
-> FunPtr C_RegistryPluginAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "plugin-added" FunPtr C_RegistryPluginAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId
afterRegistryPluginAdded :: a -> RegistryPluginAddedCallback -> m SignalHandlerId
afterRegistryPluginAdded obj :: a
obj cb :: RegistryPluginAddedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_RegistryPluginAddedCallback
cb' = RegistryPluginAddedCallback -> C_RegistryPluginAddedCallback
wrap_RegistryPluginAddedCallback RegistryPluginAddedCallback
cb
FunPtr C_RegistryPluginAddedCallback
cb'' <- C_RegistryPluginAddedCallback
-> IO (FunPtr C_RegistryPluginAddedCallback)
mk_RegistryPluginAddedCallback C_RegistryPluginAddedCallback
cb'
a
-> Text
-> FunPtr C_RegistryPluginAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "plugin-added" FunPtr C_RegistryPluginAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data RegistryPluginAddedSignalInfo
instance SignalInfo RegistryPluginAddedSignalInfo where
type HaskellCallbackType RegistryPluginAddedSignalInfo = RegistryPluginAddedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_RegistryPluginAddedCallback cb
cb'' <- mk_RegistryPluginAddedCallback cb'
connectSignalFunPtr obj "plugin-added" cb'' connectMode detail
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Registry
type instance O.AttributeList Registry = RegistryAttributeList
type RegistryAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Registry = RegistrySignalList
type RegistrySignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("featureAdded", RegistryFeatureAddedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pluginAdded", RegistryPluginAddedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_registry_add_feature" gst_registry_add_feature ::
Ptr Registry ->
Ptr Gst.PluginFeature.PluginFeature ->
IO CInt
registryAddFeature ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) =>
a
-> b
-> m Bool
registryAddFeature :: a -> b -> m Bool
registryAddFeature registry :: a
registry feature :: b
feature = 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 Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr PluginFeature
feature' <- b -> IO (Ptr PluginFeature)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
feature
CInt
result <- Ptr Registry -> Ptr PluginFeature -> IO CInt
gst_registry_add_feature Ptr Registry
registry' Ptr PluginFeature
feature'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
feature
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistryAddFeatureMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) => O.MethodInfo RegistryAddFeatureMethodInfo a signature where
overloadedMethod = registryAddFeature
#endif
foreign import ccall "gst_registry_add_plugin" gst_registry_add_plugin ::
Ptr Registry ->
Ptr Gst.Plugin.Plugin ->
IO CInt
registryAddPlugin ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) =>
a
-> b
-> m Bool
registryAddPlugin :: a -> b -> m Bool
registryAddPlugin registry :: a
registry plugin :: b
plugin = 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 Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr Plugin
plugin' <- b -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
plugin
CInt
result <- Ptr Registry -> Ptr Plugin -> IO CInt
gst_registry_add_plugin Ptr Registry
registry' Ptr Plugin
plugin'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
plugin
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistryAddPluginMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) => O.MethodInfo RegistryAddPluginMethodInfo a signature where
overloadedMethod = registryAddPlugin
#endif
foreign import ccall "gst_registry_check_feature_version" gst_registry_check_feature_version ::
Ptr Registry ->
CString ->
Word32 ->
Word32 ->
Word32 ->
IO CInt
registryCheckFeatureVersion ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> Word32
-> Word32
-> Word32
-> m Bool
registryCheckFeatureVersion :: a -> Text -> Word32 -> Word32 -> Word32 -> m Bool
registryCheckFeatureVersion registry :: a
registry featureName :: Text
featureName minMajor :: Word32
minMajor minMinor :: Word32
minMinor minMicro :: Word32
minMicro = 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 Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
featureName' <- Text -> IO CString
textToCString Text
featureName
CInt
result <- Ptr Registry -> CString -> Word32 -> Word32 -> Word32 -> IO CInt
gst_registry_check_feature_version Ptr Registry
registry' CString
featureName' Word32
minMajor Word32
minMinor Word32
minMicro
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
featureName'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistryCheckFeatureVersionMethodInfo
instance (signature ~ (T.Text -> Word32 -> Word32 -> Word32 -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistryCheckFeatureVersionMethodInfo a signature where
overloadedMethod = registryCheckFeatureVersion
#endif
foreign import ccall "gst_registry_feature_filter" gst_registry_feature_filter ::
Ptr Registry ->
FunPtr Gst.Callbacks.C_PluginFeatureFilter ->
CInt ->
Ptr () ->
IO (Ptr (GList (Ptr Gst.PluginFeature.PluginFeature)))
registryFeatureFilter ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> Gst.Callbacks.PluginFeatureFilter
-> Bool
-> m [Gst.PluginFeature.PluginFeature]
registryFeatureFilter :: a -> PluginFeatureFilter -> Bool -> m [PluginFeature]
registryFeatureFilter registry :: a
registry filter :: PluginFeatureFilter
filter first :: Bool
first = IO [PluginFeature] -> m [PluginFeature]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [PluginFeature] -> m [PluginFeature])
-> IO [PluginFeature] -> m [PluginFeature]
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
FunPtr C_PluginFeatureFilter
filter' <- C_PluginFeatureFilter -> IO (FunPtr C_PluginFeatureFilter)
Gst.Callbacks.mk_PluginFeatureFilter (Maybe (Ptr (FunPtr C_PluginFeatureFilter))
-> PluginFeatureFilter_WithClosures -> C_PluginFeatureFilter
Gst.Callbacks.wrap_PluginFeatureFilter Maybe (Ptr (FunPtr C_PluginFeatureFilter))
forall a. Maybe a
Nothing (PluginFeatureFilter -> PluginFeatureFilter_WithClosures
Gst.Callbacks.drop_closures_PluginFeatureFilter PluginFeatureFilter
filter))
let first' :: CInt
first' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
first
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr (GList (Ptr PluginFeature))
result <- Ptr Registry
-> FunPtr C_PluginFeatureFilter
-> CInt
-> Ptr ()
-> IO (Ptr (GList (Ptr PluginFeature)))
gst_registry_feature_filter Ptr Registry
registry' FunPtr C_PluginFeatureFilter
filter' CInt
first' Ptr ()
forall a. Ptr a
userData
[Ptr PluginFeature]
result' <- Ptr (GList (Ptr PluginFeature)) -> IO [Ptr PluginFeature]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr PluginFeature))
result
[PluginFeature]
result'' <- (Ptr PluginFeature -> IO PluginFeature)
-> [Ptr PluginFeature] -> IO [PluginFeature]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr PluginFeature -> PluginFeature)
-> Ptr PluginFeature -> IO PluginFeature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PluginFeature -> PluginFeature
Gst.PluginFeature.PluginFeature) [Ptr PluginFeature]
result'
Ptr (GList (Ptr PluginFeature)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr PluginFeature))
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_PluginFeatureFilter -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PluginFeatureFilter
filter'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
[PluginFeature] -> IO [PluginFeature]
forall (m :: * -> *) a. Monad m => a -> m a
return [PluginFeature]
result''
#if defined(ENABLE_OVERLOADING)
data RegistryFeatureFilterMethodInfo
instance (signature ~ (Gst.Callbacks.PluginFeatureFilter -> Bool -> m [Gst.PluginFeature.PluginFeature]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryFeatureFilterMethodInfo a signature where
overloadedMethod = registryFeatureFilter
#endif
foreign import ccall "gst_registry_find_feature" gst_registry_find_feature ::
Ptr Registry ->
CString ->
CGType ->
IO (Ptr Gst.PluginFeature.PluginFeature)
registryFindFeature ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> GType
-> m (Maybe Gst.PluginFeature.PluginFeature)
registryFindFeature :: a -> Text -> GType -> m (Maybe PluginFeature)
registryFindFeature registry :: a
registry name :: Text
name type_ :: GType
type_ = IO (Maybe PluginFeature) -> m (Maybe PluginFeature)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PluginFeature) -> m (Maybe PluginFeature))
-> IO (Maybe PluginFeature) -> m (Maybe PluginFeature)
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
name' <- Text -> IO CString
textToCString Text
name
let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
Ptr PluginFeature
result <- Ptr Registry -> CString -> CGType -> IO (Ptr PluginFeature)
gst_registry_find_feature Ptr Registry
registry' CString
name' CGType
type_'
Maybe PluginFeature
maybeResult <- Ptr PluginFeature
-> (Ptr PluginFeature -> IO PluginFeature)
-> IO (Maybe PluginFeature)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PluginFeature
result ((Ptr PluginFeature -> IO PluginFeature)
-> IO (Maybe PluginFeature))
-> (Ptr PluginFeature -> IO PluginFeature)
-> IO (Maybe PluginFeature)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr PluginFeature
result' -> do
PluginFeature
result'' <- ((ManagedPtr PluginFeature -> PluginFeature)
-> Ptr PluginFeature -> IO PluginFeature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PluginFeature -> PluginFeature
Gst.PluginFeature.PluginFeature) Ptr PluginFeature
result'
PluginFeature -> IO PluginFeature
forall (m :: * -> *) a. Monad m => a -> m a
return PluginFeature
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe PluginFeature -> IO (Maybe PluginFeature)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PluginFeature
maybeResult
#if defined(ENABLE_OVERLOADING)
data RegistryFindFeatureMethodInfo
instance (signature ~ (T.Text -> GType -> m (Maybe Gst.PluginFeature.PluginFeature)), MonadIO m, IsRegistry a) => O.MethodInfo RegistryFindFeatureMethodInfo a signature where
overloadedMethod = registryFindFeature
#endif
foreign import ccall "gst_registry_find_plugin" gst_registry_find_plugin ::
Ptr Registry ->
CString ->
IO (Ptr Gst.Plugin.Plugin)
registryFindPlugin ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> m (Maybe Gst.Plugin.Plugin)
registryFindPlugin :: a -> Text -> m (Maybe Plugin)
registryFindPlugin registry :: a
registry name :: Text
name = IO (Maybe Plugin) -> m (Maybe Plugin)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Plugin) -> m (Maybe Plugin))
-> IO (Maybe Plugin) -> m (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Plugin
result <- Ptr Registry -> CString -> IO (Ptr Plugin)
gst_registry_find_plugin Ptr Registry
registry' CString
name'
Maybe Plugin
maybeResult <- Ptr Plugin -> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Plugin
result ((Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin))
-> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Plugin
result' -> do
Plugin
result'' <- ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Plugin -> Plugin
Gst.Plugin.Plugin) Ptr Plugin
result'
Plugin -> IO Plugin
forall (m :: * -> *) a. Monad m => a -> m a
return Plugin
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe Plugin -> IO (Maybe Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Plugin
maybeResult
#if defined(ENABLE_OVERLOADING)
data RegistryFindPluginMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.Plugin.Plugin)), MonadIO m, IsRegistry a) => O.MethodInfo RegistryFindPluginMethodInfo a signature where
overloadedMethod = registryFindPlugin
#endif
foreign import ccall "gst_registry_get_feature_list" gst_registry_get_feature_list ::
Ptr Registry ->
CGType ->
IO (Ptr (GList (Ptr Gst.PluginFeature.PluginFeature)))
registryGetFeatureList ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> GType
-> m [Gst.PluginFeature.PluginFeature]
registryGetFeatureList :: a -> GType -> m [PluginFeature]
registryGetFeatureList registry :: a
registry type_ :: GType
type_ = IO [PluginFeature] -> m [PluginFeature]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [PluginFeature] -> m [PluginFeature])
-> IO [PluginFeature] -> m [PluginFeature]
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
let type_' :: CGType
type_' = GType -> CGType
gtypeToCGType GType
type_
Ptr (GList (Ptr PluginFeature))
result <- Ptr Registry -> CGType -> IO (Ptr (GList (Ptr PluginFeature)))
gst_registry_get_feature_list Ptr Registry
registry' CGType
type_'
[Ptr PluginFeature]
result' <- Ptr (GList (Ptr PluginFeature)) -> IO [Ptr PluginFeature]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr PluginFeature))
result
[PluginFeature]
result'' <- (Ptr PluginFeature -> IO PluginFeature)
-> [Ptr PluginFeature] -> IO [PluginFeature]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr PluginFeature -> PluginFeature)
-> Ptr PluginFeature -> IO PluginFeature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PluginFeature -> PluginFeature
Gst.PluginFeature.PluginFeature) [Ptr PluginFeature]
result'
Ptr (GList (Ptr PluginFeature)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr PluginFeature))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
[PluginFeature] -> IO [PluginFeature]
forall (m :: * -> *) a. Monad m => a -> m a
return [PluginFeature]
result''
#if defined(ENABLE_OVERLOADING)
data RegistryGetFeatureListMethodInfo
instance (signature ~ (GType -> m [Gst.PluginFeature.PluginFeature]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetFeatureListMethodInfo a signature where
overloadedMethod = registryGetFeatureList
#endif
foreign import ccall "gst_registry_get_feature_list_by_plugin" gst_registry_get_feature_list_by_plugin ::
Ptr Registry ->
CString ->
IO (Ptr (GList (Ptr Gst.PluginFeature.PluginFeature)))
registryGetFeatureListByPlugin ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> m [Gst.PluginFeature.PluginFeature]
registryGetFeatureListByPlugin :: a -> Text -> m [PluginFeature]
registryGetFeatureListByPlugin registry :: a
registry name :: Text
name = IO [PluginFeature] -> m [PluginFeature]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [PluginFeature] -> m [PluginFeature])
-> IO [PluginFeature] -> m [PluginFeature]
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr (GList (Ptr PluginFeature))
result <- Ptr Registry -> CString -> IO (Ptr (GList (Ptr PluginFeature)))
gst_registry_get_feature_list_by_plugin Ptr Registry
registry' CString
name'
[Ptr PluginFeature]
result' <- Ptr (GList (Ptr PluginFeature)) -> IO [Ptr PluginFeature]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr PluginFeature))
result
[PluginFeature]
result'' <- (Ptr PluginFeature -> IO PluginFeature)
-> [Ptr PluginFeature] -> IO [PluginFeature]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr PluginFeature -> PluginFeature)
-> Ptr PluginFeature -> IO PluginFeature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PluginFeature -> PluginFeature
Gst.PluginFeature.PluginFeature) [Ptr PluginFeature]
result'
Ptr (GList (Ptr PluginFeature)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr PluginFeature))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
[PluginFeature] -> IO [PluginFeature]
forall (m :: * -> *) a. Monad m => a -> m a
return [PluginFeature]
result''
#if defined(ENABLE_OVERLOADING)
data RegistryGetFeatureListByPluginMethodInfo
instance (signature ~ (T.Text -> m [Gst.PluginFeature.PluginFeature]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetFeatureListByPluginMethodInfo a signature where
overloadedMethod = registryGetFeatureListByPlugin
#endif
foreign import ccall "gst_registry_get_feature_list_cookie" gst_registry_get_feature_list_cookie ::
Ptr Registry ->
IO Word32
registryGetFeatureListCookie ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> m Word32
registryGetFeatureListCookie :: a -> m Word32
registryGetFeatureListCookie registry :: a
registry = IO Word32 -> m Word32
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Word32
result <- Ptr Registry -> IO Word32
gst_registry_get_feature_list_cookie Ptr Registry
registry'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data RegistryGetFeatureListCookieMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetFeatureListCookieMethodInfo a signature where
overloadedMethod = registryGetFeatureListCookie
#endif
foreign import ccall "gst_registry_get_plugin_list" gst_registry_get_plugin_list ::
Ptr Registry ->
IO (Ptr (GList (Ptr Gst.Plugin.Plugin)))
registryGetPluginList ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> m [Gst.Plugin.Plugin]
registryGetPluginList :: a -> m [Plugin]
registryGetPluginList registry :: a
registry = IO [Plugin] -> m [Plugin]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Plugin] -> m [Plugin]) -> IO [Plugin] -> m [Plugin]
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr (GList (Ptr Plugin))
result <- Ptr Registry -> IO (Ptr (GList (Ptr Plugin)))
gst_registry_get_plugin_list Ptr Registry
registry'
[Ptr Plugin]
result' <- Ptr (GList (Ptr Plugin)) -> IO [Ptr Plugin]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Plugin))
result
[Plugin]
result'' <- (Ptr Plugin -> IO Plugin) -> [Ptr Plugin] -> IO [Plugin]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Plugin -> Plugin
Gst.Plugin.Plugin) [Ptr Plugin]
result'
Ptr (GList (Ptr Plugin)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Plugin))
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
[Plugin] -> IO [Plugin]
forall (m :: * -> *) a. Monad m => a -> m a
return [Plugin]
result''
#if defined(ENABLE_OVERLOADING)
data RegistryGetPluginListMethodInfo
instance (signature ~ (m [Gst.Plugin.Plugin]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryGetPluginListMethodInfo a signature where
overloadedMethod = registryGetPluginList
#endif
foreign import ccall "gst_registry_lookup" gst_registry_lookup ::
Ptr Registry ->
CString ->
IO (Ptr Gst.Plugin.Plugin)
registryLookup ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> m (Maybe Gst.Plugin.Plugin)
registryLookup :: a -> Text -> m (Maybe Plugin)
registryLookup registry :: a
registry filename :: Text
filename = IO (Maybe Plugin) -> m (Maybe Plugin)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Plugin) -> m (Maybe Plugin))
-> IO (Maybe Plugin) -> m (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
filename' <- Text -> IO CString
textToCString Text
filename
Ptr Plugin
result <- Ptr Registry -> CString -> IO (Ptr Plugin)
gst_registry_lookup Ptr Registry
registry' CString
filename'
Maybe Plugin
maybeResult <- Ptr Plugin -> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Plugin
result ((Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin))
-> (Ptr Plugin -> IO Plugin) -> IO (Maybe Plugin)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Plugin
result' -> do
Plugin
result'' <- ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Plugin -> Plugin
Gst.Plugin.Plugin) Ptr Plugin
result'
Plugin -> IO Plugin
forall (m :: * -> *) a. Monad m => a -> m a
return Plugin
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
filename'
Maybe Plugin -> IO (Maybe Plugin)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Plugin
maybeResult
#if defined(ENABLE_OVERLOADING)
data RegistryLookupMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gst.Plugin.Plugin)), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLookupMethodInfo a signature where
overloadedMethod = registryLookup
#endif
foreign import ccall "gst_registry_lookup_feature" gst_registry_lookup_feature ::
Ptr Registry ->
CString ->
IO (Ptr Gst.PluginFeature.PluginFeature)
registryLookupFeature ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> T.Text
-> m Gst.PluginFeature.PluginFeature
registryLookupFeature :: a -> Text -> m PluginFeature
registryLookupFeature registry :: a
registry name :: Text
name = IO PluginFeature -> m PluginFeature
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PluginFeature -> m PluginFeature)
-> IO PluginFeature -> m PluginFeature
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr PluginFeature
result <- Ptr Registry -> CString -> IO (Ptr PluginFeature)
gst_registry_lookup_feature Ptr Registry
registry' CString
name'
Text -> Ptr PluginFeature -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "registryLookupFeature" Ptr PluginFeature
result
PluginFeature
result' <- ((ManagedPtr PluginFeature -> PluginFeature)
-> Ptr PluginFeature -> IO PluginFeature
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PluginFeature -> PluginFeature
Gst.PluginFeature.PluginFeature) Ptr PluginFeature
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
PluginFeature -> IO PluginFeature
forall (m :: * -> *) a. Monad m => a -> m a
return PluginFeature
result'
#if defined(ENABLE_OVERLOADING)
data RegistryLookupFeatureMethodInfo
instance (signature ~ (T.Text -> m Gst.PluginFeature.PluginFeature), MonadIO m, IsRegistry a) => O.MethodInfo RegistryLookupFeatureMethodInfo a signature where
overloadedMethod = registryLookupFeature
#endif
foreign import ccall "gst_registry_plugin_filter" gst_registry_plugin_filter ::
Ptr Registry ->
FunPtr Gst.Callbacks.C_PluginFilter ->
CInt ->
Ptr () ->
IO (Ptr (GList (Ptr Gst.Plugin.Plugin)))
registryPluginFilter ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> Gst.Callbacks.PluginFilter
-> Bool
-> m [Gst.Plugin.Plugin]
registryPluginFilter :: a -> PluginFilter -> Bool -> m [Plugin]
registryPluginFilter registry :: a
registry filter :: PluginFilter
filter first :: Bool
first = IO [Plugin] -> m [Plugin]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Plugin] -> m [Plugin]) -> IO [Plugin] -> m [Plugin]
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
FunPtr C_PluginFilter
filter' <- C_PluginFilter -> IO (FunPtr C_PluginFilter)
Gst.Callbacks.mk_PluginFilter (Maybe (Ptr (FunPtr C_PluginFilter))
-> PluginFilter_WithClosures -> C_PluginFilter
Gst.Callbacks.wrap_PluginFilter Maybe (Ptr (FunPtr C_PluginFilter))
forall a. Maybe a
Nothing (PluginFilter -> PluginFilter_WithClosures
Gst.Callbacks.drop_closures_PluginFilter PluginFilter
filter))
let first' :: CInt
first' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
first
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr (GList (Ptr Plugin))
result <- Ptr Registry
-> FunPtr C_PluginFilter
-> CInt
-> Ptr ()
-> IO (Ptr (GList (Ptr Plugin)))
gst_registry_plugin_filter Ptr Registry
registry' FunPtr C_PluginFilter
filter' CInt
first' Ptr ()
forall a. Ptr a
userData
[Ptr Plugin]
result' <- Ptr (GList (Ptr Plugin)) -> IO [Ptr Plugin]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr Plugin))
result
[Plugin]
result'' <- (Ptr Plugin -> IO Plugin) -> [Ptr Plugin] -> IO [Plugin]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr Plugin -> Plugin) -> Ptr Plugin -> IO Plugin
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Plugin -> Plugin
Gst.Plugin.Plugin) [Ptr Plugin]
result'
Ptr (GList (Ptr Plugin)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr Plugin))
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_PluginFilter -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PluginFilter
filter'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
[Plugin] -> IO [Plugin]
forall (m :: * -> *) a. Monad m => a -> m a
return [Plugin]
result''
#if defined(ENABLE_OVERLOADING)
data RegistryPluginFilterMethodInfo
instance (signature ~ (Gst.Callbacks.PluginFilter -> Bool -> m [Gst.Plugin.Plugin]), MonadIO m, IsRegistry a) => O.MethodInfo RegistryPluginFilterMethodInfo a signature where
overloadedMethod = registryPluginFilter
#endif
foreign import ccall "gst_registry_remove_feature" gst_registry_remove_feature ::
Ptr Registry ->
Ptr Gst.PluginFeature.PluginFeature ->
IO ()
registryRemoveFeature ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) =>
a
-> b
-> m ()
registryRemoveFeature :: a -> b -> m ()
registryRemoveFeature registry :: a
registry feature :: b
feature = 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 Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr PluginFeature
feature' <- b -> IO (Ptr PluginFeature)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
feature
Ptr Registry -> Ptr PluginFeature -> IO ()
gst_registry_remove_feature Ptr Registry
registry' Ptr PluginFeature
feature'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
feature
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegistryRemoveFeatureMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsRegistry a, Gst.PluginFeature.IsPluginFeature b) => O.MethodInfo RegistryRemoveFeatureMethodInfo a signature where
overloadedMethod = registryRemoveFeature
#endif
foreign import ccall "gst_registry_remove_plugin" gst_registry_remove_plugin ::
Ptr Registry ->
Ptr Gst.Plugin.Plugin ->
IO ()
registryRemovePlugin ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) =>
a
-> b
-> m ()
registryRemovePlugin :: a -> b -> m ()
registryRemovePlugin registry :: a
registry plugin :: b
plugin = 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 Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
Ptr Plugin
plugin' <- b -> IO (Ptr Plugin)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
plugin
Ptr Registry -> Ptr Plugin -> IO ()
gst_registry_remove_plugin Ptr Registry
registry' Ptr Plugin
plugin'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
plugin
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data RegistryRemovePluginMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsRegistry a, Gst.Plugin.IsPlugin b) => O.MethodInfo RegistryRemovePluginMethodInfo a signature where
overloadedMethod = registryRemovePlugin
#endif
foreign import ccall "gst_registry_scan_path" gst_registry_scan_path ::
Ptr Registry ->
CString ->
IO CInt
registryScanPath ::
(B.CallStack.HasCallStack, MonadIO m, IsRegistry a) =>
a
-> [Char]
-> m Bool
registryScanPath :: a -> [Char] -> m Bool
registryScanPath registry :: a
registry path :: [Char]
path = 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 Registry
registry' <- a -> IO (Ptr Registry)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
registry
CString
path' <- [Char] -> IO CString
stringToCString [Char]
path
CInt
result <- Ptr Registry -> CString -> IO CInt
gst_registry_scan_path Ptr Registry
registry' CString
path'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
registry
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
path'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data RegistryScanPathMethodInfo
instance (signature ~ ([Char] -> m Bool), MonadIO m, IsRegistry a) => O.MethodInfo RegistryScanPathMethodInfo a signature where
overloadedMethod = registryScanPath
#endif
foreign import ccall "gst_registry_fork_is_enabled" gst_registry_fork_is_enabled ::
IO CInt
registryForkIsEnabled ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Bool
registryForkIsEnabled :: m Bool
registryForkIsEnabled = 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
CInt
result <- IO CInt
gst_registry_fork_is_enabled
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_registry_fork_set_enabled" gst_registry_fork_set_enabled ::
CInt ->
IO ()
registryForkSetEnabled ::
(B.CallStack.HasCallStack, MonadIO m) =>
Bool
-> m ()
registryForkSetEnabled :: Bool -> m ()
registryForkSetEnabled enabled :: Bool
enabled = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let enabled' :: CInt
enabled' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
enabled
CInt -> IO ()
gst_registry_fork_set_enabled CInt
enabled'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_registry_get" gst_registry_get ::
IO (Ptr Registry)
registryGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Registry
registryGet :: m Registry
registryGet = IO Registry -> m Registry
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Registry -> m Registry) -> IO Registry -> m Registry
forall a b. (a -> b) -> a -> b
$ do
Ptr Registry
result <- IO (Ptr Registry)
gst_registry_get
Text -> Ptr Registry -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "registryGet" Ptr Registry
result
Registry
result' <- ((ManagedPtr Registry -> Registry) -> Ptr Registry -> IO Registry
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Registry -> Registry
Registry) Ptr Registry
result
Registry -> IO Registry
forall (m :: * -> *) a. Monad m => a -> m a
return Registry
result'
#if defined(ENABLE_OVERLOADING)
#endif