{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A 'GI.Gst.Structs.Structure.Structure' is a collection of key\/value pairs. The keys are expressed as GQuarks and the values can be of any GType. In addition to the key\/value pairs, a 'GI.Gst.Structs.Structure.Structure' also has a name. The name starts with a letter and can be filled by letters, numbers and any of \"\/-_.:\". 'GI.Gst.Structs.Structure.Structure' is used by various GStreamer subsystems to store information in a flexible and extensible way. A 'GI.Gst.Structs.Structure.Structure' does not have a refcount because it usually is part of a higher level object such as 'GI.Gst.Structs.Caps.Caps', 'GI.Gst.Structs.Message.Message', 'GI.Gst.Structs.Event.Event', 'GI.Gst.Structs.Query.Query'. It provides a means to enforce mutability using the refcount of the parent with the 'GI.Gst.Structs.Structure.structureSetParentRefcount' method. A 'GI.Gst.Structs.Structure.Structure' can be created with 'GI.Gst.Structs.Structure.structureNewEmpty' or @/gst_structure_new()/@, which both take a name and an optional set of key\/value pairs along with the types of the values. Field values can be changed with 'GI.Gst.Structs.Structure.structureSetValue' or @/gst_structure_set()/@. Field values can be retrieved with 'GI.Gst.Structs.Structure.structureGetValue' or the more convenient gst_structure_get_*() functions. Fields can be removed with 'GI.Gst.Structs.Structure.structureRemoveField' or @/gst_structure_remove_fields()/@. Strings in structures must be ASCII or UTF-8 encoded. Other encodings are not allowed. Strings may be 'Nothing' however. Be aware that the current 'GI.Gst.Structs.Caps.Caps' \/ 'GI.Gst.Structs.Structure.Structure' serialization into string has limited support for nested 'GI.Gst.Structs.Caps.Caps' \/ 'GI.Gst.Structs.Structure.Structure' fields. It can only support one level of nesting. Using more levels will lead to unexpected behavior when using serialization features, such as 'GI.Gst.Structs.Caps.capsToString' or 'GI.Gst.Functions.valueSerialize' and their counterparts. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gst.Structs.Structure ( -- * Exported types Structure(..) , newZeroStructure , noStructure , -- * Methods -- ** canIntersect #method:canIntersect# #if ENABLE_OVERLOADING StructureCanIntersectMethodInfo , #endif structureCanIntersect , -- ** copy #method:copy# #if ENABLE_OVERLOADING StructureCopyMethodInfo , #endif structureCopy , -- ** filterAndMapInPlace #method:filterAndMapInPlace# #if ENABLE_OVERLOADING StructureFilterAndMapInPlaceMethodInfo , #endif structureFilterAndMapInPlace , -- ** fixate #method:fixate# #if ENABLE_OVERLOADING StructureFixateMethodInfo , #endif structureFixate , -- ** fixateField #method:fixateField# #if ENABLE_OVERLOADING StructureFixateFieldMethodInfo , #endif structureFixateField , -- ** fixateFieldBoolean #method:fixateFieldBoolean# #if ENABLE_OVERLOADING StructureFixateFieldBooleanMethodInfo , #endif structureFixateFieldBoolean , -- ** fixateFieldNearestDouble #method:fixateFieldNearestDouble# #if ENABLE_OVERLOADING StructureFixateFieldNearestDoubleMethodInfo, #endif structureFixateFieldNearestDouble , -- ** fixateFieldNearestFraction #method:fixateFieldNearestFraction# #if ENABLE_OVERLOADING StructureFixateFieldNearestFractionMethodInfo, #endif structureFixateFieldNearestFraction , -- ** fixateFieldNearestInt #method:fixateFieldNearestInt# #if ENABLE_OVERLOADING StructureFixateFieldNearestIntMethodInfo, #endif structureFixateFieldNearestInt , -- ** fixateFieldString #method:fixateFieldString# #if ENABLE_OVERLOADING StructureFixateFieldStringMethodInfo , #endif structureFixateFieldString , -- ** foreach #method:foreach# #if ENABLE_OVERLOADING StructureForeachMethodInfo , #endif structureForeach , -- ** free #method:free# #if ENABLE_OVERLOADING StructureFreeMethodInfo , #endif structureFree , -- ** fromString #method:fromString# structureFromString , -- ** getArray #method:getArray# #if ENABLE_OVERLOADING StructureGetArrayMethodInfo , #endif structureGetArray , -- ** getBoolean #method:getBoolean# #if ENABLE_OVERLOADING StructureGetBooleanMethodInfo , #endif structureGetBoolean , -- ** getClockTime #method:getClockTime# #if ENABLE_OVERLOADING StructureGetClockTimeMethodInfo , #endif structureGetClockTime , -- ** getDate #method:getDate# #if ENABLE_OVERLOADING StructureGetDateMethodInfo , #endif structureGetDate , -- ** getDateTime #method:getDateTime# #if ENABLE_OVERLOADING StructureGetDateTimeMethodInfo , #endif structureGetDateTime , -- ** getDouble #method:getDouble# #if ENABLE_OVERLOADING StructureGetDoubleMethodInfo , #endif structureGetDouble , -- ** getEnum #method:getEnum# #if ENABLE_OVERLOADING StructureGetEnumMethodInfo , #endif structureGetEnum , -- ** getFieldType #method:getFieldType# #if ENABLE_OVERLOADING StructureGetFieldTypeMethodInfo , #endif structureGetFieldType , -- ** getFlagset #method:getFlagset# #if ENABLE_OVERLOADING StructureGetFlagsetMethodInfo , #endif structureGetFlagset , -- ** getFraction #method:getFraction# #if ENABLE_OVERLOADING StructureGetFractionMethodInfo , #endif structureGetFraction , -- ** getInt #method:getInt# #if ENABLE_OVERLOADING StructureGetIntMethodInfo , #endif structureGetInt , -- ** getInt64 #method:getInt64# #if ENABLE_OVERLOADING StructureGetInt64MethodInfo , #endif structureGetInt64 , -- ** getList #method:getList# #if ENABLE_OVERLOADING StructureGetListMethodInfo , #endif structureGetList , -- ** getName #method:getName# #if ENABLE_OVERLOADING StructureGetNameMethodInfo , #endif structureGetName , -- ** getNameId #method:getNameId# #if ENABLE_OVERLOADING StructureGetNameIdMethodInfo , #endif structureGetNameId , -- ** getString #method:getString# #if ENABLE_OVERLOADING StructureGetStringMethodInfo , #endif structureGetString , -- ** getUint #method:getUint# #if ENABLE_OVERLOADING StructureGetUintMethodInfo , #endif structureGetUint , -- ** getUint64 #method:getUint64# #if ENABLE_OVERLOADING StructureGetUint64MethodInfo , #endif structureGetUint64 , -- ** getValue #method:getValue# #if ENABLE_OVERLOADING StructureGetValueMethodInfo , #endif structureGetValue , -- ** hasField #method:hasField# #if ENABLE_OVERLOADING StructureHasFieldMethodInfo , #endif structureHasField , -- ** hasFieldTyped #method:hasFieldTyped# #if ENABLE_OVERLOADING StructureHasFieldTypedMethodInfo , #endif structureHasFieldTyped , -- ** hasName #method:hasName# #if ENABLE_OVERLOADING StructureHasNameMethodInfo , #endif structureHasName , -- ** idGetValue #method:idGetValue# #if ENABLE_OVERLOADING StructureIdGetValueMethodInfo , #endif structureIdGetValue , -- ** idHasField #method:idHasField# #if ENABLE_OVERLOADING StructureIdHasFieldMethodInfo , #endif structureIdHasField , -- ** idHasFieldTyped #method:idHasFieldTyped# #if ENABLE_OVERLOADING StructureIdHasFieldTypedMethodInfo , #endif structureIdHasFieldTyped , -- ** idSetValue #method:idSetValue# #if ENABLE_OVERLOADING StructureIdSetValueMethodInfo , #endif structureIdSetValue , -- ** idTakeValue #method:idTakeValue# #if ENABLE_OVERLOADING StructureIdTakeValueMethodInfo , #endif structureIdTakeValue , -- ** intersect #method:intersect# #if ENABLE_OVERLOADING StructureIntersectMethodInfo , #endif structureIntersect , -- ** isEqual #method:isEqual# #if ENABLE_OVERLOADING StructureIsEqualMethodInfo , #endif structureIsEqual , -- ** isSubset #method:isSubset# #if ENABLE_OVERLOADING StructureIsSubsetMethodInfo , #endif structureIsSubset , -- ** mapInPlace #method:mapInPlace# #if ENABLE_OVERLOADING StructureMapInPlaceMethodInfo , #endif structureMapInPlace , -- ** nFields #method:nFields# #if ENABLE_OVERLOADING StructureNFieldsMethodInfo , #endif structureNFields , -- ** newEmpty #method:newEmpty# structureNewEmpty , -- ** newFromString #method:newFromString# structureNewFromString , -- ** newIdEmpty #method:newIdEmpty# structureNewIdEmpty , -- ** nthFieldName #method:nthFieldName# #if ENABLE_OVERLOADING StructureNthFieldNameMethodInfo , #endif structureNthFieldName , -- ** removeAllFields #method:removeAllFields# #if ENABLE_OVERLOADING StructureRemoveAllFieldsMethodInfo , #endif structureRemoveAllFields , -- ** removeField #method:removeField# #if ENABLE_OVERLOADING StructureRemoveFieldMethodInfo , #endif structureRemoveField , -- ** setArray #method:setArray# #if ENABLE_OVERLOADING StructureSetArrayMethodInfo , #endif structureSetArray , -- ** setList #method:setList# #if ENABLE_OVERLOADING StructureSetListMethodInfo , #endif structureSetList , -- ** setName #method:setName# #if ENABLE_OVERLOADING StructureSetNameMethodInfo , #endif structureSetName , -- ** setParentRefcount #method:setParentRefcount# #if ENABLE_OVERLOADING StructureSetParentRefcountMethodInfo , #endif structureSetParentRefcount , -- ** setValue #method:setValue# #if ENABLE_OVERLOADING StructureSetValueMethodInfo , #endif structureSetValue , -- ** takeValue #method:takeValue# #if ENABLE_OVERLOADING StructureTakeValueMethodInfo , #endif structureTakeValue , -- ** toString #method:toString# #if ENABLE_OVERLOADING StructureToStringMethodInfo , #endif structureToString , -- * Properties -- ** type #attr:type# {- | the GType of a structure -} getStructureType , setStructureType , #if ENABLE_OVERLOADING structure_type , #endif ) 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.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.GLib.Structs.Date as GLib.Date import qualified GI.GObject.Structs.ValueArray as GObject.ValueArray import qualified GI.Gst.Callbacks as Gst.Callbacks import {-# SOURCE #-} qualified GI.Gst.Structs.DateTime as Gst.DateTime -- | Memory-managed wrapper type. newtype Structure = Structure (ManagedPtr Structure) foreign import ccall "gst_structure_get_type" c_gst_structure_get_type :: IO GType instance BoxedObject Structure where boxedType _ = c_gst_structure_get_type -- | Construct a `Structure` struct initialized to zero. newZeroStructure :: MonadIO m => m Structure newZeroStructure = liftIO $ callocBoxedBytes 16 >>= wrapBoxed Structure instance tag ~ 'AttrSet => Constructible Structure tag where new _ attrs = do o <- newZeroStructure GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `Structure`. noStructure :: Maybe Structure noStructure = Nothing {- | Get the value of the “@type@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' structure #type @ -} getStructureType :: MonadIO m => Structure -> m GType getStructureType s = liftIO $ withManagedPtr s $ \ptr -> do val <- peek (ptr `plusPtr` 0) :: IO CGType let val' = GType val return val' {- | Set the value of the “@type@” field. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' structure [ #type 'Data.GI.Base.Attributes.:=' value ] @ -} setStructureType :: MonadIO m => Structure -> GType -> m () setStructureType s val = liftIO $ withManagedPtr s $ \ptr -> do let val' = gtypeToCGType val poke (ptr `plusPtr` 0) (val' :: CGType) #if ENABLE_OVERLOADING data StructureTypeFieldInfo instance AttrInfo StructureTypeFieldInfo where type AttrAllowedOps StructureTypeFieldInfo = '[ 'AttrSet, 'AttrGet] type AttrSetTypeConstraint StructureTypeFieldInfo = (~) GType type AttrBaseTypeConstraint StructureTypeFieldInfo = (~) Structure type AttrGetType StructureTypeFieldInfo = GType type AttrLabel StructureTypeFieldInfo = "type" type AttrOrigin StructureTypeFieldInfo = Structure attrGet _ = getStructureType attrSet _ = setStructureType attrConstruct = undefined attrClear _ = undefined structure_type :: AttrLabelProxy "type" structure_type = AttrLabelProxy #endif #if ENABLE_OVERLOADING instance O.HasAttributeList Structure type instance O.AttributeList Structure = StructureAttributeList type StructureAttributeList = ('[ '("type", StructureTypeFieldInfo)] :: [(Symbol, *)]) #endif -- method Structure::new_empty -- method type : Constructor -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of new structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_new_empty" gst_structure_new_empty :: CString -> -- name : TBasicType TUTF8 IO (Ptr Structure) {- | Creates a new, empty 'GI.Gst.Structs.Structure.Structure' with the given /@name@/. See 'GI.Gst.Structs.Structure.structureSetName' for constraints on the /@name@/ parameter. Free-function: gst_structure_free -} structureNewEmpty :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@name@/: name of new structure -} -> m Structure {- ^ __Returns:__ a new, empty 'GI.Gst.Structs.Structure.Structure' -} structureNewEmpty name = liftIO $ do name' <- textToCString name result <- gst_structure_new_empty name' checkUnexpectedReturnNULL "structureNewEmpty" result result' <- (wrapBoxed Structure) result freeMem name' return result' #if ENABLE_OVERLOADING #endif -- method Structure::new_from_string -- method type : Constructor -- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string representation of a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_new_from_string" gst_structure_new_from_string :: CString -> -- string : TBasicType TUTF8 IO (Ptr Structure) {- | Creates a 'GI.Gst.Structs.Structure.Structure' from a string representation. If end is not 'Nothing', a pointer to the place inside the given string where parsing ended will be returned. The current implementation of serialization will lead to unexpected results when there are nested 'GI.Gst.Structs.Caps.Caps' \/ 'GI.Gst.Structs.Structure.Structure' deeper than one level. Free-function: gst_structure_free /Since: 1.2/ -} structureNewFromString :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@string@/: a string representation of a 'GI.Gst.Structs.Structure.Structure' -} -> m (Maybe Structure) {- ^ __Returns:__ a new 'GI.Gst.Structs.Structure.Structure' or 'Nothing' when the string could not be parsed. Free with 'GI.Gst.Structs.Structure.structureFree' after use. -} structureNewFromString string = liftIO $ do string' <- textToCString string result <- gst_structure_new_from_string string' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Structure) result' return result'' freeMem string' return maybeResult #if ENABLE_OVERLOADING #endif -- method Structure::new_id_empty -- method type : Constructor -- Args : [Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "name of new structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_new_id_empty" gst_structure_new_id_empty :: Word32 -> -- quark : TBasicType TUInt32 IO (Ptr Structure) {- | Creates a new, empty 'GI.Gst.Structs.Structure.Structure' with the given name as a GQuark. Free-function: gst_structure_free -} structureNewIdEmpty :: (B.CallStack.HasCallStack, MonadIO m) => Word32 {- ^ /@quark@/: name of new structure -} -> m Structure {- ^ __Returns:__ a new, empty 'GI.Gst.Structs.Structure.Structure' -} structureNewIdEmpty quark = liftIO $ do result <- gst_structure_new_id_empty quark checkUnexpectedReturnNULL "structureNewIdEmpty" result result' <- (wrapBoxed Structure) result return result' #if ENABLE_OVERLOADING #endif -- method Structure::can_intersect -- method type : OrdinaryMethod -- Args : [Arg {argCName = "struct1", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "struct2", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_can_intersect" gst_structure_can_intersect :: Ptr Structure -> -- struct1 : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr Structure -> -- struct2 : TInterface (Name {namespace = "Gst", name = "Structure"}) IO CInt {- | Tries intersecting /@struct1@/ and /@struct2@/ and reports whether the result would not be empty. -} structureCanIntersect :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@struct1@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Structure {- ^ /@struct2@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m Bool {- ^ __Returns:__ 'True' if intersection would not be empty -} structureCanIntersect struct1 struct2 = liftIO $ do struct1' <- unsafeManagedPtrGetPtr struct1 struct2' <- unsafeManagedPtrGetPtr struct2 result <- gst_structure_can_intersect struct1' struct2' let result' = (/= 0) result touchManagedPtr struct1 touchManagedPtr struct2 return result' #if ENABLE_OVERLOADING data StructureCanIntersectMethodInfo instance (signature ~ (Structure -> m Bool), MonadIO m) => O.MethodInfo StructureCanIntersectMethodInfo Structure signature where overloadedMethod _ = structureCanIntersect #endif -- method Structure::copy -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure to duplicate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_copy" gst_structure_copy :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO (Ptr Structure) {- | Duplicates a 'GI.Gst.Structs.Structure.Structure' and all its fields and values. Free-function: gst_structure_free -} structureCopy :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' to duplicate -} -> m Structure {- ^ __Returns:__ a new 'GI.Gst.Structs.Structure.Structure'. -} structureCopy structure = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_copy structure' checkUnexpectedReturnNULL "structureCopy" result result' <- (wrapBoxed Structure) result touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureCopyMethodInfo instance (signature ~ (m Structure), MonadIO m) => O.MethodInfo StructureCopyMethodInfo Structure signature where overloadedMethod _ = structureCopy #endif -- method Structure::filter_and_map_in_place -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gst", name = "StructureFilterMapFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a function to call for each field", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "private data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_filter_and_map_in_place" gst_structure_filter_and_map_in_place :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) FunPtr Gst.Callbacks.C_StructureFilterMapFunc -> -- func : TInterface (Name {namespace = "Gst", name = "StructureFilterMapFunc"}) Ptr () -> -- user_data : TBasicType TPtr IO () {- | Calls the provided function once for each field in the 'GI.Gst.Structs.Structure.Structure'. In contrast to 'GI.Gst.Structs.Structure.structureForeach', the function may modify the fields. In contrast to 'GI.Gst.Structs.Structure.structureMapInPlace', the field is removed from the structure if 'False' is returned from the function. The structure must be mutable. /Since: 1.6/ -} structureFilterAndMapInPlace :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Gst.Callbacks.StructureFilterMapFunc {- ^ /@func@/: a function to call for each field -} -> m () structureFilterAndMapInPlace structure func = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure func' <- Gst.Callbacks.mk_StructureFilterMapFunc (Gst.Callbacks.wrap_StructureFilterMapFunc Nothing (Gst.Callbacks.drop_closures_StructureFilterMapFunc func)) let userData = nullPtr gst_structure_filter_and_map_in_place structure' func' userData safeFreeFunPtr $ castFunPtrToPtr func' touchManagedPtr structure return () #if ENABLE_OVERLOADING data StructureFilterAndMapInPlaceMethodInfo instance (signature ~ (Gst.Callbacks.StructureFilterMapFunc -> m ()), MonadIO m) => O.MethodInfo StructureFilterAndMapInPlaceMethodInfo Structure signature where overloadedMethod _ = structureFilterAndMapInPlace #endif -- method Structure::fixate -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_fixate" gst_structure_fixate :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO () {- | Fixate all values in /@structure@/ using 'GI.Gst.Functions.valueFixate'. /@structure@/ will be modified in-place and should be writable. -} structureFixate :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m () structureFixate structure = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure gst_structure_fixate structure' touchManagedPtr structure return () #if ENABLE_OVERLOADING data StructureFixateMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureFixateMethodInfo Structure signature where overloadedMethod _ = structureFixate #endif -- method Structure::fixate_field -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field in @structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_fixate_field" gst_structure_fixate_field :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- field_name : TBasicType TUTF8 IO CInt {- | Fixates a 'GI.Gst.Structs.Structure.Structure' by changing the given field with its fixated value. -} structureFixateField :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldName@/: a field in /@structure@/ -} -> m Bool {- ^ __Returns:__ 'True' if the structure field could be fixated -} structureFixateField structure fieldName = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldName' <- textToCString fieldName result <- gst_structure_fixate_field structure' fieldName' let result' = (/= 0) result touchManagedPtr structure freeMem fieldName' return result' #if ENABLE_OVERLOADING data StructureFixateFieldMethodInfo instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldMethodInfo Structure signature where overloadedMethod _ = structureFixateField #endif -- method Structure::fixate_field_boolean -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field in @structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target value of the fixation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_fixate_field_boolean" gst_structure_fixate_field_boolean :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- field_name : TBasicType TUTF8 CInt -> -- target : TBasicType TBoolean IO CInt {- | Fixates a 'GI.Gst.Structs.Structure.Structure' by changing the given /@fieldName@/ field to the given /@target@/ boolean if that field is not fixed yet. -} structureFixateFieldBoolean :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldName@/: a field in /@structure@/ -} -> Bool {- ^ /@target@/: the target value of the fixation -} -> m Bool {- ^ __Returns:__ 'True' if the structure could be fixated -} structureFixateFieldBoolean structure fieldName target = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldName' <- textToCString fieldName let target' = (fromIntegral . fromEnum) target result <- gst_structure_fixate_field_boolean structure' fieldName' target' let result' = (/= 0) result touchManagedPtr structure freeMem fieldName' return result' #if ENABLE_OVERLOADING data StructureFixateFieldBooleanMethodInfo instance (signature ~ (T.Text -> Bool -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldBooleanMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldBoolean #endif -- method Structure::fixate_field_nearest_double -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field in @structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target value of the fixation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_fixate_field_nearest_double" gst_structure_fixate_field_nearest_double :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- field_name : TBasicType TUTF8 CDouble -> -- target : TBasicType TDouble IO CInt {- | Fixates a 'GI.Gst.Structs.Structure.Structure' by changing the given field to the nearest double to /@target@/ that is a subset of the existing field. -} structureFixateFieldNearestDouble :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldName@/: a field in /@structure@/ -} -> Double {- ^ /@target@/: the target value of the fixation -} -> m Bool {- ^ __Returns:__ 'True' if the structure could be fixated -} structureFixateFieldNearestDouble structure fieldName target = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldName' <- textToCString fieldName let target' = realToFrac target result <- gst_structure_fixate_field_nearest_double structure' fieldName' target' let result' = (/= 0) result touchManagedPtr structure freeMem fieldName' return result' #if ENABLE_OVERLOADING data StructureFixateFieldNearestDoubleMethodInfo instance (signature ~ (T.Text -> Double -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldNearestDoubleMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldNearestDouble #endif -- method Structure::fixate_field_nearest_fraction -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field in @structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_numerator", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The numerator of the target value of the fixation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_denominator", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The denominator of the target value of the fixation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_fixate_field_nearest_fraction" gst_structure_fixate_field_nearest_fraction :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- field_name : TBasicType TUTF8 Int32 -> -- target_numerator : TBasicType TInt Int32 -> -- target_denominator : TBasicType TInt IO CInt {- | Fixates a 'GI.Gst.Structs.Structure.Structure' by changing the given field to the nearest fraction to /@targetNumerator@/\//@targetDenominator@/ that is a subset of the existing field. -} structureFixateFieldNearestFraction :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldName@/: a field in /@structure@/ -} -> Int32 {- ^ /@targetNumerator@/: The numerator of the target value of the fixation -} -> Int32 {- ^ /@targetDenominator@/: The denominator of the target value of the fixation -} -> m Bool {- ^ __Returns:__ 'True' if the structure could be fixated -} structureFixateFieldNearestFraction structure fieldName targetNumerator targetDenominator = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldName' <- textToCString fieldName result <- gst_structure_fixate_field_nearest_fraction structure' fieldName' targetNumerator targetDenominator let result' = (/= 0) result touchManagedPtr structure freeMem fieldName' return result' #if ENABLE_OVERLOADING data StructureFixateFieldNearestFractionMethodInfo instance (signature ~ (T.Text -> Int32 -> Int32 -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldNearestFractionMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldNearestFraction #endif -- method Structure::fixate_field_nearest_int -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field in @structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target value of the fixation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_fixate_field_nearest_int" gst_structure_fixate_field_nearest_int :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- field_name : TBasicType TUTF8 Int32 -> -- target : TBasicType TInt IO CInt {- | Fixates a 'GI.Gst.Structs.Structure.Structure' by changing the given field to the nearest integer to /@target@/ that is a subset of the existing field. -} structureFixateFieldNearestInt :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldName@/: a field in /@structure@/ -} -> Int32 {- ^ /@target@/: the target value of the fixation -} -> m Bool {- ^ __Returns:__ 'True' if the structure could be fixated -} structureFixateFieldNearestInt structure fieldName target = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldName' <- textToCString fieldName result <- gst_structure_fixate_field_nearest_int structure' fieldName' target let result' = (/= 0) result touchManagedPtr structure freeMem fieldName' return result' #if ENABLE_OVERLOADING data StructureFixateFieldNearestIntMethodInfo instance (signature ~ (T.Text -> Int32 -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldNearestIntMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldNearestInt #endif -- method Structure::fixate_field_string -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a field in @structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the target value of the fixation", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_fixate_field_string" gst_structure_fixate_field_string :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- field_name : TBasicType TUTF8 CString -> -- target : TBasicType TUTF8 IO CInt {- | Fixates a 'GI.Gst.Structs.Structure.Structure' by changing the given /@fieldName@/ field to the given /@target@/ string if that field is not fixed yet. -} structureFixateFieldString :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldName@/: a field in /@structure@/ -} -> T.Text {- ^ /@target@/: the target value of the fixation -} -> m Bool {- ^ __Returns:__ 'True' if the structure could be fixated -} structureFixateFieldString structure fieldName target = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldName' <- textToCString fieldName target' <- textToCString target result <- gst_structure_fixate_field_string structure' fieldName' target' let result' = (/= 0) result touchManagedPtr structure freeMem fieldName' freeMem target' return result' #if ENABLE_OVERLOADING data StructureFixateFieldStringMethodInfo instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldStringMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldString #endif -- method Structure::foreach -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gst", name = "StructureForeachFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a function to call for each field", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "private data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_foreach" gst_structure_foreach :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) FunPtr Gst.Callbacks.C_StructureForeachFunc -> -- func : TInterface (Name {namespace = "Gst", name = "StructureForeachFunc"}) Ptr () -> -- user_data : TBasicType TPtr IO CInt {- | Calls the provided function once for each field in the 'GI.Gst.Structs.Structure.Structure'. The function must not modify the fields. Also see 'GI.Gst.Structs.Structure.structureMapInPlace' and 'GI.Gst.Structs.Structure.structureFilterAndMapInPlace'. -} structureForeach :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Gst.Callbacks.StructureForeachFunc {- ^ /@func@/: a function to call for each field -} -> m Bool {- ^ __Returns:__ 'True' if the supplied function returns 'True' For each of the fields, 'False' otherwise. -} structureForeach structure func = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure func' <- Gst.Callbacks.mk_StructureForeachFunc (Gst.Callbacks.wrap_StructureForeachFunc Nothing (Gst.Callbacks.drop_closures_StructureForeachFunc func)) let userData = nullPtr result <- gst_structure_foreach structure' func' userData let result' = (/= 0) result safeFreeFunPtr $ castFunPtrToPtr func' touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureForeachMethodInfo instance (signature ~ (Gst.Callbacks.StructureForeachFunc -> m Bool), MonadIO m) => O.MethodInfo StructureForeachMethodInfo Structure signature where overloadedMethod _ = structureForeach #endif -- method Structure::free -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GstStructure to free", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_free" gst_structure_free :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO () {- | Frees a 'GI.Gst.Structs.Structure.Structure' and all its fields and values. The structure must not have a parent when this function is called. -} structureFree :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: the 'GI.Gst.Structs.Structure.Structure' to free -} -> m () structureFree structure = liftIO $ do structure' <- B.ManagedPtr.disownBoxed structure gst_structure_free structure' touchManagedPtr structure return () #if ENABLE_OVERLOADING data StructureFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureFreeMethodInfo Structure signature where overloadedMethod _ = structureFree #endif -- method Structure::get_array -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GValueArray", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_array" gst_structure_get_array :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr (Ptr GObject.ValueArray.ValueArray) -> -- array : TInterface (Name {namespace = "GObject", name = "ValueArray"}) IO CInt {- | This is useful in language bindings where unknown 'GI.GObject.Structs.Value.Value' types are not supported. This function will convert the @/GST_TYPE_ARRAY/@ into a newly allocated 'GI.GObject.Structs.ValueArray.ValueArray' and return it through /@array@/. Be aware that this is slower then getting the 'GI.GObject.Structs.Value.Value' directly. -} structureGetArray :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, GObject.ValueArray.ValueArray)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a @/GST_TYPE_ARRAY/@, this function returns 'False'. -} structureGetArray structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname array <- allocMem :: IO (Ptr (Ptr GObject.ValueArray.ValueArray)) result <- gst_structure_get_array structure' fieldname' array let result' = (/= 0) result array' <- peek array array'' <- (wrapBoxed GObject.ValueArray.ValueArray) array' touchManagedPtr structure freeMem fieldname' freeMem array return (result', array'') #if ENABLE_OVERLOADING data StructureGetArrayMethodInfo instance (signature ~ (T.Text -> m ((Bool, GObject.ValueArray.ValueArray))), MonadIO m) => O.MethodInfo StructureGetArrayMethodInfo Structure signature where overloadedMethod _ = structureGetArray #endif -- method Structure::get_boolean -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #gboolean to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_boolean" gst_structure_get_boolean :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr CInt -> -- value : TBasicType TBoolean IO CInt {- | Sets the boolean pointed to by /@value@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists and has the correct type. -} structureGetBoolean :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Bool)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a boolean, this function returns 'False'. -} structureGetBoolean structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr CInt) result <- gst_structure_get_boolean structure' fieldname' value let result' = (/= 0) result value' <- peek value let value'' = (/= 0) value' touchManagedPtr structure freeMem fieldname' freeMem value return (result', value'') #if ENABLE_OVERLOADING data StructureGetBooleanMethodInfo instance (signature ~ (T.Text -> m ((Bool, Bool))), MonadIO m) => O.MethodInfo StructureGetBooleanMethodInfo Structure signature where overloadedMethod _ = structureGetBoolean #endif -- method Structure::get_clock_time -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GstClockTime to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_clock_time" gst_structure_get_clock_time :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr Word64 -> -- value : TBasicType TUInt64 IO CInt {- | Sets the clock time pointed to by /@value@/ corresponding to the clock time of the given field. Caller is responsible for making sure the field exists and has the correct type. -} structureGetClockTime :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Word64)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a @/GstClockTime/@, this function returns 'False'. -} structureGetClockTime structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr Word64) result <- gst_structure_get_clock_time structure' fieldname' value let result' = (/= 0) result value' <- peek value touchManagedPtr structure freeMem fieldname' freeMem value return (result', value') #if ENABLE_OVERLOADING data StructureGetClockTimeMethodInfo instance (signature ~ (T.Text -> m ((Bool, Word64))), MonadIO m) => O.MethodInfo StructureGetClockTimeMethodInfo Structure signature where overloadedMethod _ = structureGetClockTime #endif -- method Structure::get_date -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GLib", name = "Date"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GDate to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_date" gst_structure_get_date :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr (Ptr GLib.Date.Date) -> -- value : TInterface (Name {namespace = "GLib", name = "Date"}) IO CInt {- | Sets the date pointed to by /@value@/ corresponding to the date of the given field. Caller is responsible for making sure the field exists and has the correct type. On success /@value@/ will point to a newly-allocated copy of the date which should be freed with 'GI.GLib.Structs.Date.dateFree' when no longer needed (note: this is inconsistent with e.g. 'GI.Gst.Structs.Structure.structureGetString' which doesn\'t return a copy of the string). -} structureGetDate :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, GLib.Date.Date)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a data, this function returns 'False'. -} structureGetDate structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr (Ptr GLib.Date.Date)) result <- gst_structure_get_date structure' fieldname' value let result' = (/= 0) result value' <- peek value value'' <- (wrapBoxed GLib.Date.Date) value' touchManagedPtr structure freeMem fieldname' freeMem value return (result', value'') #if ENABLE_OVERLOADING data StructureGetDateMethodInfo instance (signature ~ (T.Text -> m ((Bool, GLib.Date.Date))), MonadIO m) => O.MethodInfo StructureGetDateMethodInfo Structure signature where overloadedMethod _ = structureGetDate #endif -- method Structure::get_date_time -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "Gst", name = "DateTime"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GstDateTime to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_date_time" gst_structure_get_date_time :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr (Ptr Gst.DateTime.DateTime) -> -- value : TInterface (Name {namespace = "Gst", name = "DateTime"}) IO CInt {- | Sets the datetime pointed to by /@value@/ corresponding to the datetime of the given field. Caller is responsible for making sure the field exists and has the correct type. On success /@value@/ will point to a reference of the datetime which should be unreffed with 'GI.Gst.Structs.DateTime.dateTimeUnref' when no longer needed (note: this is inconsistent with e.g. 'GI.Gst.Structs.Structure.structureGetString' which doesn\'t return a copy of the string). -} structureGetDateTime :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Gst.DateTime.DateTime)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a data, this function returns 'False'. -} structureGetDateTime structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr (Ptr Gst.DateTime.DateTime)) result <- gst_structure_get_date_time structure' fieldname' value let result' = (/= 0) result value' <- peek value value'' <- (wrapBoxed Gst.DateTime.DateTime) value' touchManagedPtr structure freeMem fieldname' freeMem value return (result', value'') #if ENABLE_OVERLOADING data StructureGetDateTimeMethodInfo instance (signature ~ (T.Text -> m ((Bool, Gst.DateTime.DateTime))), MonadIO m) => O.MethodInfo StructureGetDateTimeMethodInfo Structure signature where overloadedMethod _ = structureGetDateTime #endif -- method Structure::get_double -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a gdouble to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_double" gst_structure_get_double :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr CDouble -> -- value : TBasicType TDouble IO CInt {- | Sets the double pointed to by /@value@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists and has the correct type. -} structureGetDouble :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Double)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a double, this function returns 'False'. -} structureGetDouble structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr CDouble) result <- gst_structure_get_double structure' fieldname' value let result' = (/= 0) result value' <- peek value let value'' = realToFrac value' touchManagedPtr structure freeMem fieldname' freeMem value return (result', value'') #if ENABLE_OVERLOADING data StructureGetDoubleMethodInfo instance (signature ~ (T.Text -> m ((Bool, Double))), MonadIO m) => O.MethodInfo StructureGetDoubleMethodInfo Structure signature where overloadedMethod _ = structureGetDouble #endif -- method Structure::get_enum -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enumtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the enum type of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an int to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_enum" gst_structure_get_enum :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 CGType -> -- enumtype : TBasicType TGType Ptr Int32 -> -- value : TBasicType TInt IO CInt {- | Sets the int pointed to by /@value@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists, has the correct type and that the enumtype is correct. -} structureGetEnum :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> GType {- ^ /@enumtype@/: the enum type of a field -} -> m ((Bool, Int32)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain an enum of the given type, this function returns 'False'. -} structureGetEnum structure fieldname enumtype = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname let enumtype' = gtypeToCGType enumtype value <- allocMem :: IO (Ptr Int32) result <- gst_structure_get_enum structure' fieldname' enumtype' value let result' = (/= 0) result value' <- peek value touchManagedPtr structure freeMem fieldname' freeMem value return (result', value') #if ENABLE_OVERLOADING data StructureGetEnumMethodInfo instance (signature ~ (T.Text -> GType -> m ((Bool, Int32))), MonadIO m) => O.MethodInfo StructureGetEnumMethodInfo Structure signature where overloadedMethod _ = structureGetEnum #endif -- method Structure::get_field_type -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the field", 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_structure_get_field_type" gst_structure_get_field_type :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 IO CGType {- | Finds the field with the given name, and returns the type of the value it contains. If the field is not found, G_TYPE_INVALID is returned. -} structureGetFieldType :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of the field -} -> m GType {- ^ __Returns:__ the 'GI.GObject.Structs.Value.Value' of the field -} structureGetFieldType structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname result <- gst_structure_get_field_type structure' fieldname' let result' = GType result touchManagedPtr structure freeMem fieldname' return result' #if ENABLE_OVERLOADING data StructureGetFieldTypeMethodInfo instance (signature ~ (T.Text -> m GType), MonadIO m) => O.MethodInfo StructureGetFieldTypeMethodInfo Structure signature where overloadedMethod _ = structureGetFieldType #endif -- method Structure::get_flagset -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_flags", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a guint for the flags field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "value_mask", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a guint for the mask field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_flagset" gst_structure_get_flagset :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr Word32 -> -- value_flags : TBasicType TUInt Ptr Word32 -> -- value_mask : TBasicType TUInt IO CInt {- | Read the GstFlagSet flags and mask out of the structure into the provided pointers. /Since: 1.6/ -} structureGetFlagset :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Word32, Word32)) {- ^ __Returns:__ 'True' if the values could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a GstFlagSet, this function returns 'False'. -} structureGetFlagset structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname valueFlags <- allocMem :: IO (Ptr Word32) valueMask <- allocMem :: IO (Ptr Word32) result <- gst_structure_get_flagset structure' fieldname' valueFlags valueMask let result' = (/= 0) result valueFlags' <- peek valueFlags valueMask' <- peek valueMask touchManagedPtr structure freeMem fieldname' freeMem valueFlags freeMem valueMask return (result', valueFlags', valueMask') #if ENABLE_OVERLOADING data StructureGetFlagsetMethodInfo instance (signature ~ (T.Text -> m ((Bool, Word32, Word32))), MonadIO m) => O.MethodInfo StructureGetFlagsetMethodInfo Structure signature where overloadedMethod _ = structureGetFlagset #endif -- method Structure::get_fraction -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_numerator", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an int to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "value_denominator", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an int to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_fraction" gst_structure_get_fraction :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr Int32 -> -- value_numerator : TBasicType TInt Ptr Int32 -> -- value_denominator : TBasicType TInt IO CInt {- | Sets the integers pointed to by /@valueNumerator@/ and /@valueDenominator@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists and has the correct type. -} structureGetFraction :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Int32, Int32)) {- ^ __Returns:__ 'True' if the values could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a GstFraction, this function returns 'False'. -} structureGetFraction structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname valueNumerator <- allocMem :: IO (Ptr Int32) valueDenominator <- allocMem :: IO (Ptr Int32) result <- gst_structure_get_fraction structure' fieldname' valueNumerator valueDenominator let result' = (/= 0) result valueNumerator' <- peek valueNumerator valueDenominator' <- peek valueDenominator touchManagedPtr structure freeMem fieldname' freeMem valueNumerator freeMem valueDenominator return (result', valueNumerator', valueDenominator') #if ENABLE_OVERLOADING data StructureGetFractionMethodInfo instance (signature ~ (T.Text -> m ((Bool, Int32, Int32))), MonadIO m) => O.MethodInfo StructureGetFractionMethodInfo Structure signature where overloadedMethod _ = structureGetFraction #endif -- method Structure::get_int -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an int to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_int" gst_structure_get_int :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr Int32 -> -- value : TBasicType TInt IO CInt {- | Sets the int pointed to by /@value@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists and has the correct type. -} structureGetInt :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Int32)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain an int, this function returns 'False'. -} structureGetInt structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr Int32) result <- gst_structure_get_int structure' fieldname' value let result' = (/= 0) result value' <- peek value touchManagedPtr structure freeMem fieldname' freeMem value return (result', value') #if ENABLE_OVERLOADING data StructureGetIntMethodInfo instance (signature ~ (T.Text -> m ((Bool, Int32))), MonadIO m) => O.MethodInfo StructureGetIntMethodInfo Structure signature where overloadedMethod _ = structureGetInt #endif -- method Structure::get_int64 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #gint64 to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_int64" gst_structure_get_int64 :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr Int64 -> -- value : TBasicType TInt64 IO CInt {- | Sets the @/gint64/@ pointed to by /@value@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists and has the correct type. /Since: 1.4/ -} structureGetInt64 :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Int64)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a @/gint64/@, this function returns 'False'. -} structureGetInt64 structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr Int64) result <- gst_structure_get_int64 structure' fieldname' value let result' = (/= 0) result value' <- peek value touchManagedPtr structure freeMem fieldname' freeMem value return (result', value') #if ENABLE_OVERLOADING data StructureGetInt64MethodInfo instance (signature ~ (T.Text -> m ((Bool, Int64))), MonadIO m) => O.MethodInfo StructureGetInt64MethodInfo Structure signature where overloadedMethod _ = structureGetInt64 #endif -- method Structure::get_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GValueArray", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_list" gst_structure_get_list :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr (Ptr GObject.ValueArray.ValueArray) -> -- array : TInterface (Name {namespace = "GObject", name = "ValueArray"}) IO CInt {- | This is useful in language bindings where unknown 'GI.GObject.Structs.Value.Value' types are not supported. This function will convert the @/GST_TYPE_LIST/@ into a newly allocated GValueArray and return it through /@array@/. Be aware that this is slower then getting the 'GI.GObject.Structs.Value.Value' directly. -} structureGetList :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, GObject.ValueArray.ValueArray)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a @/GST_TYPE_LIST/@, this function returns 'False'. Since 1.12 -} structureGetList structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname array <- allocMem :: IO (Ptr (Ptr GObject.ValueArray.ValueArray)) result <- gst_structure_get_list structure' fieldname' array let result' = (/= 0) result array' <- peek array array'' <- (wrapBoxed GObject.ValueArray.ValueArray) array' touchManagedPtr structure freeMem fieldname' freeMem array return (result', array'') #if ENABLE_OVERLOADING data StructureGetListMethodInfo instance (signature ~ (T.Text -> m ((Bool, GObject.ValueArray.ValueArray))), MonadIO m) => O.MethodInfo StructureGetListMethodInfo Structure signature where overloadedMethod _ = structureGetList #endif -- method Structure::get_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_name" gst_structure_get_name :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO CString {- | Get the name of /@structure@/ as a string. -} structureGetName :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m T.Text {- ^ __Returns:__ the name of the structure. -} structureGetName structure = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_get_name structure' checkUnexpectedReturnNULL "structureGetName" result result' <- cstringToText result touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureGetNameMethodInfo instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo StructureGetNameMethodInfo Structure signature where overloadedMethod _ = structureGetName #endif -- method Structure::get_name_id -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt32) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_name_id" gst_structure_get_name_id :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO Word32 {- | Get the name of /@structure@/ as a GQuark. -} structureGetNameId :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m Word32 {- ^ __Returns:__ the quark representing the name of the structure. -} structureGetNameId structure = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_get_name_id structure' touchManagedPtr structure return result #if ENABLE_OVERLOADING data StructureGetNameIdMethodInfo instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo StructureGetNameIdMethodInfo Structure signature where overloadedMethod _ = structureGetNameId #endif -- method Structure::get_string -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_string" gst_structure_get_string :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 IO CString {- | Finds the field corresponding to /@fieldname@/, and returns the string contained in the field\'s value. Caller is responsible for making sure the field exists and has the correct type. The string should not be modified, and remains valid until the next call to a gst_structure_*() function with the given structure. -} structureGetString :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m (Maybe T.Text) {- ^ __Returns:__ a pointer to the string or 'Nothing' when the field did not exist or did not contain a string. -} structureGetString structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname result <- gst_structure_get_string structure' fieldname' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr structure freeMem fieldname' return maybeResult #if ENABLE_OVERLOADING data StructureGetStringMethodInfo instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo StructureGetStringMethodInfo Structure signature where overloadedMethod _ = structureGetString #endif -- method Structure::get_uint -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a uint to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_uint" gst_structure_get_uint :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr Word32 -> -- value : TBasicType TUInt IO CInt {- | Sets the uint pointed to by /@value@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists and has the correct type. -} structureGetUint :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Word32)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a uint, this function returns 'False'. -} structureGetUint structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr Word32) result <- gst_structure_get_uint structure' fieldname' value let result' = (/= 0) result value' <- peek value touchManagedPtr structure freeMem fieldname' freeMem value return (result', value') #if ENABLE_OVERLOADING data StructureGetUintMethodInfo instance (signature ~ (T.Text -> m ((Bool, Word32))), MonadIO m) => O.MethodInfo StructureGetUintMethodInfo Structure signature where overloadedMethod _ = structureGetUint #endif -- method Structure::get_uint64 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #guint64 to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_uint64" gst_structure_get_uint64 :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr Word64 -> -- value : TBasicType TUInt64 IO CInt {- | Sets the @/guint64/@ pointed to by /@value@/ corresponding to the value of the given field. Caller is responsible for making sure the field exists and has the correct type. /Since: 1.4/ -} structureGetUint64 :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m ((Bool, Word64)) {- ^ __Returns:__ 'True' if the value could be set correctly. If there was no field with /@fieldname@/ or the existing field did not contain a @/guint64/@, this function returns 'False'. -} structureGetUint64 structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value <- allocMem :: IO (Ptr Word64) result <- gst_structure_get_uint64 structure' fieldname' value let result' = (/= 0) result value' <- peek value touchManagedPtr structure freeMem fieldname' freeMem value return (result', value') #if ENABLE_OVERLOADING data StructureGetUint64MethodInfo instance (signature ~ (T.Text -> m ((Bool, Word64))), MonadIO m) => O.MethodInfo StructureGetUint64MethodInfo Structure signature where overloadedMethod _ = structureGetUint64 #endif -- method Structure::get_value -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the field to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_get_value" gst_structure_get_value :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 IO (Ptr GValue) {- | Get the value of the field with name /@fieldname@/. -} structureGetValue :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of the field to get -} -> m (Maybe GValue) {- ^ __Returns:__ the 'GI.GObject.Structs.Value.Value' corresponding to the field with the given name. -} structureGetValue structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname result <- gst_structure_get_value structure' fieldname' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newBoxed GValue) result' return result'' touchManagedPtr structure freeMem fieldname' return maybeResult #if ENABLE_OVERLOADING data StructureGetValueMethodInfo instance (signature ~ (T.Text -> m (Maybe GValue)), MonadIO m) => O.MethodInfo StructureGetValueMethodInfo Structure signature where overloadedMethod _ = structureGetValue #endif -- method Structure::has_field -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_has_field" gst_structure_has_field :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 IO CInt {- | Check if /@structure@/ contains a field named /@fieldname@/. -} structureHasField :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> m Bool {- ^ __Returns:__ 'True' if the structure contains a field with the given name -} structureHasField structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname result <- gst_structure_has_field structure' fieldname' let result' = (/= 0) result touchManagedPtr structure freeMem fieldname' return result' #if ENABLE_OVERLOADING data StructureHasFieldMethodInfo instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureHasFieldMethodInfo Structure signature where overloadedMethod _ = structureHasField #endif -- method Structure::has_field_typed -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of a value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_has_field_typed" gst_structure_has_field_typed :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 CGType -> -- type : TBasicType TGType IO CInt {- | Check if /@structure@/ contains a field named /@fieldname@/ and with GType /@type@/. -} structureHasFieldTyped :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> GType {- ^ /@type@/: the type of a value -} -> m Bool {- ^ __Returns:__ 'True' if the structure contains a field with the given name and type -} structureHasFieldTyped structure fieldname type_ = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname let type_' = gtypeToCGType type_ result <- gst_structure_has_field_typed structure' fieldname' type_' let result' = (/= 0) result touchManagedPtr structure freeMem fieldname' return result' #if ENABLE_OVERLOADING data StructureHasFieldTypedMethodInfo instance (signature ~ (T.Text -> GType -> m Bool), MonadIO m) => O.MethodInfo StructureHasFieldTypedMethodInfo Structure signature where overloadedMethod _ = structureHasFieldTyped #endif -- method Structure::has_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "structure name to check for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_has_name" gst_structure_has_name :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- name : TBasicType TUTF8 IO CInt {- | Checks if the structure has the given name -} structureHasName :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@name@/: structure name to check for -} -> m Bool {- ^ __Returns:__ 'True' if /@name@/ matches the name of the structure. -} structureHasName structure name = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure name' <- textToCString name result <- gst_structure_has_name structure' name' let result' = (/= 0) result touchManagedPtr structure freeMem name' return result' #if ENABLE_OVERLOADING data StructureHasNameMethodInfo instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureHasNameMethodInfo Structure signature where overloadedMethod _ = structureHasName #endif -- method Structure::id_get_value -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GQuark of the field to get", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GObject", name = "Value"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_id_get_value" gst_structure_id_get_value :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) Word32 -> -- field : TBasicType TUInt32 IO (Ptr GValue) {- | Get the value of the field with GQuark /@field@/. -} structureIdGetValue :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Word32 {- ^ /@field@/: the @/GQuark/@ of the field to get -} -> m (Maybe GValue) {- ^ __Returns:__ the 'GI.GObject.Structs.Value.Value' corresponding to the field with the given name identifier. -} structureIdGetValue structure field = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_id_get_value structure' field maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (newBoxed GValue) result' return result'' touchManagedPtr structure return maybeResult #if ENABLE_OVERLOADING data StructureIdGetValueMethodInfo instance (signature ~ (Word32 -> m (Maybe GValue)), MonadIO m) => O.MethodInfo StructureIdGetValueMethodInfo Structure signature where overloadedMethod _ = structureIdGetValue #endif -- method Structure::id_has_field -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GQuark of the field name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_id_has_field" gst_structure_id_has_field :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) Word32 -> -- field : TBasicType TUInt32 IO CInt {- | Check if /@structure@/ contains a field named /@field@/. -} structureIdHasField :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Word32 {- ^ /@field@/: @/GQuark/@ of the field name -} -> m Bool {- ^ __Returns:__ 'True' if the structure contains a field with the given name -} structureIdHasField structure field = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_id_has_field structure' field let result' = (/= 0) result touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureIdHasFieldMethodInfo instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.MethodInfo StructureIdHasFieldMethodInfo Structure signature where overloadedMethod _ = structureIdHasField #endif -- method Structure::id_has_field_typed -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "#GQuark of the field name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of a value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_id_has_field_typed" gst_structure_id_has_field_typed :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) Word32 -> -- field : TBasicType TUInt32 CGType -> -- type : TBasicType TGType IO CInt {- | Check if /@structure@/ contains a field named /@field@/ and with GType /@type@/. -} structureIdHasFieldTyped :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Word32 {- ^ /@field@/: @/GQuark/@ of the field name -} -> GType {- ^ /@type@/: the type of a value -} -> m Bool {- ^ __Returns:__ 'True' if the structure contains a field with the given name and type -} structureIdHasFieldTyped structure field type_ = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure let type_' = gtypeToCGType type_ result <- gst_structure_id_has_field_typed structure' field type_' let result' = (/= 0) result touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureIdHasFieldTypedMethodInfo instance (signature ~ (Word32 -> GType -> m Bool), MonadIO m) => O.MethodInfo StructureIdHasFieldTypedMethodInfo Structure signature where overloadedMethod _ = structureIdHasFieldTyped #endif -- method Structure::id_set_value -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQuark representing a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value of the field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_id_set_value" gst_structure_id_set_value :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) Word32 -> -- field : TBasicType TUInt32 Ptr GValue -> -- value : TInterface (Name {namespace = "GObject", name = "Value"}) IO () {- | Sets the field with the given GQuark /@field@/ to /@value@/. If the field does not exist, it is created. If the field exists, the previous value is replaced and freed. -} structureIdSetValue :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Word32 {- ^ /@field@/: a @/GQuark/@ representing a field -} -> GValue {- ^ /@value@/: the new value of the field -} -> m () structureIdSetValue structure field value = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure value' <- unsafeManagedPtrGetPtr value gst_structure_id_set_value structure' field value' touchManagedPtr structure touchManagedPtr value return () #if ENABLE_OVERLOADING data StructureIdSetValueMethodInfo instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureIdSetValueMethodInfo Structure signature where overloadedMethod _ = structureIdSetValue #endif -- method Structure::id_take_value -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GQuark representing a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value of the field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_id_take_value" gst_structure_id_take_value :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) Word32 -> -- field : TBasicType TUInt32 Ptr GValue -> -- value : TInterface (Name {namespace = "GObject", name = "Value"}) IO () {- | Sets the field with the given GQuark /@field@/ to /@value@/. If the field does not exist, it is created. If the field exists, the previous value is replaced and freed. -} structureIdTakeValue :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Word32 {- ^ /@field@/: a @/GQuark/@ representing a field -} -> GValue {- ^ /@value@/: the new value of the field -} -> m () structureIdTakeValue structure field value = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure value' <- B.ManagedPtr.disownBoxed value gst_structure_id_take_value structure' field value' touchManagedPtr structure touchManagedPtr value return () #if ENABLE_OVERLOADING data StructureIdTakeValueMethodInfo instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureIdTakeValueMethodInfo Structure signature where overloadedMethod _ = structureIdTakeValue #endif -- method Structure::intersect -- method type : OrdinaryMethod -- Args : [Arg {argCName = "struct1", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "struct2", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_intersect" gst_structure_intersect :: Ptr Structure -> -- struct1 : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr Structure -> -- struct2 : TInterface (Name {namespace = "Gst", name = "Structure"}) IO (Ptr Structure) {- | Intersects /@struct1@/ and /@struct2@/ and returns the intersection. -} structureIntersect :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@struct1@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Structure {- ^ /@struct2@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m (Maybe Structure) {- ^ __Returns:__ Intersection of /@struct1@/ and /@struct2@/ -} structureIntersect struct1 struct2 = liftIO $ do struct1' <- unsafeManagedPtrGetPtr struct1 struct2' <- unsafeManagedPtrGetPtr struct2 result <- gst_structure_intersect struct1' struct2' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Structure) result' return result'' touchManagedPtr struct1 touchManagedPtr struct2 return maybeResult #if ENABLE_OVERLOADING data StructureIntersectMethodInfo instance (signature ~ (Structure -> m (Maybe Structure)), MonadIO m) => O.MethodInfo StructureIntersectMethodInfo Structure signature where overloadedMethod _ = structureIntersect #endif -- method Structure::is_equal -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure1", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure2", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_is_equal" gst_structure_is_equal :: Ptr Structure -> -- structure1 : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr Structure -> -- structure2 : TInterface (Name {namespace = "Gst", name = "Structure"}) IO CInt {- | Tests if the two 'GI.Gst.Structs.Structure.Structure' are equal. -} structureIsEqual :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure1@/: a 'GI.Gst.Structs.Structure.Structure'. -} -> Structure {- ^ /@structure2@/: a 'GI.Gst.Structs.Structure.Structure'. -} -> m Bool {- ^ __Returns:__ 'True' if the two structures have the same name and field. -} structureIsEqual structure1 structure2 = liftIO $ do structure1' <- unsafeManagedPtrGetPtr structure1 structure2' <- unsafeManagedPtrGetPtr structure2 result <- gst_structure_is_equal structure1' structure2' let result' = (/= 0) result touchManagedPtr structure1 touchManagedPtr structure2 return result' #if ENABLE_OVERLOADING data StructureIsEqualMethodInfo instance (signature ~ (Structure -> m Bool), MonadIO m) => O.MethodInfo StructureIsEqualMethodInfo Structure signature where overloadedMethod _ = structureIsEqual #endif -- method Structure::is_subset -- method type : OrdinaryMethod -- Args : [Arg {argCName = "subset", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "superset", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a potentially greater #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_is_subset" gst_structure_is_subset :: Ptr Structure -> -- subset : TInterface (Name {namespace = "Gst", name = "Structure"}) Ptr Structure -> -- superset : TInterface (Name {namespace = "Gst", name = "Structure"}) IO CInt {- | Checks if /@subset@/ is a subset of /@superset@/, i.e. has the same structure name and for all fields that are existing in /@superset@/, /@subset@/ has a value that is a subset of the value in /@superset@/. -} structureIsSubset :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@subset@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Structure {- ^ /@superset@/: a potentially greater 'GI.Gst.Structs.Structure.Structure' -} -> m Bool {- ^ __Returns:__ 'True' if /@subset@/ is a subset of /@superset@/ -} structureIsSubset subset superset = liftIO $ do subset' <- unsafeManagedPtrGetPtr subset superset' <- unsafeManagedPtrGetPtr superset result <- gst_structure_is_subset subset' superset' let result' = (/= 0) result touchManagedPtr subset touchManagedPtr superset return result' #if ENABLE_OVERLOADING data StructureIsSubsetMethodInfo instance (signature ~ (Structure -> m Bool), MonadIO m) => O.MethodInfo StructureIsSubsetMethodInfo Structure signature where overloadedMethod _ = structureIsSubset #endif -- method Structure::map_in_place -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface (Name {namespace = "Gst", name = "StructureMapFunc"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a function to call for each field", sinceVersion = Nothing}, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "private data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_map_in_place" gst_structure_map_in_place :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) FunPtr Gst.Callbacks.C_StructureMapFunc -> -- func : TInterface (Name {namespace = "Gst", name = "StructureMapFunc"}) Ptr () -> -- user_data : TBasicType TPtr IO CInt {- | Calls the provided function once for each field in the 'GI.Gst.Structs.Structure.Structure'. In contrast to 'GI.Gst.Structs.Structure.structureForeach', the function may modify but not delete the fields. The structure must be mutable. -} structureMapInPlace :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Gst.Callbacks.StructureMapFunc {- ^ /@func@/: a function to call for each field -} -> m Bool {- ^ __Returns:__ 'True' if the supplied function returns 'True' For each of the fields, 'False' otherwise. -} structureMapInPlace structure func = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure func' <- Gst.Callbacks.mk_StructureMapFunc (Gst.Callbacks.wrap_StructureMapFunc Nothing (Gst.Callbacks.drop_closures_StructureMapFunc func)) let userData = nullPtr result <- gst_structure_map_in_place structure' func' userData let result' = (/= 0) result safeFreeFunPtr $ castFunPtrToPtr func' touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureMapInPlaceMethodInfo instance (signature ~ (Gst.Callbacks.StructureMapFunc -> m Bool), MonadIO m) => O.MethodInfo StructureMapInPlaceMethodInfo Structure signature where overloadedMethod _ = structureMapInPlace #endif -- method Structure::n_fields -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TInt) -- throws : False -- Skip return : False foreign import ccall "gst_structure_n_fields" gst_structure_n_fields :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO Int32 {- | Get the number of fields in the structure. -} structureNFields :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m Int32 {- ^ __Returns:__ the number of fields in the structure -} structureNFields structure = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_n_fields structure' touchManagedPtr structure return result #if ENABLE_OVERLOADING data StructureNFieldsMethodInfo instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo StructureNFieldsMethodInfo Structure signature where overloadedMethod _ = structureNFields #endif -- method Structure::nth_field_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index to get the name of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_structure_nth_field_name" gst_structure_nth_field_name :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) Word32 -> -- index : TBasicType TUInt IO CString {- | Get the name of the given field number, counting from 0 onwards. -} structureNthFieldName :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Word32 {- ^ /@index@/: the index to get the name of -} -> m T.Text {- ^ __Returns:__ the name of the given field number -} structureNthFieldName structure index = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_nth_field_name structure' index checkUnexpectedReturnNULL "structureNthFieldName" result result' <- cstringToText result touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureNthFieldNameMethodInfo instance (signature ~ (Word32 -> m T.Text), MonadIO m) => O.MethodInfo StructureNthFieldNameMethodInfo Structure signature where overloadedMethod _ = structureNthFieldName #endif -- method Structure::remove_all_fields -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_remove_all_fields" gst_structure_remove_all_fields :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO () {- | Removes all fields in a GstStructure. -} structureRemoveAllFields :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m () structureRemoveAllFields structure = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure gst_structure_remove_all_fields structure' touchManagedPtr structure return () #if ENABLE_OVERLOADING data StructureRemoveAllFieldsMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureRemoveAllFieldsMethodInfo Structure signature where overloadedMethod _ = structureRemoveAllFields #endif -- method Structure::remove_field -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the field to remove", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_remove_field" gst_structure_remove_field :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 IO () {- | Removes the field with the given name. If the field with the given name does not exist, the structure is unchanged. -} structureRemoveField :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of the field to remove -} -> m () structureRemoveField structure fieldname = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname gst_structure_remove_field structure' fieldname' touchManagedPtr structure freeMem fieldname' return () #if ENABLE_OVERLOADING data StructureRemoveFieldMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo StructureRemoveFieldMethodInfo Structure signature where overloadedMethod _ = structureRemoveField #endif -- method Structure::set_array -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GValueArray", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_set_array" gst_structure_set_array :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr GObject.ValueArray.ValueArray -> -- array : TInterface (Name {namespace = "GObject", name = "ValueArray"}) IO () {- | This is useful in language bindings where unknown GValue types are not supported. This function will convert a /@array@/ to @/GST_TYPE_ARRAY/@ and set the field specified by /@fieldname@/. Be aware that this is slower then using @/GST_TYPE_ARRAY/@ in a 'GI.GObject.Structs.Value.Value' directly. Since 1.12 -} structureSetArray :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> GObject.ValueArray.ValueArray {- ^ /@array@/: a pointer to a 'GI.GObject.Structs.ValueArray.ValueArray' -} -> m () structureSetArray structure fieldname array = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname array' <- unsafeManagedPtrGetPtr array gst_structure_set_array structure' fieldname' array' touchManagedPtr structure touchManagedPtr array freeMem fieldname' return () #if ENABLE_OVERLOADING data StructureSetArrayMethodInfo instance (signature ~ (T.Text -> GObject.ValueArray.ValueArray -> m ()), MonadIO m) => O.MethodInfo StructureSetArrayMethodInfo Structure signature where overloadedMethod _ = structureSetArray #endif -- method Structure::set_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of a field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "array", argType = TInterface (Name {namespace = "GObject", name = "ValueArray"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to a #GValueArray", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_set_list" gst_structure_set_list :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr GObject.ValueArray.ValueArray -> -- array : TInterface (Name {namespace = "GObject", name = "ValueArray"}) IO () {- | This is useful in language bindings where unknown GValue types are not supported. This function will convert a /@array@/ to @/GST_TYPE_LIST/@ and set the field specified by /@fieldname@/. Be aware that this is slower then using @/GST_TYPE_LIST/@ in a 'GI.GObject.Structs.Value.Value' directly. Since 1.12 -} structureSetList :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of a field -} -> GObject.ValueArray.ValueArray {- ^ /@array@/: a pointer to a 'GI.GObject.Structs.ValueArray.ValueArray' -} -> m () structureSetList structure fieldname array = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname array' <- unsafeManagedPtrGetPtr array gst_structure_set_list structure' fieldname' array' touchManagedPtr structure touchManagedPtr array freeMem fieldname' return () #if ENABLE_OVERLOADING data StructureSetListMethodInfo instance (signature ~ (T.Text -> GObject.ValueArray.ValueArray -> m ()), MonadIO m) => O.MethodInfo StructureSetListMethodInfo Structure signature where overloadedMethod _ = structureSetList #endif -- method Structure::set_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new name of the structure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_set_name" gst_structure_set_name :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- name : TBasicType TUTF8 IO () {- | Sets the name of the structure to the given /@name@/. The string provided is copied before being used. It must not be empty, start with a letter and can be followed by letters, numbers and any of \"\/-_.:\". -} structureSetName :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@name@/: the new name of the structure -} -> m () structureSetName structure name = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure name' <- textToCString name gst_structure_set_name structure' name' touchManagedPtr structure freeMem name' return () #if ENABLE_OVERLOADING data StructureSetNameMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo StructureSetNameMethodInfo Structure signature where overloadedMethod _ = structureSetName #endif -- method Structure::set_parent_refcount -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refcount", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to the parent's refcount", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "gst_structure_set_parent_refcount" gst_structure_set_parent_refcount :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) Int32 -> -- refcount : TBasicType TInt IO CInt {- | Sets the parent_refcount field of 'GI.Gst.Structs.Structure.Structure'. This field is used to determine whether a structure is mutable or not. This function should only be called by code implementing parent objects of 'GI.Gst.Structs.Structure.Structure', as described in the MT Refcounting section of the design documents. -} structureSetParentRefcount :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> Int32 {- ^ /@refcount@/: a pointer to the parent\'s refcount -} -> m Bool {- ^ __Returns:__ 'True' if the parent refcount could be set. -} structureSetParentRefcount structure refcount = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_set_parent_refcount structure' refcount let result' = (/= 0) result touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureSetParentRefcountMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m) => O.MethodInfo StructureSetParentRefcountMethodInfo Structure signature where overloadedMethod _ = structureSetParentRefcount #endif -- method Structure::set_value -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the field to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value of the field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_set_value" gst_structure_set_value :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr GValue -> -- value : TInterface (Name {namespace = "GObject", name = "Value"}) IO () {- | Sets the field with the given name /@field@/ to /@value@/. If the field does not exist, it is created. If the field exists, the previous value is replaced and freed. -} structureSetValue :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of the field to set -} -> GValue {- ^ /@value@/: the new value of the field -} -> m () structureSetValue structure fieldname value = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value' <- unsafeManagedPtrGetPtr value gst_structure_set_value structure' fieldname' value' touchManagedPtr structure touchManagedPtr value freeMem fieldname' return () #if ENABLE_OVERLOADING data StructureSetValueMethodInfo instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureSetValueMethodInfo Structure signature where overloadedMethod _ = structureSetValue #endif -- method Structure::take_value -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name of the field to set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new value of the field", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "gst_structure_take_value" gst_structure_take_value :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) CString -> -- fieldname : TBasicType TUTF8 Ptr GValue -> -- value : TInterface (Name {namespace = "GObject", name = "Value"}) IO () {- | Sets the field with the given name /@field@/ to /@value@/. If the field does not exist, it is created. If the field exists, the previous value is replaced and freed. The function will take ownership of /@value@/. -} structureTakeValue :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> T.Text {- ^ /@fieldname@/: the name of the field to set -} -> GValue {- ^ /@value@/: the new value of the field -} -> m () structureTakeValue structure fieldname value = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure fieldname' <- textToCString fieldname value' <- B.ManagedPtr.disownBoxed value gst_structure_take_value structure' fieldname' value' touchManagedPtr structure touchManagedPtr value freeMem fieldname' return () #if ENABLE_OVERLOADING data StructureTakeValueMethodInfo instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureTakeValueMethodInfo Structure signature where overloadedMethod _ = structureTakeValue #endif -- method Structure::to_string -- method type : OrdinaryMethod -- Args : [Arg {argCName = "structure", argType = TInterface (Name {namespace = "Gst", name = "Structure"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstStructure", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "gst_structure_to_string" gst_structure_to_string :: Ptr Structure -> -- structure : TInterface (Name {namespace = "Gst", name = "Structure"}) IO CString {- | Converts /@structure@/ to a human-readable string representation. For debugging purposes its easier to do something like this: === /C code/ > >GST_LOG ("structure is %" GST_PTR_FORMAT, structure); This prints the structure in human readable form. The current implementation of serialization will lead to unexpected results when there are nested 'GI.Gst.Structs.Caps.Caps' \/ 'GI.Gst.Structs.Structure.Structure' deeper than one level. Free-function: g_free -} structureToString :: (B.CallStack.HasCallStack, MonadIO m) => Structure {- ^ /@structure@/: a 'GI.Gst.Structs.Structure.Structure' -} -> m T.Text {- ^ __Returns:__ a pointer to string allocated by 'GI.GLib.Functions.malloc'. 'GI.GLib.Functions.free' after usage. -} structureToString structure = liftIO $ do structure' <- unsafeManagedPtrGetPtr structure result <- gst_structure_to_string structure' checkUnexpectedReturnNULL "structureToString" result result' <- cstringToText result freeMem result touchManagedPtr structure return result' #if ENABLE_OVERLOADING data StructureToStringMethodInfo instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo StructureToStringMethodInfo Structure signature where overloadedMethod _ = structureToString #endif -- method Structure::from_string -- method type : MemberFunction -- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string representation of a #GstStructure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "pointer to store the end of the string in.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"})) -- throws : False -- Skip return : False foreign import ccall "gst_structure_from_string" gst_structure_from_string :: CString -> -- string : TBasicType TUTF8 Ptr CString -> -- end : TBasicType TUTF8 IO (Ptr Structure) {- | Creates a 'GI.Gst.Structs.Structure.Structure' from a string representation. If end is not 'Nothing', a pointer to the place inside the given string where parsing ended will be returned. Free-function: gst_structure_free -} structureFromString :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@string@/: a string representation of a 'GI.Gst.Structs.Structure.Structure'. -} -> m ((Maybe Structure, T.Text)) {- ^ __Returns:__ a new 'GI.Gst.Structs.Structure.Structure' or 'Nothing' when the string could not be parsed. Free with 'GI.Gst.Structs.Structure.structureFree' after use. -} structureFromString string = liftIO $ do string' <- textToCString string end <- allocMem :: IO (Ptr CString) result <- gst_structure_from_string string' end maybeResult <- convertIfNonNull result $ \result' -> do result'' <- (wrapBoxed Structure) result' return result'' end' <- peek end end'' <- cstringToText end' freeMem string' freeMem end return (maybeResult, end'') #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING type family ResolveStructureMethod (t :: Symbol) (o :: *) :: * where ResolveStructureMethod "canIntersect" o = StructureCanIntersectMethodInfo ResolveStructureMethod "copy" o = StructureCopyMethodInfo ResolveStructureMethod "filterAndMapInPlace" o = StructureFilterAndMapInPlaceMethodInfo ResolveStructureMethod "fixate" o = StructureFixateMethodInfo ResolveStructureMethod "fixateField" o = StructureFixateFieldMethodInfo ResolveStructureMethod "fixateFieldBoolean" o = StructureFixateFieldBooleanMethodInfo ResolveStructureMethod "fixateFieldNearestDouble" o = StructureFixateFieldNearestDoubleMethodInfo ResolveStructureMethod "fixateFieldNearestFraction" o = StructureFixateFieldNearestFractionMethodInfo ResolveStructureMethod "fixateFieldNearestInt" o = StructureFixateFieldNearestIntMethodInfo ResolveStructureMethod "fixateFieldString" o = StructureFixateFieldStringMethodInfo ResolveStructureMethod "foreach" o = StructureForeachMethodInfo ResolveStructureMethod "free" o = StructureFreeMethodInfo ResolveStructureMethod "hasField" o = StructureHasFieldMethodInfo ResolveStructureMethod "hasFieldTyped" o = StructureHasFieldTypedMethodInfo ResolveStructureMethod "hasName" o = StructureHasNameMethodInfo ResolveStructureMethod "idGetValue" o = StructureIdGetValueMethodInfo ResolveStructureMethod "idHasField" o = StructureIdHasFieldMethodInfo ResolveStructureMethod "idHasFieldTyped" o = StructureIdHasFieldTypedMethodInfo ResolveStructureMethod "idSetValue" o = StructureIdSetValueMethodInfo ResolveStructureMethod "idTakeValue" o = StructureIdTakeValueMethodInfo ResolveStructureMethod "intersect" o = StructureIntersectMethodInfo ResolveStructureMethod "isEqual" o = StructureIsEqualMethodInfo ResolveStructureMethod "isSubset" o = StructureIsSubsetMethodInfo ResolveStructureMethod "mapInPlace" o = StructureMapInPlaceMethodInfo ResolveStructureMethod "nFields" o = StructureNFieldsMethodInfo ResolveStructureMethod "nthFieldName" o = StructureNthFieldNameMethodInfo ResolveStructureMethod "removeAllFields" o = StructureRemoveAllFieldsMethodInfo ResolveStructureMethod "removeField" o = StructureRemoveFieldMethodInfo ResolveStructureMethod "takeValue" o = StructureTakeValueMethodInfo ResolveStructureMethod "toString" o = StructureToStringMethodInfo ResolveStructureMethod "getArray" o = StructureGetArrayMethodInfo ResolveStructureMethod "getBoolean" o = StructureGetBooleanMethodInfo ResolveStructureMethod "getClockTime" o = StructureGetClockTimeMethodInfo ResolveStructureMethod "getDate" o = StructureGetDateMethodInfo ResolveStructureMethod "getDateTime" o = StructureGetDateTimeMethodInfo ResolveStructureMethod "getDouble" o = StructureGetDoubleMethodInfo ResolveStructureMethod "getEnum" o = StructureGetEnumMethodInfo ResolveStructureMethod "getFieldType" o = StructureGetFieldTypeMethodInfo ResolveStructureMethod "getFlagset" o = StructureGetFlagsetMethodInfo ResolveStructureMethod "getFraction" o = StructureGetFractionMethodInfo ResolveStructureMethod "getInt" o = StructureGetIntMethodInfo ResolveStructureMethod "getInt64" o = StructureGetInt64MethodInfo ResolveStructureMethod "getList" o = StructureGetListMethodInfo ResolveStructureMethod "getName" o = StructureGetNameMethodInfo ResolveStructureMethod "getNameId" o = StructureGetNameIdMethodInfo ResolveStructureMethod "getString" o = StructureGetStringMethodInfo ResolveStructureMethod "getUint" o = StructureGetUintMethodInfo ResolveStructureMethod "getUint64" o = StructureGetUint64MethodInfo ResolveStructureMethod "getValue" o = StructureGetValueMethodInfo ResolveStructureMethod "setArray" o = StructureSetArrayMethodInfo ResolveStructureMethod "setList" o = StructureSetListMethodInfo ResolveStructureMethod "setName" o = StructureSetNameMethodInfo ResolveStructureMethod "setParentRefcount" o = StructureSetParentRefcountMethodInfo ResolveStructureMethod "setValue" o = StructureSetValueMethodInfo ResolveStructureMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveStructureMethod t Structure, O.MethodInfo info Structure p) => OL.IsLabel t (Structure -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif