GI.GES.Callbacks

Signals

BaseEffectTimeTranslationFunc

type BaseEffectTimeTranslationFunc

Arguments

 = BaseEffect

effect: The BaseEffect that is doing the time translation

-> Word64

time: The GstClockTime to translation

-> Map Text GValue

timePropertyValues: A table of child property name/value pairs

-> IO Word64

Returns: The translated time.

A function for querying how an effect would translate a time if it had the given child property values set. The keys for timeProperties will be the same string that was passed to baseEffectRegisterTimeProperty, the values will be Value* values of the corresponding child properties. You should always use the values given in timeProperties before using the currently set values.

Since: 1.18

type BaseEffectTimeTranslationFunc_WithClosures

Arguments

 = BaseEffect

effect: The BaseEffect that is doing the time translation

-> Word64

time: The GstClockTime to translation

-> Map Text GValue

timePropertyValues: A table of child property name/value pairs

-> Ptr ()

userData: Data passed to baseEffectSetTimeTranslationFuncs

-> IO Word64

Returns: The translated time.

A function for querying how an effect would translate a time if it had the given child property values set. The keys for timeProperties will be the same string that was passed to baseEffectRegisterTimeProperty, the values will be Value* values of the corresponding child properties. You should always use the values given in timeProperties before using the currently set values.

Since: 1.18

type C_BaseEffectTimeTranslationFunc = Ptr BaseEffect -> Word64 -> Ptr (GHashTable CString (Ptr GValue)) -> Ptr () -> IO Word64

Type for the callback on the (unwrapped) C side.

drop_closures_BaseEffectTimeTranslationFunc :: BaseEffectTimeTranslationFunc -> BaseEffectTimeTranslationFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_BaseEffectTimeTranslationFunc

Arguments

:: (HasCallStack, MonadIO m, IsBaseEffect a)

=> FunPtr C_BaseEffectTimeTranslationFunc

-> a

effect: The BaseEffect that is doing the time translation

-> Word64

time: The GstClockTime to translation

-> Map Text GValue

timePropertyValues: A table of child property name/value pairs

-> Ptr ()

userData: Data passed to baseEffectSetTimeTranslationFuncs

-> m Word64

Returns: The translated time.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_BaseEffectTimeTranslationFunc :: MonadIO m => BaseEffectTimeTranslationFunc -> m (GClosure C_BaseEffectTimeTranslationFunc)

Wrap the callback into a GClosure.

mk_BaseEffectTimeTranslationFunc :: C_BaseEffectTimeTranslationFunc -> IO (FunPtr C_BaseEffectTimeTranslationFunc)

Generate a function pointer callable from C code, from a C_BaseEffectTimeTranslationFunc.

noBaseEffectTimeTranslationFunc :: Maybe BaseEffectTimeTranslationFunc

A convenience synonym for Nothing :: Maybe BaseEffectTimeTranslationFunc.

noBaseEffectTimeTranslationFunc_WithClosures :: Maybe BaseEffectTimeTranslationFunc_WithClosures

A convenience synonym for Nothing :: Maybe BaseEffectTimeTranslationFunc_WithClosures.

wrap_BaseEffectTimeTranslationFunc :: Maybe (Ptr (FunPtr C_BaseEffectTimeTranslationFunc)) -> BaseEffectTimeTranslationFunc_WithClosures -> C_BaseEffectTimeTranslationFunc

Wrap a BaseEffectTimeTranslationFunc into a C_BaseEffectTimeTranslationFunc.

CreateTrackElementFunc

type C_CreateTrackElementFunc = Ptr Clip -> CUInt -> IO (Ptr TrackElement)

Type for the callback on the (unwrapped) C side.

type CreateTrackElementFunc

Arguments

 = Clip

clip: A Clip

-> [TrackType]

type: A TrackType to create a TrackElement for

-> IO (Maybe TrackElement)

Returns: The TrackElement created by clip, or Nothing if clip can not provide a track element for the given type or an error occurred.

A method for creating the core TrackElement of a clip, to be added to a Track of the given track type.

If a clip may produce several track elements per track type, CreateTrackElementsFunc is more appropriate.

