{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Interfaces.ChildProxy
(
ChildProxy(..) ,
noChildProxy ,
IsChildProxy ,
toChildProxy ,
#if defined(ENABLE_OVERLOADING)
ResolveChildProxyMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ChildProxyChildAddedMethodInfo ,
#endif
childProxyChildAdded ,
#if defined(ENABLE_OVERLOADING)
ChildProxyChildRemovedMethodInfo ,
#endif
childProxyChildRemoved ,
#if defined(ENABLE_OVERLOADING)
ChildProxyGetChildByIndexMethodInfo ,
#endif
childProxyGetChildByIndex ,
#if defined(ENABLE_OVERLOADING)
ChildProxyGetChildByNameMethodInfo ,
#endif
childProxyGetChildByName ,
#if defined(ENABLE_OVERLOADING)
ChildProxyGetChildrenCountMethodInfo ,
#endif
childProxyGetChildrenCount ,
#if defined(ENABLE_OVERLOADING)
ChildProxyGetPropertyMethodInfo ,
#endif
childProxyGetProperty ,
#if defined(ENABLE_OVERLOADING)
ChildProxyLookupMethodInfo ,
#endif
childProxyLookup ,
#if defined(ENABLE_OVERLOADING)
ChildProxySetPropertyMethodInfo ,
#endif
childProxySetProperty ,
C_ChildProxyChildAddedCallback ,
ChildProxyChildAddedCallback ,
#if defined(ENABLE_OVERLOADING)
ChildProxyChildAddedSignalInfo ,
#endif
afterChildProxyChildAdded ,
genClosure_ChildProxyChildAdded ,
mk_ChildProxyChildAddedCallback ,
noChildProxyChildAddedCallback ,
onChildProxyChildAdded ,
wrap_ChildProxyChildAddedCallback ,
C_ChildProxyChildRemovedCallback ,
ChildProxyChildRemovedCallback ,
#if defined(ENABLE_OVERLOADING)
ChildProxyChildRemovedSignalInfo ,
#endif
afterChildProxyChildRemoved ,
genClosure_ChildProxyChildRemoved ,
mk_ChildProxyChildRemovedCallback ,
noChildProxyChildRemovedCallback ,
onChildProxyChildRemoved ,
wrap_ChildProxyChildRemovedCallback ,
) 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
newtype ChildProxy = ChildProxy (ManagedPtr ChildProxy)
deriving (ChildProxy -> ChildProxy -> Bool
(ChildProxy -> ChildProxy -> Bool)
-> (ChildProxy -> ChildProxy -> Bool) -> Eq ChildProxy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChildProxy -> ChildProxy -> Bool
$c/= :: ChildProxy -> ChildProxy -> Bool
== :: ChildProxy -> ChildProxy -> Bool
$c== :: ChildProxy -> ChildProxy -> Bool
Eq)
noChildProxy :: Maybe ChildProxy
noChildProxy :: Maybe ChildProxy
noChildProxy = Maybe ChildProxy
forall a. Maybe a
Nothing
type ChildProxyChildAddedCallback =
GObject.Object.Object
-> T.Text
-> IO ()
noChildProxyChildAddedCallback :: Maybe ChildProxyChildAddedCallback
noChildProxyChildAddedCallback :: Maybe ChildProxyChildAddedCallback
noChildProxyChildAddedCallback = Maybe ChildProxyChildAddedCallback
forall a. Maybe a
Nothing
type C_ChildProxyChildAddedCallback =
Ptr () ->
Ptr GObject.Object.Object ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ChildProxyChildAddedCallback :: C_ChildProxyChildAddedCallback -> IO (FunPtr C_ChildProxyChildAddedCallback)
genClosure_ChildProxyChildAdded :: MonadIO m => ChildProxyChildAddedCallback -> m (GClosure C_ChildProxyChildAddedCallback)
genClosure_ChildProxyChildAdded :: ChildProxyChildAddedCallback
-> m (GClosure C_ChildProxyChildAddedCallback)
genClosure_ChildProxyChildAdded cb :: ChildProxyChildAddedCallback
cb = IO (GClosure C_ChildProxyChildAddedCallback)
-> m (GClosure C_ChildProxyChildAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ChildProxyChildAddedCallback)
-> m (GClosure C_ChildProxyChildAddedCallback))
-> IO (GClosure C_ChildProxyChildAddedCallback)
-> m (GClosure C_ChildProxyChildAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ChildProxyChildAddedCallback
cb' = ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildAddedCallback ChildProxyChildAddedCallback
cb
C_ChildProxyChildAddedCallback
-> IO (FunPtr C_ChildProxyChildAddedCallback)
mk_ChildProxyChildAddedCallback C_ChildProxyChildAddedCallback
cb' IO (FunPtr C_ChildProxyChildAddedCallback)
-> (FunPtr C_ChildProxyChildAddedCallback
-> IO (GClosure C_ChildProxyChildAddedCallback))
-> IO (GClosure C_ChildProxyChildAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ChildProxyChildAddedCallback
-> IO (GClosure C_ChildProxyChildAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ChildProxyChildAddedCallback ::
ChildProxyChildAddedCallback ->
C_ChildProxyChildAddedCallback
wrap_ChildProxyChildAddedCallback :: ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildAddedCallback _cb :: ChildProxyChildAddedCallback
_cb _ object :: Ptr Object
object name :: CString
name _ = do
Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
ChildProxyChildAddedCallback
_cb Object
object' Text
name'
onChildProxyChildAdded :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId
onChildProxyChildAdded :: a -> ChildProxyChildAddedCallback -> m SignalHandlerId
onChildProxyChildAdded obj :: a
obj cb :: ChildProxyChildAddedCallback
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_ChildProxyChildAddedCallback
cb' = ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildAddedCallback ChildProxyChildAddedCallback
cb
FunPtr C_ChildProxyChildAddedCallback
cb'' <- C_ChildProxyChildAddedCallback
-> IO (FunPtr C_ChildProxyChildAddedCallback)
mk_ChildProxyChildAddedCallback C_ChildProxyChildAddedCallback
cb'
a
-> Text
-> FunPtr C_ChildProxyChildAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "child-added" FunPtr C_ChildProxyChildAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterChildProxyChildAdded :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId
afterChildProxyChildAdded :: a -> ChildProxyChildAddedCallback -> m SignalHandlerId
afterChildProxyChildAdded obj :: a
obj cb :: ChildProxyChildAddedCallback
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_ChildProxyChildAddedCallback
cb' = ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildAddedCallback ChildProxyChildAddedCallback
cb
FunPtr C_ChildProxyChildAddedCallback
cb'' <- C_ChildProxyChildAddedCallback
-> IO (FunPtr C_ChildProxyChildAddedCallback)
mk_ChildProxyChildAddedCallback C_ChildProxyChildAddedCallback
cb'
a
-> Text
-> FunPtr C_ChildProxyChildAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "child-added" FunPtr C_ChildProxyChildAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data ChildProxyChildAddedSignalInfo
instance SignalInfo ChildProxyChildAddedSignalInfo where
type HaskellCallbackType ChildProxyChildAddedSignalInfo = ChildProxyChildAddedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_ChildProxyChildAddedCallback cb
cb'' <- mk_ChildProxyChildAddedCallback cb'
connectSignalFunPtr obj "child-added" cb'' connectMode detail
#endif
type ChildProxyChildRemovedCallback =
GObject.Object.Object
-> T.Text
-> IO ()
noChildProxyChildRemovedCallback :: Maybe ChildProxyChildRemovedCallback
noChildProxyChildRemovedCallback :: Maybe ChildProxyChildAddedCallback
noChildProxyChildRemovedCallback = Maybe ChildProxyChildAddedCallback
forall a. Maybe a
Nothing
type C_ChildProxyChildRemovedCallback =
Ptr () ->
Ptr GObject.Object.Object ->
CString ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_ChildProxyChildRemovedCallback :: C_ChildProxyChildRemovedCallback -> IO (FunPtr C_ChildProxyChildRemovedCallback)
genClosure_ChildProxyChildRemoved :: MonadIO m => ChildProxyChildRemovedCallback -> m (GClosure C_ChildProxyChildRemovedCallback)
genClosure_ChildProxyChildRemoved :: ChildProxyChildAddedCallback
-> m (GClosure C_ChildProxyChildAddedCallback)
genClosure_ChildProxyChildRemoved cb :: ChildProxyChildAddedCallback
cb = IO (GClosure C_ChildProxyChildAddedCallback)
-> m (GClosure C_ChildProxyChildAddedCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_ChildProxyChildAddedCallback)
-> m (GClosure C_ChildProxyChildAddedCallback))
-> IO (GClosure C_ChildProxyChildAddedCallback)
-> m (GClosure C_ChildProxyChildAddedCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_ChildProxyChildAddedCallback
cb' = ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildRemovedCallback ChildProxyChildAddedCallback
cb
C_ChildProxyChildAddedCallback
-> IO (FunPtr C_ChildProxyChildAddedCallback)
mk_ChildProxyChildRemovedCallback C_ChildProxyChildAddedCallback
cb' IO (FunPtr C_ChildProxyChildAddedCallback)
-> (FunPtr C_ChildProxyChildAddedCallback
-> IO (GClosure C_ChildProxyChildAddedCallback))
-> IO (GClosure C_ChildProxyChildAddedCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ChildProxyChildAddedCallback
-> IO (GClosure C_ChildProxyChildAddedCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_ChildProxyChildRemovedCallback ::
ChildProxyChildRemovedCallback ->
C_ChildProxyChildRemovedCallback
wrap_ChildProxyChildRemovedCallback :: ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildRemovedCallback _cb :: ChildProxyChildAddedCallback
_cb _ object :: Ptr Object
object name :: CString
name _ = do
Object
object' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
object
Text
name' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name
ChildProxyChildAddedCallback
_cb Object
object' Text
name'
onChildProxyChildRemoved :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId
onChildProxyChildRemoved :: a -> ChildProxyChildAddedCallback -> m SignalHandlerId
onChildProxyChildRemoved obj :: a
obj cb :: ChildProxyChildAddedCallback
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_ChildProxyChildAddedCallback
cb' = ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildRemovedCallback ChildProxyChildAddedCallback
cb
FunPtr C_ChildProxyChildAddedCallback
cb'' <- C_ChildProxyChildAddedCallback
-> IO (FunPtr C_ChildProxyChildAddedCallback)
mk_ChildProxyChildRemovedCallback C_ChildProxyChildAddedCallback
cb'
a
-> Text
-> FunPtr C_ChildProxyChildAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "child-removed" FunPtr C_ChildProxyChildAddedCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterChildProxyChildRemoved :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId
afterChildProxyChildRemoved :: a -> ChildProxyChildAddedCallback -> m SignalHandlerId
afterChildProxyChildRemoved obj :: a
obj cb :: ChildProxyChildAddedCallback
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_ChildProxyChildAddedCallback
cb' = ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback
wrap_ChildProxyChildRemovedCallback ChildProxyChildAddedCallback
cb
FunPtr C_ChildProxyChildAddedCallback
cb'' <- C_ChildProxyChildAddedCallback
-> IO (FunPtr C_ChildProxyChildAddedCallback)
mk_ChildProxyChildRemovedCallback C_ChildProxyChildAddedCallback
cb'
a
-> Text
-> FunPtr C_ChildProxyChildAddedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj "child-removed" FunPtr C_ChildProxyChildAddedCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data ChildProxyChildRemovedSignalInfo
instance SignalInfo ChildProxyChildRemovedSignalInfo where
type HaskellCallbackType ChildProxyChildRemovedSignalInfo = ChildProxyChildRemovedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_ChildProxyChildRemovedCallback cb
cb'' <- mk_ChildProxyChildRemovedCallback cb'
connectSignalFunPtr obj "child-removed" cb'' connectMode detail
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ChildProxy = ChildProxySignalList
type ChildProxySignalList = ('[ '("childAdded", ChildProxyChildAddedSignalInfo), '("childRemoved", ChildProxyChildRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_child_proxy_get_type"
c_gst_child_proxy_get_type :: IO GType
instance GObject ChildProxy where
gobjectType :: IO GType
gobjectType = IO GType
c_gst_child_proxy_get_type
instance B.GValue.IsGValue ChildProxy where
toGValue :: ChildProxy -> IO GValue
toGValue o :: ChildProxy
o = do
GType
gtype <- IO GType
c_gst_child_proxy_get_type
ChildProxy -> (Ptr ChildProxy -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ChildProxy
o (GType
-> (GValue -> Ptr ChildProxy -> IO ())
-> Ptr ChildProxy
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ChildProxy -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO ChildProxy
fromGValue gv :: GValue
gv = do
Ptr ChildProxy
ptr <- GValue -> IO (Ptr ChildProxy)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr ChildProxy)
(ManagedPtr ChildProxy -> ChildProxy)
-> Ptr ChildProxy -> IO ChildProxy
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ChildProxy -> ChildProxy
ChildProxy Ptr ChildProxy
ptr
class (GObject o, O.IsDescendantOf ChildProxy o) => IsChildProxy o
instance (GObject o, O.IsDescendantOf ChildProxy o) => IsChildProxy o
instance O.HasParentTypes ChildProxy
type instance O.ParentTypes ChildProxy = '[GObject.Object.Object]
toChildProxy :: (MonadIO m, IsChildProxy o) => o -> m ChildProxy
toChildProxy :: o -> m ChildProxy
toChildProxy = IO ChildProxy -> m ChildProxy
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ChildProxy -> m ChildProxy)
-> (o -> IO ChildProxy) -> o -> m ChildProxy
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ChildProxy -> ChildProxy) -> o -> IO ChildProxy
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr ChildProxy -> ChildProxy
ChildProxy
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ChildProxy
type instance O.AttributeList ChildProxy = ChildProxyAttributeList
type ChildProxyAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveChildProxyMethod (t :: Symbol) (o :: *) :: * where
ResolveChildProxyMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveChildProxyMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveChildProxyMethod "childAdded" o = ChildProxyChildAddedMethodInfo
ResolveChildProxyMethod "childRemoved" o = ChildProxyChildRemovedMethodInfo
ResolveChildProxyMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveChildProxyMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveChildProxyMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveChildProxyMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveChildProxyMethod "lookup" o = ChildProxyLookupMethodInfo
ResolveChildProxyMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveChildProxyMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveChildProxyMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveChildProxyMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveChildProxyMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveChildProxyMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveChildProxyMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveChildProxyMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveChildProxyMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveChildProxyMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveChildProxyMethod "getChildByIndex" o = ChildProxyGetChildByIndexMethodInfo
ResolveChildProxyMethod "getChildByName" o = ChildProxyGetChildByNameMethodInfo
ResolveChildProxyMethod "getChildrenCount" o = ChildProxyGetChildrenCountMethodInfo
ResolveChildProxyMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveChildProxyMethod "getProperty" o = ChildProxyGetPropertyMethodInfo
ResolveChildProxyMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveChildProxyMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveChildProxyMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveChildProxyMethod "setProperty" o = ChildProxySetPropertyMethodInfo
ResolveChildProxyMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveChildProxyMethod t ChildProxy, O.MethodInfo info ChildProxy p) => OL.IsLabel t (ChildProxy -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif
foreign import ccall "gst_child_proxy_child_added" gst_child_proxy_child_added ::
Ptr ChildProxy ->
Ptr GObject.Object.Object ->
CString ->
IO ()
childProxyChildAdded ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a, GObject.Object.IsObject b) =>
a
-> b
-> T.Text
-> m ()
childProxyChildAdded :: a -> b -> Text -> m ()
childProxyChildAdded parent :: a
parent child :: b
child name :: Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ChildProxy
parent' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parent
Ptr Object
child' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr ChildProxy -> Ptr Object -> CString -> IO ()
gst_child_proxy_child_added Ptr ChildProxy
parent' Ptr Object
child' CString
name'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parent
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ChildProxyChildAddedMethodInfo
instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsChildProxy a, GObject.Object.IsObject b) => O.MethodInfo ChildProxyChildAddedMethodInfo a signature where
overloadedMethod = childProxyChildAdded
#endif
foreign import ccall "gst_child_proxy_child_removed" gst_child_proxy_child_removed ::
Ptr ChildProxy ->
Ptr GObject.Object.Object ->
CString ->
IO ()
childProxyChildRemoved ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a, GObject.Object.IsObject b) =>
a
-> b
-> T.Text
-> m ()
childProxyChildRemoved :: a -> b -> Text -> m ()
childProxyChildRemoved parent :: a
parent child :: b
child name :: Text
name = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ChildProxy
parent' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parent
Ptr Object
child' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
child
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr ChildProxy -> Ptr Object -> CString -> IO ()
gst_child_proxy_child_removed Ptr ChildProxy
parent' Ptr Object
child' CString
name'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parent
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
child
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ChildProxyChildRemovedMethodInfo
instance (signature ~ (b -> T.Text -> m ()), MonadIO m, IsChildProxy a, GObject.Object.IsObject b) => O.MethodInfo ChildProxyChildRemovedMethodInfo a signature where
overloadedMethod = childProxyChildRemoved
#endif
foreign import ccall "gst_child_proxy_get_child_by_index" gst_child_proxy_get_child_by_index ::
Ptr ChildProxy ->
Word32 ->
IO (Ptr GObject.Object.Object)
childProxyGetChildByIndex ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a) =>
a
-> Word32
-> m (Maybe GObject.Object.Object)
childProxyGetChildByIndex :: a -> Word32 -> m (Maybe Object)
childProxyGetChildByIndex parent :: a
parent index :: Word32
index = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
Ptr ChildProxy
parent' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parent
Ptr Object
result <- Ptr ChildProxy -> Word32 -> IO (Ptr Object)
gst_child_proxy_get_child_by_index Ptr ChildProxy
parent' Word32
index
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parent
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
#if defined(ENABLE_OVERLOADING)
data ChildProxyGetChildByIndexMethodInfo
instance (signature ~ (Word32 -> m (Maybe GObject.Object.Object)), MonadIO m, IsChildProxy a) => O.MethodInfo ChildProxyGetChildByIndexMethodInfo a signature where
overloadedMethod = childProxyGetChildByIndex
#endif
foreign import ccall "gst_child_proxy_get_child_by_name" gst_child_proxy_get_child_by_name ::
Ptr ChildProxy ->
CString ->
IO (Ptr GObject.Object.Object)
childProxyGetChildByName ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a) =>
a
-> T.Text
-> m (Maybe GObject.Object.Object)
childProxyGetChildByName :: a -> Text -> m (Maybe Object)
childProxyGetChildByName parent :: a
parent name :: Text
name = IO (Maybe Object) -> m (Maybe Object)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Object) -> m (Maybe Object))
-> IO (Maybe Object) -> m (Maybe Object)
forall a b. (a -> b) -> a -> b
$ do
Ptr ChildProxy
parent' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parent
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr Object
result <- Ptr ChildProxy -> CString -> IO (Ptr Object)
gst_child_proxy_get_child_by_name Ptr ChildProxy
parent' CString
name'
Maybe Object
maybeResult <- Ptr Object -> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Object
result ((Ptr Object -> IO Object) -> IO (Maybe Object))
-> (Ptr Object -> IO Object) -> IO (Maybe Object)
forall a b. (a -> b) -> a -> b
$ \result' :: Ptr Object
result' -> do
Object
result'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
result'
Object -> IO Object
forall (m :: * -> *) a. Monad m => a -> m a
return Object
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parent
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe Object -> IO (Maybe Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Object
maybeResult
#if defined(ENABLE_OVERLOADING)
data ChildProxyGetChildByNameMethodInfo
instance (signature ~ (T.Text -> m (Maybe GObject.Object.Object)), MonadIO m, IsChildProxy a) => O.MethodInfo ChildProxyGetChildByNameMethodInfo a signature where
overloadedMethod = childProxyGetChildByName
#endif
foreign import ccall "gst_child_proxy_get_children_count" gst_child_proxy_get_children_count ::
Ptr ChildProxy ->
IO Word32
childProxyGetChildrenCount ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a) =>
a
-> m Word32
childProxyGetChildrenCount :: a -> m Word32
childProxyGetChildrenCount parent :: a
parent = 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 ChildProxy
parent' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
parent
Word32
result <- Ptr ChildProxy -> IO Word32
gst_child_proxy_get_children_count Ptr ChildProxy
parent'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
parent
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data ChildProxyGetChildrenCountMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsChildProxy a) => O.MethodInfo ChildProxyGetChildrenCountMethodInfo a signature where
overloadedMethod = childProxyGetChildrenCount
#endif
foreign import ccall "gst_child_proxy_get_property" gst_child_proxy_get_property ::
Ptr ChildProxy ->
CString ->
Ptr GValue ->
IO ()
childProxyGetProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a) =>
a
-> T.Text
-> m (GValue)
childProxyGetProperty :: a -> Text -> m GValue
childProxyGetProperty object :: a
object name :: Text
name = IO GValue -> m GValue
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
Ptr ChildProxy
object' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr GValue
value <- Int -> IO (Ptr GValue)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 24 :: IO (Ptr GValue)
Ptr ChildProxy -> CString -> Ptr GValue -> IO ()
gst_child_proxy_get_property Ptr ChildProxy
object' CString
name' Ptr GValue
value
GValue
value' <- ((ManagedPtr GValue -> GValue) -> Ptr GValue -> IO GValue
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr GValue -> GValue
GValue) Ptr GValue
value
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
GValue -> IO GValue
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'
#if defined(ENABLE_OVERLOADING)
data ChildProxyGetPropertyMethodInfo
instance (signature ~ (T.Text -> m (GValue)), MonadIO m, IsChildProxy a) => O.MethodInfo ChildProxyGetPropertyMethodInfo a signature where
overloadedMethod = childProxyGetProperty
#endif
foreign import ccall "gst_child_proxy_lookup" gst_child_proxy_lookup ::
Ptr ChildProxy ->
CString ->
Ptr (Ptr GObject.Object.Object) ->
Ptr (Ptr GParamSpec) ->
IO CInt
childProxyLookup ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a) =>
a
-> T.Text
-> m ((Bool, GObject.Object.Object, GParamSpec))
childProxyLookup :: a -> Text -> m (Bool, Object, GParamSpec)
childProxyLookup object :: a
object name :: Text
name = IO (Bool, Object, GParamSpec) -> m (Bool, Object, GParamSpec)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Object, GParamSpec) -> m (Bool, Object, GParamSpec))
-> IO (Bool, Object, GParamSpec) -> m (Bool, Object, GParamSpec)
forall a b. (a -> b) -> a -> b
$ do
Ptr ChildProxy
object' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr (Ptr Object)
target <- IO (Ptr (Ptr Object))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr GObject.Object.Object))
Ptr (Ptr GParamSpec)
pspec <- IO (Ptr (Ptr GParamSpec))
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr (Ptr GParamSpec))
CInt
result <- Ptr ChildProxy
-> CString -> Ptr (Ptr Object) -> Ptr (Ptr GParamSpec) -> IO CInt
gst_child_proxy_lookup Ptr ChildProxy
object' CString
name' Ptr (Ptr Object)
target Ptr (Ptr GParamSpec)
pspec
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
Ptr Object
target' <- Ptr (Ptr Object) -> IO (Ptr Object)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Object)
target
Object
target'' <- ((ManagedPtr Object -> Object) -> Ptr Object -> IO Object
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Object -> Object
GObject.Object.Object) Ptr Object
target'
Ptr GParamSpec
pspec' <- Ptr (Ptr GParamSpec) -> IO (Ptr GParamSpec)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr GParamSpec)
pspec
GParamSpec
pspec'' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
pspec'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Ptr (Ptr Object) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Object)
target
Ptr (Ptr GParamSpec) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr GParamSpec)
pspec
(Bool, Object, GParamSpec) -> IO (Bool, Object, GParamSpec)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Object
target'', GParamSpec
pspec'')
#if defined(ENABLE_OVERLOADING)
data ChildProxyLookupMethodInfo
instance (signature ~ (T.Text -> m ((Bool, GObject.Object.Object, GParamSpec))), MonadIO m, IsChildProxy a) => O.MethodInfo ChildProxyLookupMethodInfo a signature where
overloadedMethod = childProxyLookup
#endif
foreign import ccall "gst_child_proxy_set_property" gst_child_proxy_set_property ::
Ptr ChildProxy ->
CString ->
Ptr GValue ->
IO ()
childProxySetProperty ::
(B.CallStack.HasCallStack, MonadIO m, IsChildProxy a) =>
a
-> T.Text
-> GValue
-> m ()
childProxySetProperty :: a -> Text -> GValue -> m ()
childProxySetProperty object :: a
object name :: Text
name value :: GValue
value = 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 ChildProxy
object' <- a -> IO (Ptr ChildProxy)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
object
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
Ptr ChildProxy -> CString -> Ptr GValue -> IO ()
gst_child_proxy_set_property Ptr ChildProxy
object' CString
name' Ptr GValue
value'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
object
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ChildProxySetPropertyMethodInfo
instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, IsChildProxy a) => O.MethodInfo ChildProxySetPropertyMethodInfo a signature where
overloadedMethod = childProxySetProperty
#endif