{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- t'GI.Gst.Objects.DynamicTypeFactory.DynamicTypeFactory' is used to represent a type that can be
-- automatically loaded the first time it is used. For example,
-- a non-standard type for use in caps fields.
-- 
-- In general, applications and plugins don\'t need to use the factory
-- beyond registering the type in a plugin init function. Once that is
-- done, the type is stored in the registry, and ready as soon as the
-- registry is loaded.
-- 
-- == Registering a type for dynamic loading
-- 
-- 
-- === /C code/
-- >
-- >
-- >static gboolean
-- >plugin_init (GstPlugin * plugin)
-- >{
-- >  return gst_dynamic_type_register (plugin, GST_TYPE_CUSTOM_CAPS_FIELD);
-- >}
-- 

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

module GI.Gst.Objects.DynamicTypeFactory
    ( 

-- * Exported types
    DynamicTypeFactory(..)                  ,
    IsDynamicTypeFactory                    ,
    toDynamicTypeFactory                    ,
    noDynamicTypeFactory                    ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveDynamicTypeFactoryMethod         ,
#endif


-- ** load #method:load#

    dynamicTypeFactoryLoad                  ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.PluginFeature as Gst.PluginFeature

-- | Memory-managed wrapper type.
newtype DynamicTypeFactory = DynamicTypeFactory (ManagedPtr DynamicTypeFactory)
    deriving (DynamicTypeFactory -> DynamicTypeFactory -> Bool
(DynamicTypeFactory -> DynamicTypeFactory -> Bool)
-> (DynamicTypeFactory -> DynamicTypeFactory -> Bool)
-> Eq DynamicTypeFactory
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DynamicTypeFactory -> DynamicTypeFactory -> Bool
$c/= :: DynamicTypeFactory -> DynamicTypeFactory -> Bool
== :: DynamicTypeFactory -> DynamicTypeFactory -> Bool
$c== :: DynamicTypeFactory -> DynamicTypeFactory -> Bool
Eq)
foreign import ccall "gst_dynamic_type_factory_get_type"
    c_gst_dynamic_type_factory_get_type :: IO GType

instance GObject DynamicTypeFactory where
    gobjectType :: IO GType
gobjectType = IO GType
c_gst_dynamic_type_factory_get_type
    

-- | Convert 'DynamicTypeFactory' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue DynamicTypeFactory where
    toGValue :: DynamicTypeFactory -> IO GValue
toGValue o :: DynamicTypeFactory
o = do
        GType
gtype <- IO GType
c_gst_dynamic_type_factory_get_type
        DynamicTypeFactory
-> (Ptr DynamicTypeFactory -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DynamicTypeFactory
o (GType
-> (GValue -> Ptr DynamicTypeFactory -> IO ())
-> Ptr DynamicTypeFactory
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr DynamicTypeFactory -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO DynamicTypeFactory
fromGValue gv :: GValue
gv = do
        Ptr DynamicTypeFactory
ptr <- GValue -> IO (Ptr DynamicTypeFactory)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr DynamicTypeFactory)
        (ManagedPtr DynamicTypeFactory -> DynamicTypeFactory)
-> Ptr DynamicTypeFactory -> IO DynamicTypeFactory
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr DynamicTypeFactory -> DynamicTypeFactory
DynamicTypeFactory Ptr DynamicTypeFactory
ptr
        
    

-- | Type class for types which can be safely cast to `DynamicTypeFactory`, for instance with `toDynamicTypeFactory`.
class (GObject o, O.IsDescendantOf DynamicTypeFactory o) => IsDynamicTypeFactory o
instance (GObject o, O.IsDescendantOf DynamicTypeFactory o) => IsDynamicTypeFactory o

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

-- | Cast to `DynamicTypeFactory`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDynamicTypeFactory :: (MonadIO m, IsDynamicTypeFactory o) => o -> m DynamicTypeFactory
toDynamicTypeFactory :: o -> m DynamicTypeFactory
toDynamicTypeFactory = IO DynamicTypeFactory -> m DynamicTypeFactory
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DynamicTypeFactory -> m DynamicTypeFactory)
-> (o -> IO DynamicTypeFactory) -> o -> m DynamicTypeFactory
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DynamicTypeFactory -> DynamicTypeFactory)
-> o -> IO DynamicTypeFactory
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr DynamicTypeFactory -> DynamicTypeFactory
DynamicTypeFactory

-- | A convenience alias for `Nothing` :: `Maybe` `DynamicTypeFactory`.
noDynamicTypeFactory :: Maybe DynamicTypeFactory
noDynamicTypeFactory :: Maybe DynamicTypeFactory
noDynamicTypeFactory = Maybe DynamicTypeFactory
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveDynamicTypeFactoryMethod (t :: Symbol) (o :: *) :: * where
    ResolveDynamicTypeFactoryMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveDynamicTypeFactoryMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDynamicTypeFactoryMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDynamicTypeFactoryMethod "checkVersion" o = Gst.PluginFeature.PluginFeatureCheckVersionMethodInfo
    ResolveDynamicTypeFactoryMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveDynamicTypeFactoryMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDynamicTypeFactoryMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDynamicTypeFactoryMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveDynamicTypeFactoryMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveDynamicTypeFactoryMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveDynamicTypeFactoryMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveDynamicTypeFactoryMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveDynamicTypeFactoryMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDynamicTypeFactoryMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDynamicTypeFactoryMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDynamicTypeFactoryMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveDynamicTypeFactoryMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDynamicTypeFactoryMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveDynamicTypeFactoryMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDynamicTypeFactoryMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDynamicTypeFactoryMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDynamicTypeFactoryMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveDynamicTypeFactoryMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveDynamicTypeFactoryMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDynamicTypeFactoryMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveDynamicTypeFactoryMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveDynamicTypeFactoryMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDynamicTypeFactoryMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveDynamicTypeFactoryMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveDynamicTypeFactoryMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDynamicTypeFactoryMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveDynamicTypeFactoryMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveDynamicTypeFactoryMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveDynamicTypeFactoryMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveDynamicTypeFactoryMethod "getPlugin" o = Gst.PluginFeature.PluginFeatureGetPluginMethodInfo
    ResolveDynamicTypeFactoryMethod "getPluginName" o = Gst.PluginFeature.PluginFeatureGetPluginNameMethodInfo
    ResolveDynamicTypeFactoryMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDynamicTypeFactoryMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDynamicTypeFactoryMethod "getRank" o = Gst.PluginFeature.PluginFeatureGetRankMethodInfo
    ResolveDynamicTypeFactoryMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveDynamicTypeFactoryMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveDynamicTypeFactoryMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveDynamicTypeFactoryMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveDynamicTypeFactoryMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDynamicTypeFactoryMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveDynamicTypeFactoryMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveDynamicTypeFactoryMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveDynamicTypeFactoryMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDynamicTypeFactoryMethod "setRank" o = Gst.PluginFeature.PluginFeatureSetRankMethodInfo
    ResolveDynamicTypeFactoryMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DynamicTypeFactory = DynamicTypeFactorySignalList
type DynamicTypeFactorySignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DynamicTypeFactory::load
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "factoryname"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TGType)
-- throws : False
-- Skip return : False

foreign import ccall "gst_dynamic_type_factory_load" gst_dynamic_type_factory_load :: 
    CString ->                              -- factoryname : TBasicType TUTF8
    IO CGType

-- | /No description available in the introspection data./
dynamicTypeFactoryLoad ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -> m GType
dynamicTypeFactoryLoad :: Text -> m GType
dynamicTypeFactoryLoad factoryname :: Text
factoryname = IO GType -> m GType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
    CString
factoryname' <- Text -> IO CString
textToCString Text
factoryname
    CGType
result <- CString -> IO CGType
gst_dynamic_type_factory_load CString
factoryname'
    let result' :: GType
result' = CGType -> GType
GType CGType
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
factoryname'
    GType -> IO GType
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'

#if defined(ENABLE_OVERLOADING)
#endif