dynamic_CreateTrackElementFunc

Arguments

:: (HasCallStack, MonadIO m, IsClip a)

=> FunPtr C_CreateTrackElementFunc

-> a

clip: A Clip

-> [TrackType]

type: A TrackType to create a TrackElement for

-> m (Maybe TrackElement)

Returns: The TrackElement created by clip, or Nothing if clip can not provide a track element for the given type or an error occurred.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_CreateTrackElementFunc :: MonadIO m => CreateTrackElementFunc -> m (GClosure C_CreateTrackElementFunc)

Wrap the callback into a GClosure.

mk_CreateTrackElementFunc :: C_CreateTrackElementFunc -> IO (FunPtr C_CreateTrackElementFunc)

Generate a function pointer callable from C code, from a C_CreateTrackElementFunc.

noCreateTrackElementFunc :: Maybe CreateTrackElementFunc

A convenience synonym for Nothing :: Maybe CreateTrackElementFunc.

wrap_CreateTrackElementFunc :: Maybe (Ptr (FunPtr C_CreateTrackElementFunc)) -> CreateTrackElementFunc -> C_CreateTrackElementFunc

Wrap a CreateTrackElementFunc into a C_CreateTrackElementFunc.

CreateTrackElementsFunc

type C_CreateTrackElementsFunc = Ptr Clip -> CUInt -> IO (Ptr (GList (Ptr TrackElement)))

Type for the callback on the (unwrapped) C side.

type CreateTrackElementsFunc

Arguments

 = Clip

clip: A Clip

-> [TrackType]

type: A TrackType to create TrackElement-s for

-> IO [TrackElement]

Returns: A list of the TrackElement-s created by clip for the given type, or Nothing if no track elements are created or an error occurred.

A method for creating the core TrackElement-s of a clip, to be added to Track-s of the given track type.

dynamic_CreateTrackElementsFunc

Arguments

:: (HasCallStack, MonadIO m, IsClip a)

=> FunPtr C_CreateTrackElementsFunc

-> a

clip: A Clip

-> [TrackType]

type: A TrackType to create TrackElement-s for

-> m [TrackElement]

Returns: A list of the TrackElement-s created by clip for the given type, or Nothing if no track elements are created or an error occurred.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_CreateTrackElementsFunc :: MonadIO m => CreateTrackElementsFunc -> m (GClosure C_CreateTrackElementsFunc)

Wrap the callback into a GClosure.

mk_CreateTrackElementsFunc :: C_CreateTrackElementsFunc -> IO (FunPtr C_CreateTrackElementsFunc)

Generate a function pointer callable from C code, from a C_CreateTrackElementsFunc.

noCreateTrackElementsFunc :: Maybe CreateTrackElementsFunc

A convenience synonym for Nothing :: Maybe CreateTrackElementsFunc.

wrap_CreateTrackElementsFunc :: Maybe (Ptr (FunPtr C_CreateTrackElementsFunc)) -> CreateTrackElementsFunc -> C_CreateTrackElementsFunc

Wrap a CreateTrackElementsFunc into a C_CreateTrackElementsFunc.

ExtractableCheckId

type C_ExtractableCheckId = CGType -> CString -> Ptr (Ptr GError) -> IO CString

Type for the callback on the (unwrapped) C side.

type ExtractableCheckId

Arguments

 = GType

type: The Extractable type to check id for

-> Text

id: The ID to check

-> IO Text

(Can throw GError)

Method for checking that an ID is valid for the given Extractable type. If the given ID is considered valid, it can be adjusted into some standard and returned to prevent the creation of separate Asset-s, with different Asset:id, that would otherwise act the same.

Returns (transfer full) (nullable): The actual Asset:id to set on any corresponding assets, based on id, or Nothing if id is not valid.

dynamic_ExtractableCheckId

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_ExtractableCheckId

-> GType

type: The Extractable type to check id for

-> Text

id: The ID to check

-> m Text

(Can throw GError)

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

mk_ExtractableCheckId :: C_ExtractableCheckId -> IO (FunPtr C_ExtractableCheckId)

Generate a function pointer callable from C code, from a C_ExtractableCheckId.

