{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) 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. -} module GI.Gst.Structs.Structure ( -- * Exported types Structure(..) , newZeroStructure , noStructure , -- * Methods -- ** canIntersect #method:canIntersect# StructureCanIntersectMethodInfo , structureCanIntersect , -- ** copy #method:copy# StructureCopyMethodInfo , structureCopy , -- ** filterAndMapInPlace #method:filterAndMapInPlace# StructureFilterAndMapInPlaceMethodInfo , structureFilterAndMapInPlace , -- ** fixate #method:fixate# StructureFixateMethodInfo , structureFixate , -- ** fixateField #method:fixateField# StructureFixateFieldMethodInfo , structureFixateField , -- ** fixateFieldBoolean #method:fixateFieldBoolean# StructureFixateFieldBooleanMethodInfo , structureFixateFieldBoolean , -- ** fixateFieldNearestDouble #method:fixateFieldNearestDouble# StructureFixateFieldNearestDoubleMethodInfo, structureFixateFieldNearestDouble , -- ** fixateFieldNearestFraction #method:fixateFieldNearestFraction# StructureFixateFieldNearestFractionMethodInfo, structureFixateFieldNearestFraction , -- ** fixateFieldNearestInt #method:fixateFieldNearestInt# StructureFixateFieldNearestIntMethodInfo, structureFixateFieldNearestInt , -- ** fixateFieldString #method:fixateFieldString# StructureFixateFieldStringMethodInfo , structureFixateFieldString , -- ** foreach #method:foreach# StructureForeachMethodInfo , structureForeach , -- ** free #method:free# StructureFreeMethodInfo , structureFree , -- ** fromString #method:fromString# structureFromString , -- ** getBoolean #method:getBoolean# StructureGetBooleanMethodInfo , structureGetBoolean , -- ** getClockTime #method:getClockTime# StructureGetClockTimeMethodInfo , structureGetClockTime , -- ** getDate #method:getDate# StructureGetDateMethodInfo , structureGetDate , -- ** getDateTime #method:getDateTime# StructureGetDateTimeMethodInfo , structureGetDateTime , -- ** getDouble #method:getDouble# StructureGetDoubleMethodInfo , structureGetDouble , -- ** getEnum #method:getEnum# StructureGetEnumMethodInfo , structureGetEnum , -- ** getFieldType #method:getFieldType# StructureGetFieldTypeMethodInfo , structureGetFieldType , -- ** getFlagset #method:getFlagset# StructureGetFlagsetMethodInfo , structureGetFlagset , -- ** getFraction #method:getFraction# StructureGetFractionMethodInfo , structureGetFraction , -- ** getInt #method:getInt# StructureGetIntMethodInfo , structureGetInt , -- ** getInt64 #method:getInt64# StructureGetInt64MethodInfo , structureGetInt64 , -- ** getName #method:getName# StructureGetNameMethodInfo , structureGetName , -- ** getNameId #method:getNameId# StructureGetNameIdMethodInfo , structureGetNameId , -- ** getString #method:getString# StructureGetStringMethodInfo , structureGetString , -- ** getUint #method:getUint# StructureGetUintMethodInfo , structureGetUint , -- ** getUint64 #method:getUint64# StructureGetUint64MethodInfo , structureGetUint64 , -- ** getValue #method:getValue# StructureGetValueMethodInfo , structureGetValue , -- ** hasField #method:hasField# StructureHasFieldMethodInfo , structureHasField , -- ** hasFieldTyped #method:hasFieldTyped# StructureHasFieldTypedMethodInfo , structureHasFieldTyped , -- ** hasName #method:hasName# StructureHasNameMethodInfo , structureHasName , -- ** idGetValue #method:idGetValue# StructureIdGetValueMethodInfo , structureIdGetValue , -- ** idHasField #method:idHasField# StructureIdHasFieldMethodInfo , structureIdHasField , -- ** idHasFieldTyped #method:idHasFieldTyped# StructureIdHasFieldTypedMethodInfo , structureIdHasFieldTyped , -- ** idSetValue #method:idSetValue# StructureIdSetValueMethodInfo , structureIdSetValue , -- ** idTakeValue #method:idTakeValue# StructureIdTakeValueMethodInfo , structureIdTakeValue , -- ** intersect #method:intersect# StructureIntersectMethodInfo , structureIntersect , -- ** isEqual #method:isEqual# StructureIsEqualMethodInfo , structureIsEqual , -- ** isSubset #method:isSubset# StructureIsSubsetMethodInfo , structureIsSubset , -- ** mapInPlace #method:mapInPlace# StructureMapInPlaceMethodInfo , structureMapInPlace , -- ** nFields #method:nFields# StructureNFieldsMethodInfo , structureNFields , -- ** newEmpty #method:newEmpty# structureNewEmpty , -- ** newFromString #method:newFromString# structureNewFromString , -- ** newIdEmpty #method:newIdEmpty# structureNewIdEmpty , -- ** nthFieldName #method:nthFieldName# StructureNthFieldNameMethodInfo , structureNthFieldName , -- ** removeAllFields #method:removeAllFields# StructureRemoveAllFieldsMethodInfo , structureRemoveAllFields , -- ** removeField #method:removeField# StructureRemoveFieldMethodInfo , structureRemoveField , -- ** setName #method:setName# StructureSetNameMethodInfo , structureSetName , -- ** setParentRefcount #method:setParentRefcount# StructureSetParentRefcountMethodInfo , structureSetParentRefcount , -- ** setValue #method:setValue# StructureSetValueMethodInfo , structureSetValue , -- ** takeValue #method:takeValue# StructureTakeValueMethodInfo , structureTakeValue , -- ** toString #method:toString# StructureToStringMethodInfo , structureToString , -- * Properties -- ** type #attr:type# getStructureType , setStructureType , structure_type , ) 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.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack 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 GI.GLib.Structs.Date as GLib.Date import qualified GI.Gst.Callbacks as Gst.Callbacks import {-# SOURCE #-} qualified GI.Gst.Structs.DateTime as Gst.DateTime 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 noStructure :: Maybe Structure noStructure = Nothing 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' setStructureType :: MonadIO m => Structure -> GType -> m () setStructureType s val = liftIO $ withManagedPtr s $ \ptr -> do let val' = gtypeToCGType val poke (ptr `plusPtr` 0) (val' :: CGType) 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 instance O.HasAttributeList Structure type instance O.AttributeList Structure = StructureAttributeList type StructureAttributeList = ('[ '("type", StructureTypeFieldInfo)] :: [(Symbol, *)]) -- 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' -- 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 -- 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' -- 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' data StructureCanIntersectMethodInfo instance (signature ~ (Structure -> m Bool), MonadIO m) => O.MethodInfo StructureCanIntersectMethodInfo Structure signature where overloadedMethod _ = structureCanIntersect -- 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' data StructureCopyMethodInfo instance (signature ~ (m Structure), MonadIO m) => O.MethodInfo StructureCopyMethodInfo Structure signature where overloadedMethod _ = structureCopy -- 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 () data StructureFilterAndMapInPlaceMethodInfo instance (signature ~ (Gst.Callbacks.StructureFilterMapFunc -> m ()), MonadIO m) => O.MethodInfo StructureFilterAndMapInPlaceMethodInfo Structure signature where overloadedMethod _ = structureFilterAndMapInPlace -- 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 () data StructureFixateMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureFixateMethodInfo Structure signature where overloadedMethod _ = structureFixate -- 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' data StructureFixateFieldMethodInfo instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldMethodInfo Structure signature where overloadedMethod _ = structureFixateField -- 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' data StructureFixateFieldBooleanMethodInfo instance (signature ~ (T.Text -> Bool -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldBooleanMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldBoolean -- 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' data StructureFixateFieldNearestDoubleMethodInfo instance (signature ~ (T.Text -> Double -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldNearestDoubleMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldNearestDouble -- 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' data StructureFixateFieldNearestFractionMethodInfo instance (signature ~ (T.Text -> Int32 -> Int32 -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldNearestFractionMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldNearestFraction -- 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' data StructureFixateFieldNearestIntMethodInfo instance (signature ~ (T.Text -> Int32 -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldNearestIntMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldNearestInt -- 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' data StructureFixateFieldStringMethodInfo instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureFixateFieldStringMethodInfo Structure signature where overloadedMethod _ = structureFixateFieldString -- 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' data StructureForeachMethodInfo instance (signature ~ (Gst.Callbacks.StructureForeachFunc -> m Bool), MonadIO m) => O.MethodInfo StructureForeachMethodInfo Structure signature where overloadedMethod _ = structureForeach -- 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 () data StructureFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureFreeMethodInfo Structure signature where overloadedMethod _ = structureFree -- 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'') data StructureGetBooleanMethodInfo instance (signature ~ (T.Text -> m (Bool,Bool)), MonadIO m) => O.MethodInfo StructureGetBooleanMethodInfo Structure signature where overloadedMethod _ = structureGetBoolean -- 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') data StructureGetClockTimeMethodInfo instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => O.MethodInfo StructureGetClockTimeMethodInfo Structure signature where overloadedMethod _ = structureGetClockTime -- 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'') data StructureGetDateMethodInfo instance (signature ~ (T.Text -> m (Bool,GLib.Date.Date)), MonadIO m) => O.MethodInfo StructureGetDateMethodInfo Structure signature where overloadedMethod _ = structureGetDate -- 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'') data StructureGetDateTimeMethodInfo instance (signature ~ (T.Text -> m (Bool,Gst.DateTime.DateTime)), MonadIO m) => O.MethodInfo StructureGetDateTimeMethodInfo Structure signature where overloadedMethod _ = structureGetDateTime -- 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'') data StructureGetDoubleMethodInfo instance (signature ~ (T.Text -> m (Bool,Double)), MonadIO m) => O.MethodInfo StructureGetDoubleMethodInfo Structure signature where overloadedMethod _ = structureGetDouble -- 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') data StructureGetEnumMethodInfo instance (signature ~ (T.Text -> GType -> m (Bool,Int32)), MonadIO m) => O.MethodInfo StructureGetEnumMethodInfo Structure signature where overloadedMethod _ = structureGetEnum -- 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' data StructureGetFieldTypeMethodInfo instance (signature ~ (T.Text -> m GType), MonadIO m) => O.MethodInfo StructureGetFieldTypeMethodInfo Structure signature where overloadedMethod _ = structureGetFieldType -- 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') data StructureGetFlagsetMethodInfo instance (signature ~ (T.Text -> m (Bool,Word32,Word32)), MonadIO m) => O.MethodInfo StructureGetFlagsetMethodInfo Structure signature where overloadedMethod _ = structureGetFlagset -- 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') data StructureGetFractionMethodInfo instance (signature ~ (T.Text -> m (Bool,Int32,Int32)), MonadIO m) => O.MethodInfo StructureGetFractionMethodInfo Structure signature where overloadedMethod _ = structureGetFraction -- 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') data StructureGetIntMethodInfo instance (signature ~ (T.Text -> m (Bool,Int32)), MonadIO m) => O.MethodInfo StructureGetIntMethodInfo Structure signature where overloadedMethod _ = structureGetInt -- 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') data StructureGetInt64MethodInfo instance (signature ~ (T.Text -> m (Bool,Int64)), MonadIO m) => O.MethodInfo StructureGetInt64MethodInfo Structure signature where overloadedMethod _ = structureGetInt64 -- 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' data StructureGetNameMethodInfo instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo StructureGetNameMethodInfo Structure signature where overloadedMethod _ = structureGetName -- 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 data StructureGetNameIdMethodInfo instance (signature ~ (m Word32), MonadIO m) => O.MethodInfo StructureGetNameIdMethodInfo Structure signature where overloadedMethod _ = structureGetNameId -- 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 data StructureGetStringMethodInfo instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo StructureGetStringMethodInfo Structure signature where overloadedMethod _ = structureGetString -- 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') data StructureGetUintMethodInfo instance (signature ~ (T.Text -> m (Bool,Word32)), MonadIO m) => O.MethodInfo StructureGetUintMethodInfo Structure signature where overloadedMethod _ = structureGetUint -- 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') data StructureGetUint64MethodInfo instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => O.MethodInfo StructureGetUint64MethodInfo Structure signature where overloadedMethod _ = structureGetUint64 -- 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 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' checkUnexpectedReturnNULL "structureGetValue" result result' <- (newBoxed GValue) result touchManagedPtr structure freeMem fieldname' return result' data StructureGetValueMethodInfo instance (signature ~ (T.Text -> m GValue), MonadIO m) => O.MethodInfo StructureGetValueMethodInfo Structure signature where overloadedMethod _ = structureGetValue -- 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' data StructureHasFieldMethodInfo instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureHasFieldMethodInfo Structure signature where overloadedMethod _ = structureHasField -- 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' data StructureHasFieldTypedMethodInfo instance (signature ~ (T.Text -> GType -> m Bool), MonadIO m) => O.MethodInfo StructureHasFieldTypedMethodInfo Structure signature where overloadedMethod _ = structureHasFieldTyped -- 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' data StructureHasNameMethodInfo instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.MethodInfo StructureHasNameMethodInfo Structure signature where overloadedMethod _ = structureHasName -- 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 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 checkUnexpectedReturnNULL "structureIdGetValue" result result' <- (newBoxed GValue) result touchManagedPtr structure return result' data StructureIdGetValueMethodInfo instance (signature ~ (Word32 -> m GValue), MonadIO m) => O.MethodInfo StructureIdGetValueMethodInfo Structure signature where overloadedMethod _ = structureIdGetValue -- 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' data StructureIdHasFieldMethodInfo instance (signature ~ (Word32 -> m Bool), MonadIO m) => O.MethodInfo StructureIdHasFieldMethodInfo Structure signature where overloadedMethod _ = structureIdHasField -- 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' data StructureIdHasFieldTypedMethodInfo instance (signature ~ (Word32 -> GType -> m Bool), MonadIO m) => O.MethodInfo StructureIdHasFieldTypedMethodInfo Structure signature where overloadedMethod _ = structureIdHasFieldTyped -- 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 () data StructureIdSetValueMethodInfo instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureIdSetValueMethodInfo Structure signature where overloadedMethod _ = structureIdSetValue -- 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 () data StructureIdTakeValueMethodInfo instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureIdTakeValueMethodInfo Structure signature where overloadedMethod _ = structureIdTakeValue -- 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 Structure {- ^ __Returns:__ Intersection of /@struct1@/ and /@struct2@/ -} structureIntersect struct1 struct2 = liftIO $ do struct1' <- unsafeManagedPtrGetPtr struct1 struct2' <- unsafeManagedPtrGetPtr struct2 result <- gst_structure_intersect struct1' struct2' checkUnexpectedReturnNULL "structureIntersect" result result' <- (wrapBoxed Structure) result touchManagedPtr struct1 touchManagedPtr struct2 return result' data StructureIntersectMethodInfo instance (signature ~ (Structure -> m Structure), MonadIO m) => O.MethodInfo StructureIntersectMethodInfo Structure signature where overloadedMethod _ = structureIntersect -- 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' data StructureIsEqualMethodInfo instance (signature ~ (Structure -> m Bool), MonadIO m) => O.MethodInfo StructureIsEqualMethodInfo Structure signature where overloadedMethod _ = structureIsEqual -- 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' data StructureIsSubsetMethodInfo instance (signature ~ (Structure -> m Bool), MonadIO m) => O.MethodInfo StructureIsSubsetMethodInfo Structure signature where overloadedMethod _ = structureIsSubset -- 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' data StructureMapInPlaceMethodInfo instance (signature ~ (Gst.Callbacks.StructureMapFunc -> m Bool), MonadIO m) => O.MethodInfo StructureMapInPlaceMethodInfo Structure signature where overloadedMethod _ = structureMapInPlace -- 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 data StructureNFieldsMethodInfo instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo StructureNFieldsMethodInfo Structure signature where overloadedMethod _ = structureNFields -- 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' data StructureNthFieldNameMethodInfo instance (signature ~ (Word32 -> m T.Text), MonadIO m) => O.MethodInfo StructureNthFieldNameMethodInfo Structure signature where overloadedMethod _ = structureNthFieldName -- 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 () data StructureRemoveAllFieldsMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo StructureRemoveAllFieldsMethodInfo Structure signature where overloadedMethod _ = structureRemoveAllFields -- 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 () data StructureRemoveFieldMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo StructureRemoveFieldMethodInfo Structure signature where overloadedMethod _ = structureRemoveField -- 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 () data StructureSetNameMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo StructureSetNameMethodInfo Structure signature where overloadedMethod _ = structureSetName -- 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' data StructureSetParentRefcountMethodInfo instance (signature ~ (Int32 -> m Bool), MonadIO m) => O.MethodInfo StructureSetParentRefcountMethodInfo Structure signature where overloadedMethod _ = structureSetParentRefcount -- 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 () data StructureSetValueMethodInfo instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureSetValueMethodInfo Structure signature where overloadedMethod _ = structureSetValue -- 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 () data StructureTakeValueMethodInfo instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => O.MethodInfo StructureTakeValueMethodInfo Structure signature where overloadedMethod _ = structureTakeValue -- 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' data StructureToStringMethodInfo instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo StructureToStringMethodInfo Structure signature where overloadedMethod _ = structureToString -- 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'') 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 "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 "getName" o = StructureGetNameMethodInfo ResolveStructureMethod "getNameId" o = StructureGetNameIdMethodInfo ResolveStructureMethod "getString" o = StructureGetStringMethodInfo ResolveStructureMethod "getUint" o = StructureGetUintMethodInfo ResolveStructureMethod "getUint64" o = StructureGetUint64MethodInfo ResolveStructureMethod "getValue" o = StructureGetValueMethodInfo 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) => O.IsLabelProxy t (Structure -> p) where fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #if MIN_VERSION_base(4,9,0) instance (info ~ ResolveStructureMethod t Structure, O.MethodInfo info Structure p) => O.IsLabel t (Structure -> p) where fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif