{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.StreamCollection
(
StreamCollection(..) ,
IsStreamCollection ,
toStreamCollection ,
#if defined(ENABLE_OVERLOADING)
ResolveStreamCollectionMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
StreamCollectionAddStreamMethodInfo ,
#endif
streamCollectionAddStream ,
#if defined(ENABLE_OVERLOADING)
StreamCollectionGetSizeMethodInfo ,
#endif
streamCollectionGetSize ,
#if defined(ENABLE_OVERLOADING)
StreamCollectionGetStreamMethodInfo ,
#endif
streamCollectionGetStream ,
#if defined(ENABLE_OVERLOADING)
StreamCollectionGetUpstreamIdMethodInfo ,
#endif
streamCollectionGetUpstreamId ,
streamCollectionNew ,
#if defined(ENABLE_OVERLOADING)
StreamCollectionUpstreamIdPropertyInfo ,
#endif
clearStreamCollectionUpstreamId ,
constructStreamCollectionUpstreamId ,
getStreamCollectionUpstreamId ,
setStreamCollectionUpstreamId ,
#if defined(ENABLE_OVERLOADING)
streamCollectionUpstreamId ,
#endif
C_StreamCollectionStreamNotifyCallback ,
StreamCollectionStreamNotifyCallback ,
#if defined(ENABLE_OVERLOADING)
StreamCollectionStreamNotifySignalInfo ,
#endif
afterStreamCollectionStreamNotify ,
genClosure_StreamCollectionStreamNotify ,
mk_StreamCollectionStreamNotifyCallback ,
noStreamCollectionStreamNotifyCallback ,
onStreamCollectionStreamNotify ,
wrap_StreamCollectionStreamNotifyCallback,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Stream as Gst.Stream
newtype StreamCollection = StreamCollection (SP.ManagedPtr StreamCollection)
deriving (StreamCollection -> StreamCollection -> Bool
(StreamCollection -> StreamCollection -> Bool)
-> (StreamCollection -> StreamCollection -> Bool)
-> Eq StreamCollection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StreamCollection -> StreamCollection -> Bool
$c/= :: StreamCollection -> StreamCollection -> Bool
== :: StreamCollection -> StreamCollection -> Bool
$c== :: StreamCollection -> StreamCollection -> Bool
Eq)
instance SP.ManagedPtrNewtype StreamCollection where
toManagedPtr :: StreamCollection -> ManagedPtr StreamCollection
toManagedPtr (StreamCollection ManagedPtr StreamCollection
p) = ManagedPtr StreamCollection
p
foreign import ccall "gst_stream_collection_get_type"
c_gst_stream_collection_get_type :: IO B.Types.GType
instance B.Types.TypedObject StreamCollection where
glibType :: IO GType
glibType = IO GType
c_gst_stream_collection_get_type
instance B.Types.GObject StreamCollection
class (SP.GObject o, O.IsDescendantOf StreamCollection o) => IsStreamCollection o
instance (SP.GObject o, O.IsDescendantOf StreamCollection o) => IsStreamCollection o
instance O.HasParentTypes StreamCollection
type instance O.ParentTypes StreamCollection = '[Gst.Object.Object, GObject.Object.Object]
toStreamCollection :: (MIO.MonadIO m, IsStreamCollection o) => o -> m StreamCollection
toStreamCollection :: forall (m :: * -> *) o.
(MonadIO m, IsStreamCollection o) =>
o -> m StreamCollection
toStreamCollection = IO StreamCollection -> m StreamCollection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO StreamCollection -> m StreamCollection)
-> (o -> IO StreamCollection) -> o -> m StreamCollection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr StreamCollection -> StreamCollection)
-> o -> IO StreamCollection
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr StreamCollection -> StreamCollection
StreamCollection
instance B.GValue.IsGValue (Maybe StreamCollection) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_stream_collection_get_type
gvalueSet_ :: Ptr GValue -> Maybe StreamCollection -> IO ()
gvalueSet_ Ptr GValue
gv Maybe StreamCollection
P.Nothing = Ptr GValue -> Ptr StreamCollection -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr StreamCollection
forall a. Ptr a
FP.nullPtr :: FP.Ptr StreamCollection)
gvalueSet_ Ptr GValue
gv (P.Just StreamCollection
obj) = StreamCollection -> (Ptr StreamCollection -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StreamCollection
obj (Ptr GValue -> Ptr StreamCollection -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe StreamCollection)
gvalueGet_ Ptr GValue
gv = do
Ptr StreamCollection
ptr <- Ptr GValue -> IO (Ptr StreamCollection)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr StreamCollection)
if Ptr StreamCollection
ptr Ptr StreamCollection -> Ptr StreamCollection -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr StreamCollection
forall a. Ptr a
FP.nullPtr
then StreamCollection -> Maybe StreamCollection
forall a. a -> Maybe a
P.Just (StreamCollection -> Maybe StreamCollection)
-> IO StreamCollection -> IO (Maybe StreamCollection)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr StreamCollection -> StreamCollection)
-> Ptr StreamCollection -> IO StreamCollection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr StreamCollection -> StreamCollection
StreamCollection Ptr StreamCollection
ptr
else Maybe StreamCollection -> IO (Maybe StreamCollection)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe StreamCollection
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveStreamCollectionMethod (t :: Symbol) (o :: *) :: * where
ResolveStreamCollectionMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolveStreamCollectionMethod "addStream" o = StreamCollectionAddStreamMethodInfo
ResolveStreamCollectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveStreamCollectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveStreamCollectionMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolveStreamCollectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveStreamCollectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveStreamCollectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveStreamCollectionMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolveStreamCollectionMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolveStreamCollectionMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolveStreamCollectionMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolveStreamCollectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveStreamCollectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveStreamCollectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveStreamCollectionMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolveStreamCollectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveStreamCollectionMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolveStreamCollectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveStreamCollectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveStreamCollectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveStreamCollectionMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolveStreamCollectionMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolveStreamCollectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveStreamCollectionMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolveStreamCollectionMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolveStreamCollectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveStreamCollectionMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolveStreamCollectionMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolveStreamCollectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveStreamCollectionMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolveStreamCollectionMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolveStreamCollectionMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolveStreamCollectionMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolveStreamCollectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveStreamCollectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveStreamCollectionMethod "getSize" o = StreamCollectionGetSizeMethodInfo
ResolveStreamCollectionMethod "getStream" o = StreamCollectionGetStreamMethodInfo
ResolveStreamCollectionMethod "getUpstreamId" o = StreamCollectionGetUpstreamIdMethodInfo
ResolveStreamCollectionMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolveStreamCollectionMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolveStreamCollectionMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolveStreamCollectionMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolveStreamCollectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveStreamCollectionMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveStreamCollectionMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolveStreamCollectionMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolveStreamCollectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveStreamCollectionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveStreamCollectionMethod t StreamCollection, O.OverloadedMethod info StreamCollection p) => OL.IsLabel t (StreamCollection -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveStreamCollectionMethod t StreamCollection, O.OverloadedMethod info StreamCollection p, R.HasField t StreamCollection p) => R.HasField t StreamCollection p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveStreamCollectionMethod t StreamCollection, O.OverloadedMethodInfo info StreamCollection) => OL.IsLabel t (O.MethodProxy info StreamCollection) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type StreamCollectionStreamNotifyCallback =
Gst.Stream.Stream
-> GParamSpec
-> IO ()
noStreamCollectionStreamNotifyCallback :: Maybe StreamCollectionStreamNotifyCallback
noStreamCollectionStreamNotifyCallback :: Maybe StreamCollectionStreamNotifyCallback
noStreamCollectionStreamNotifyCallback = Maybe StreamCollectionStreamNotifyCallback
forall a. Maybe a
Nothing
type C_StreamCollectionStreamNotifyCallback =
Ptr () ->
Ptr Gst.Stream.Stream ->
Ptr GParamSpec ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_StreamCollectionStreamNotifyCallback :: C_StreamCollectionStreamNotifyCallback -> IO (FunPtr C_StreamCollectionStreamNotifyCallback)
genClosure_StreamCollectionStreamNotify :: MonadIO m => StreamCollectionStreamNotifyCallback -> m (GClosure C_StreamCollectionStreamNotifyCallback)
genClosure_StreamCollectionStreamNotify :: forall (m :: * -> *).
MonadIO m =>
StreamCollectionStreamNotifyCallback
-> m (GClosure C_StreamCollectionStreamNotifyCallback)
genClosure_StreamCollectionStreamNotify StreamCollectionStreamNotifyCallback
cb = IO (GClosure C_StreamCollectionStreamNotifyCallback)
-> m (GClosure C_StreamCollectionStreamNotifyCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (GClosure C_StreamCollectionStreamNotifyCallback)
-> m (GClosure C_StreamCollectionStreamNotifyCallback))
-> IO (GClosure C_StreamCollectionStreamNotifyCallback)
-> m (GClosure C_StreamCollectionStreamNotifyCallback)
forall a b. (a -> b) -> a -> b
$ do
let cb' :: C_StreamCollectionStreamNotifyCallback
cb' = StreamCollectionStreamNotifyCallback
-> C_StreamCollectionStreamNotifyCallback
wrap_StreamCollectionStreamNotifyCallback StreamCollectionStreamNotifyCallback
cb
C_StreamCollectionStreamNotifyCallback
-> IO (FunPtr C_StreamCollectionStreamNotifyCallback)
mk_StreamCollectionStreamNotifyCallback C_StreamCollectionStreamNotifyCallback
cb' IO (FunPtr C_StreamCollectionStreamNotifyCallback)
-> (FunPtr C_StreamCollectionStreamNotifyCallback
-> IO (GClosure C_StreamCollectionStreamNotifyCallback))
-> IO (GClosure C_StreamCollectionStreamNotifyCallback)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_StreamCollectionStreamNotifyCallback
-> IO (GClosure C_StreamCollectionStreamNotifyCallback)
forall (m :: * -> *) a. MonadIO m => FunPtr a -> m (GClosure a)
B.GClosure.newGClosure
wrap_StreamCollectionStreamNotifyCallback ::
StreamCollectionStreamNotifyCallback ->
C_StreamCollectionStreamNotifyCallback
wrap_StreamCollectionStreamNotifyCallback :: StreamCollectionStreamNotifyCallback
-> C_StreamCollectionStreamNotifyCallback
wrap_StreamCollectionStreamNotifyCallback StreamCollectionStreamNotifyCallback
_cb Ptr ()
_ Ptr Stream
object Ptr GParamSpec
p0 Ptr ()
_ = do
Stream
object' <- ((ManagedPtr Stream -> Stream) -> Ptr Stream -> IO Stream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Stream -> Stream
Gst.Stream.Stream) Ptr Stream
object
GParamSpec
p0' <- Ptr GParamSpec -> IO GParamSpec
B.GParamSpec.newGParamSpecFromPtr Ptr GParamSpec
p0
StreamCollectionStreamNotifyCallback
_cb Stream
object' GParamSpec
p0'
onStreamCollectionStreamNotify :: (IsStreamCollection a, MonadIO m) => a -> P.Maybe T.Text -> StreamCollectionStreamNotifyCallback -> m SignalHandlerId
onStreamCollectionStreamNotify :: forall a (m :: * -> *).
(IsStreamCollection a, MonadIO m) =>
a
-> Maybe Text
-> StreamCollectionStreamNotifyCallback
-> m SignalHandlerId
onStreamCollectionStreamNotify a
obj Maybe Text
detail StreamCollectionStreamNotifyCallback
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_StreamCollectionStreamNotifyCallback
cb' = StreamCollectionStreamNotifyCallback
-> C_StreamCollectionStreamNotifyCallback
wrap_StreamCollectionStreamNotifyCallback StreamCollectionStreamNotifyCallback
cb
FunPtr C_StreamCollectionStreamNotifyCallback
cb'' <- C_StreamCollectionStreamNotifyCallback
-> IO (FunPtr C_StreamCollectionStreamNotifyCallback)
mk_StreamCollectionStreamNotifyCallback C_StreamCollectionStreamNotifyCallback
cb'
a
-> Text
-> FunPtr C_StreamCollectionStreamNotifyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"stream-notify" FunPtr C_StreamCollectionStreamNotifyCallback
cb'' SignalConnectMode
SignalConnectBefore Maybe Text
detail
afterStreamCollectionStreamNotify :: (IsStreamCollection a, MonadIO m) => a -> P.Maybe T.Text -> StreamCollectionStreamNotifyCallback -> m SignalHandlerId
afterStreamCollectionStreamNotify :: forall a (m :: * -> *).
(IsStreamCollection a, MonadIO m) =>
a
-> Maybe Text
-> StreamCollectionStreamNotifyCallback
-> m SignalHandlerId
afterStreamCollectionStreamNotify a
obj Maybe Text
detail StreamCollectionStreamNotifyCallback
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_StreamCollectionStreamNotifyCallback
cb' = StreamCollectionStreamNotifyCallback
-> C_StreamCollectionStreamNotifyCallback
wrap_StreamCollectionStreamNotifyCallback StreamCollectionStreamNotifyCallback
cb
FunPtr C_StreamCollectionStreamNotifyCallback
cb'' <- C_StreamCollectionStreamNotifyCallback
-> IO (FunPtr C_StreamCollectionStreamNotifyCallback)
mk_StreamCollectionStreamNotifyCallback C_StreamCollectionStreamNotifyCallback
cb'
a
-> Text
-> FunPtr C_StreamCollectionStreamNotifyCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"stream-notify" FunPtr C_StreamCollectionStreamNotifyCallback
cb'' SignalConnectMode
SignalConnectAfter Maybe Text
detail
#if defined(ENABLE_OVERLOADING)
data StreamCollectionStreamNotifySignalInfo
instance SignalInfo StreamCollectionStreamNotifySignalInfo where
type HaskellCallbackType StreamCollectionStreamNotifySignalInfo = StreamCollectionStreamNotifyCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_StreamCollectionStreamNotifyCallback cb
cb'' <- mk_StreamCollectionStreamNotifyCallback cb'
connectSignalFunPtr obj "stream-notify" cb'' connectMode detail
#endif
getStreamCollectionUpstreamId :: (MonadIO m, IsStreamCollection o) => o -> m (Maybe T.Text)
getStreamCollectionUpstreamId :: forall (m :: * -> *) o.
(MonadIO m, IsStreamCollection o) =>
o -> m (Maybe Text)
getStreamCollectionUpstreamId o
obj = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"upstream-id"
setStreamCollectionUpstreamId :: (MonadIO m, IsStreamCollection o) => o -> T.Text -> m ()
setStreamCollectionUpstreamId :: forall (m :: * -> *) o.
(MonadIO m, IsStreamCollection o) =>
o -> Text -> m ()
setStreamCollectionUpstreamId o
obj Text
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"upstream-id" (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
val)
constructStreamCollectionUpstreamId :: (IsStreamCollection o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructStreamCollectionUpstreamId :: forall o (m :: * -> *).
(IsStreamCollection o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructStreamCollectionUpstreamId Text
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"upstream-id" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)
clearStreamCollectionUpstreamId :: (MonadIO m, IsStreamCollection o) => o -> m ()
clearStreamCollectionUpstreamId :: forall (m :: * -> *) o.
(MonadIO m, IsStreamCollection o) =>
o -> m ()
clearStreamCollectionUpstreamId o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"upstream-id" (Maybe Text
forall a. Maybe a
Nothing :: Maybe T.Text)
#if defined(ENABLE_OVERLOADING)
data StreamCollectionUpstreamIdPropertyInfo
instance AttrInfo StreamCollectionUpstreamIdPropertyInfo where
type AttrAllowedOps StreamCollectionUpstreamIdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint StreamCollectionUpstreamIdPropertyInfo = IsStreamCollection
type AttrSetTypeConstraint StreamCollectionUpstreamIdPropertyInfo = (~) T.Text
type AttrTransferTypeConstraint StreamCollectionUpstreamIdPropertyInfo = (~) T.Text
type AttrTransferType StreamCollectionUpstreamIdPropertyInfo = T.Text
type AttrGetType StreamCollectionUpstreamIdPropertyInfo = (Maybe T.Text)
type AttrLabel StreamCollectionUpstreamIdPropertyInfo = "upstream-id"
type AttrOrigin StreamCollectionUpstreamIdPropertyInfo = StreamCollection
attrGet = getStreamCollectionUpstreamId
attrSet = setStreamCollectionUpstreamId
attrTransfer _ v = do
return v
attrConstruct = constructStreamCollectionUpstreamId
attrClear = clearStreamCollectionUpstreamId
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StreamCollection
type instance O.AttributeList StreamCollection = StreamCollectionAttributeList
type StreamCollectionAttributeList = ('[ '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("upstreamId", StreamCollectionUpstreamIdPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
streamCollectionUpstreamId :: AttrLabelProxy "upstreamId"
streamCollectionUpstreamId = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList StreamCollection = StreamCollectionSignalList
type StreamCollectionSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("streamNotify", StreamCollectionStreamNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_stream_collection_new" gst_stream_collection_new ::
CString ->
IO (Ptr StreamCollection)
streamCollectionNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> m StreamCollection
streamCollectionNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> m StreamCollection
streamCollectionNew Maybe Text
upstreamId = IO StreamCollection -> m StreamCollection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StreamCollection -> m StreamCollection)
-> IO StreamCollection -> m StreamCollection
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeUpstreamId <- case Maybe Text
upstreamId of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jUpstreamId -> do
Ptr CChar
jUpstreamId' <- Text -> IO (Ptr CChar)
textToCString Text
jUpstreamId
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jUpstreamId'
Ptr StreamCollection
result <- Ptr CChar -> IO (Ptr StreamCollection)
gst_stream_collection_new Ptr CChar
maybeUpstreamId
Text -> Ptr StreamCollection -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"streamCollectionNew" Ptr StreamCollection
result
StreamCollection
result' <- ((ManagedPtr StreamCollection -> StreamCollection)
-> Ptr StreamCollection -> IO StreamCollection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr StreamCollection -> StreamCollection
StreamCollection) Ptr StreamCollection
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeUpstreamId
StreamCollection -> IO StreamCollection
forall (m :: * -> *) a. Monad m => a -> m a
return StreamCollection
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_stream_collection_add_stream" gst_stream_collection_add_stream ::
Ptr StreamCollection ->
Ptr Gst.Stream.Stream ->
IO CInt
streamCollectionAddStream ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamCollection a, Gst.Stream.IsStream b) =>
a
-> b
-> m Bool
streamCollectionAddStream :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsStreamCollection a, IsStream b) =>
a -> b -> m Bool
streamCollectionAddStream a
collection b
stream = 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 StreamCollection
collection' <- a -> IO (Ptr StreamCollection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
collection
Ptr Stream
stream' <- b -> IO (Ptr Stream)
forall a b. (HasCallStack, GObject a) => a -> IO (Ptr b)
B.ManagedPtr.disownObject b
stream
CInt
result <- Ptr StreamCollection -> Ptr Stream -> IO CInt
gst_stream_collection_add_stream Ptr StreamCollection
collection' Ptr Stream
stream'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
collection
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
stream
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data StreamCollectionAddStreamMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsStreamCollection a, Gst.Stream.IsStream b) => O.OverloadedMethod StreamCollectionAddStreamMethodInfo a signature where
overloadedMethod = streamCollectionAddStream
instance O.OverloadedMethodInfo StreamCollectionAddStreamMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.StreamCollection.streamCollectionAddStream",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-StreamCollection.html#v:streamCollectionAddStream"
}
#endif
foreign import ccall "gst_stream_collection_get_size" gst_stream_collection_get_size ::
Ptr StreamCollection ->
IO Word32
streamCollectionGetSize ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamCollection a) =>
a
-> m Word32
streamCollectionGetSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamCollection a) =>
a -> m Word32
streamCollectionGetSize a
collection = 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 StreamCollection
collection' <- a -> IO (Ptr StreamCollection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
collection
Word32
result <- Ptr StreamCollection -> IO Word32
gst_stream_collection_get_size Ptr StreamCollection
collection'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
collection
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
#if defined(ENABLE_OVERLOADING)
data StreamCollectionGetSizeMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsStreamCollection a) => O.OverloadedMethod StreamCollectionGetSizeMethodInfo a signature where
overloadedMethod = streamCollectionGetSize
instance O.OverloadedMethodInfo StreamCollectionGetSizeMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.StreamCollection.streamCollectionGetSize",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-StreamCollection.html#v:streamCollectionGetSize"
}
#endif
foreign import ccall "gst_stream_collection_get_stream" gst_stream_collection_get_stream ::
Ptr StreamCollection ->
Word32 ->
IO (Ptr Gst.Stream.Stream)
streamCollectionGetStream ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamCollection a) =>
a
-> Word32
-> m (Maybe Gst.Stream.Stream)
streamCollectionGetStream :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamCollection a) =>
a -> Word32 -> m (Maybe Stream)
streamCollectionGetStream a
collection Word32
index = IO (Maybe Stream) -> m (Maybe Stream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Stream) -> m (Maybe Stream))
-> IO (Maybe Stream) -> m (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ do
Ptr StreamCollection
collection' <- a -> IO (Ptr StreamCollection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
collection
Ptr Stream
result <- Ptr StreamCollection -> Word32 -> IO (Ptr Stream)
gst_stream_collection_get_stream Ptr StreamCollection
collection' Word32
index
Maybe Stream
maybeResult <- Ptr Stream -> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Stream
result ((Ptr Stream -> IO Stream) -> IO (Maybe Stream))
-> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ \Ptr Stream
result' -> do
Stream
result'' <- ((ManagedPtr Stream -> Stream) -> Ptr Stream -> IO Stream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Stream -> Stream
Gst.Stream.Stream) Ptr Stream
result'
Stream -> IO Stream
forall (m :: * -> *) a. Monad m => a -> m a
return Stream
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
collection
Maybe Stream -> IO (Maybe Stream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Stream
maybeResult
#if defined(ENABLE_OVERLOADING)
data StreamCollectionGetStreamMethodInfo
instance (signature ~ (Word32 -> m (Maybe Gst.Stream.Stream)), MonadIO m, IsStreamCollection a) => O.OverloadedMethod StreamCollectionGetStreamMethodInfo a signature where
overloadedMethod = streamCollectionGetStream
instance O.OverloadedMethodInfo StreamCollectionGetStreamMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.StreamCollection.streamCollectionGetStream",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-StreamCollection.html#v:streamCollectionGetStream"
}
#endif
foreign import ccall "gst_stream_collection_get_upstream_id" gst_stream_collection_get_upstream_id ::
Ptr StreamCollection ->
IO CString
streamCollectionGetUpstreamId ::
(B.CallStack.HasCallStack, MonadIO m, IsStreamCollection a) =>
a
-> m (Maybe T.Text)
streamCollectionGetUpstreamId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsStreamCollection a) =>
a -> m (Maybe Text)
streamCollectionGetUpstreamId a
collection = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr StreamCollection
collection' <- a -> IO (Ptr StreamCollection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
collection
Ptr CChar
result <- Ptr StreamCollection -> IO (Ptr CChar)
gst_stream_collection_get_upstream_id Ptr StreamCollection
collection'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
collection
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data StreamCollectionGetUpstreamIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsStreamCollection a) => O.OverloadedMethod StreamCollectionGetUpstreamIdMethodInfo a signature where
overloadedMethod = streamCollectionGetUpstreamId
instance O.OverloadedMethodInfo StreamCollectionGetUpstreamIdMethodInfo a where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Gst.Objects.StreamCollection.streamCollectionGetUpstreamId",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst-Objects-StreamCollection.html#v:streamCollectionGetUpstreamId"
}
#endif