noExtractableCheckId :: Maybe ExtractableCheckId

A convenience synonym for Nothing :: Maybe ExtractableCheckId.

FillTrackElementFunc

type C_FillTrackElementFunc = Ptr Clip -> Ptr TrackElement -> Ptr Element -> IO CInt

Type for the callback on the (unwrapped) C side.

type FillTrackElementFunc

Arguments

 = Clip

clip: The Clip controlling the track elements

-> TrackElement

trackElement: The TrackElement

-> Element

nleobj: The nleobject that needs to be filled

-> IO Bool

Returns: True if the implementer successfully filled the nleobj.

Deprecated: (Since version 1.18)This method type is no longer used.

A function that will be called when the nleobject of a corresponding track element needs to be filled.

The implementer of this function shall add the proper Element to nleobj using binAdd.

dynamic_FillTrackElementFunc

Arguments

:: (HasCallStack, MonadIO m, IsClip a, IsTrackElement b, IsElement c)

=> FunPtr C_FillTrackElementFunc

-> a

clip: The Clip controlling the track elements

-> b

trackElement: The TrackElement

-> c

nleobj: The nleobject that needs to be filled

-> m Bool

Returns: True if the implementer successfully filled the nleobj.

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_FillTrackElementFunc :: MonadIO m => FillTrackElementFunc -> m (GClosure C_FillTrackElementFunc)

Wrap the callback into a GClosure.

mk_FillTrackElementFunc :: C_FillTrackElementFunc -> IO (FunPtr C_FillTrackElementFunc)

Generate a function pointer callable from C code, from a C_FillTrackElementFunc.

noFillTrackElementFunc :: Maybe FillTrackElementFunc

A convenience synonym for Nothing :: Maybe FillTrackElementFunc.

wrap_FillTrackElementFunc :: Maybe (Ptr (FunPtr C_FillTrackElementFunc)) -> FillTrackElementFunc -> C_FillTrackElementFunc

Wrap a FillTrackElementFunc into a C_FillTrackElementFunc.

FormatterCanLoadURIMethod

type C_FormatterCanLoadURIMethod = Ptr Formatter -> CString -> Ptr (Ptr GError) -> IO CInt

Type for the callback on the (unwrapped) C side.

type FormatterCanLoadURIMethod

Arguments

 = Formatter

-> Text

-> IO ()

(Can throw GError)

No description available in the introspection data.

dynamic_FormatterCanLoadURIMethod

Arguments

:: (HasCallStack, MonadIO m, IsFormatter a)

=> FunPtr C_FormatterCanLoadURIMethod

-> a

-> Text

-> m ()

(Can throw GError)

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

mk_FormatterCanLoadURIMethod :: C_FormatterCanLoadURIMethod -> IO (FunPtr C_FormatterCanLoadURIMethod)

Generate a function pointer callable from C code, from a C_FormatterCanLoadURIMethod.

noFormatterCanLoadURIMethod :: Maybe FormatterCanLoadURIMethod

A convenience synonym for Nothing :: Maybe FormatterCanLoadURIMethod.

FormatterLoadFromURIMethod

type C_FormatterLoadFromURIMethod = Ptr Formatter -> Ptr Timeline -> CString -> Ptr (Ptr GError) -> IO CInt

Type for the callback on the (unwrapped) C side.

type FormatterLoadFromURIMethod

Arguments

 = Formatter

formatter: a Formatter

-> Timeline

timeline: a Timeline

-> Text

uri: a gchar * pointing to a URI

-> IO ()

Returns: TRUE if the timeline data was successfully loaded from the URI, else FALSE. (Can throw GError)

Virtual method for loading a timeline from a given URI.

Every Formatter subclass needs to implement this method.

dynamic_FormatterLoadFromURIMethod

Arguments

:: (HasCallStack, MonadIO m, IsFormatter a, IsTimeline b)

=> FunPtr C_FormatterLoadFromURIMethod

-> a

formatter: a Formatter

-> b

timeline: a Timeline

-> Text

uri: a gchar * pointing to a URI

-> m ()

(Can throw GError)

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

mk_FormatterLoadFromURIMethod :: C_FormatterLoadFromURIMethod -> IO (FunPtr C_FormatterLoadFromURIMethod)

Generate a function pointer callable from C code, from a C_FormatterLoadFromURIMethod.

noFormatterLoadFromURIMethod :: Maybe FormatterLoadFromURIMethod

A convenience synonym for Nothing :: Maybe FormatterLoadFromURIMethod.

FormatterSaveToURIMethod

type C_FormatterSaveToURIMethod = Ptr Formatter -> Ptr Timeline -> CString -> CInt -> Ptr (Ptr GError) -> IO CInt

Type for the callback on the (unwrapped) C side.

type FormatterSaveToURIMethod

Arguments

 = Formatter

formatter: a Formatter

-> Timeline

timeline: a Timeline

-> Text

uri: a gchar * pointing to a URI

-> Bool

overwrite: True to overwrite file if it exists

-> IO ()

Returns: TRUE if the timeline data was successfully saved to the URI else FALSE. (Can throw GError)

Virtual method for saving a timeline to a uri.

Every Formatter subclass needs to implement this method.

dynamic_FormatterSaveToURIMethod

Arguments

:: (HasCallStack, MonadIO m, IsFormatter a, IsTimeline b)

=> FunPtr C_FormatterSaveToURIMethod

-> a

formatter: a Formatter

-> b

timeline: a Timeline

-> Text

uri: a gchar * pointing to a URI

-> Bool

overwrite: True to overwrite file if it exists

-> m ()

(Can throw GError)

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

mk_FormatterSaveToURIMethod :: C_FormatterSaveToURIMethod -> IO (FunPtr C_FormatterSaveToURIMethod)

Generate a function pointer callable from C code, from a C_FormatterSaveToURIMethod.

noFormatterSaveToURIMethod :: Maybe FormatterSaveToURIMethod

A convenience synonym for Nothing :: Maybe FormatterSaveToURIMethod.

MetaForeachFunc

type C_MetaForeachFunc = Ptr MetaContainer -> CString -> Ptr GValue -> Ptr () -> IO ()

Type for the callback on the (unwrapped) C side.

type MetaForeachFunc

Arguments

 = MetaContainer

container: A MetaContainer

-> Text

key: The key for one of container's fields

-> GValue

value: The set value under key

-> IO ()

A method to be called on all of a meta container's fields.

type MetaForeachFunc_WithClosures

Arguments

 = MetaContainer

container: A MetaContainer

-> Text

key: The key for one of container's fields

-> GValue

value: The set value under key

-> Ptr ()

userData: User data

-> IO ()

A method to be called on all of a meta container's fields.

drop_closures_MetaForeachFunc :: MetaForeachFunc -> MetaForeachFunc_WithClosures

A simple wrapper that ignores the closure arguments.

dynamic_MetaForeachFunc

Arguments

:: (HasCallStack, MonadIO m, IsMetaContainer a)

=> FunPtr C_MetaForeachFunc

-> a

container: A MetaContainer

-> Text

key: The key for one of container's fields

-> GValue

value: The set value under key

-> Ptr ()

userData: User data

-> m ()

Given a pointer to a foreign C function, wrap it into a function callable from Haskell.

genClosure_MetaForeachFunc :: MonadIO m => MetaForeachFunc -> m (GClosure C_MetaForeachFunc)

Wrap the callback into a GClosure.

mk_MetaForeachFunc :: C_MetaForeachFunc -> IO (FunPtr C_MetaForeachFunc)

Generate a function pointer callable from C code, from a C_MetaForeachFunc.

noMetaForeachFunc :: Maybe MetaForeachFunc

A convenience synonym for Nothing :: Maybe MetaForeachFunc.

noMetaForeachFunc_WithClosures :: Maybe MetaForeachFunc_WithClosures

A convenience synonym for Nothing :: Maybe MetaForeachFunc_WithClosures.

wrap_MetaForeachFunc :: Maybe (Ptr (FunPtr C_MetaForeachFunc)) -> MetaForeachFunc_WithClosures -> C_MetaForeachFunc

Wrap a MetaForeachFunc into a C_MetaForeachFunc.