gi-gst 1.0.24 → 1.0.25

raw patch · 4 files changed

+11/−7 lines, 4 filesdep ~haskell-gidep ~haskell-gi-basesetup-changedPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-gi, haskell-gi-base

API changes (from Hackage documentation)

- GI.Gst.Interfaces.ChildProxy: genClosure_ChildProxyChildAdded :: MonadIO m => ChildProxyChildAddedCallback -> m (GClosure C_ChildProxyChildAddedCallback)

- GI.Gst.Interfaces.ChildProxy: genClosure_ChildProxyChildRemoved :: MonadIO m => ChildProxyChildRemovedCallback -> m (GClosure C_ChildProxyChildRemovedCallback)

- GI.Gst.Interfaces.ChildProxy: mk_ChildProxyChildAddedCallback :: C_ChildProxyChildAddedCallback -> IO (FunPtr C_ChildProxyChildAddedCallback)

- GI.Gst.Interfaces.ChildProxy: mk_ChildProxyChildRemovedCallback :: C_ChildProxyChildRemovedCallback -> IO (FunPtr C_ChildProxyChildRemovedCallback)

- GI.Gst.Interfaces.ChildProxy: noChildProxyChildAddedCallback :: Maybe ChildProxyChildAddedCallback

- GI.Gst.Interfaces.ChildProxy: noChildProxyChildRemovedCallback :: Maybe ChildProxyChildRemovedCallback

- GI.Gst.Interfaces.ChildProxy: type C_ChildProxyChildAddedCallback = Ptr () -> Ptr Object -> CString -> Ptr () -> IO ()

- GI.Gst.Interfaces.ChildProxy: type C_ChildProxyChildRemovedCallback = Ptr () -> Ptr Object -> CString -> Ptr () -> IO ()

- GI.Gst.Interfaces.ChildProxy: wrap_ChildProxyChildAddedCallback :: ChildProxyChildAddedCallback -> C_ChildProxyChildAddedCallback

- GI.Gst.Interfaces.ChildProxy: wrap_ChildProxyChildRemovedCallback :: ChildProxyChildRemovedCallback -> C_ChildProxyChildRemovedCallback

- GI.Gst.Objects.Bin: genClosure_BinDeepElementAdded :: MonadIO m => BinDeepElementAddedCallback -> m (GClosure C_BinDeepElementAddedCallback)

- GI.Gst.Objects.Bin: genClosure_BinDeepElementRemoved :: MonadIO m => BinDeepElementRemovedCallback -> m (GClosure C_BinDeepElementRemovedCallback)

- GI.Gst.Objects.Bin: genClosure_BinDoLatency :: MonadIO m => BinDoLatencyCallback -> m (GClosure C_BinDoLatencyCallback)

- GI.Gst.Objects.Bin: genClosure_BinElementAdded :: MonadIO m => BinElementAddedCallback -> m (GClosure C_BinElementAddedCallback)

- GI.Gst.Objects.Bin: genClosure_BinElementRemoved :: MonadIO m => BinElementRemovedCallback -> m (GClosure C_BinElementRemovedCallback)

- GI.Gst.Objects.Bin: mk_BinDeepElementAddedCallback :: C_BinDeepElementAddedCallback -> IO (FunPtr C_BinDeepElementAddedCallback)

- GI.Gst.Objects.Bin: mk_BinDeepElementRemovedCallback :: C_BinDeepElementRemovedCallback -> IO (FunPtr C_BinDeepElementRemovedCallback)

- GI.Gst.Objects.Bin: mk_BinDoLatencyCallback :: C_BinDoLatencyCallback -> IO (FunPtr C_BinDoLatencyCallback)

- GI.Gst.Objects.Bin: mk_BinElementAddedCallback :: C_BinElementAddedCallback -> IO (FunPtr C_BinElementAddedCallback)

- GI.Gst.Objects.Bin: mk_BinElementRemovedCallback :: C_BinElementRemovedCallback -> IO (FunPtr C_BinElementRemovedCallback)

- GI.Gst.Objects.Bin: noBinDeepElementAddedCallback :: Maybe BinDeepElementAddedCallback

- GI.Gst.Objects.Bin: noBinDeepElementRemovedCallback :: Maybe BinDeepElementRemovedCallback

- GI.Gst.Objects.Bin: noBinDoLatencyCallback :: Maybe BinDoLatencyCallback

- GI.Gst.Objects.Bin: noBinElementAddedCallback :: Maybe BinElementAddedCallback

- GI.Gst.Objects.Bin: noBinElementRemovedCallback :: Maybe BinElementRemovedCallback

- GI.Gst.Objects.Bin: type C_BinDeepElementAddedCallback = Ptr () -> Ptr Bin -> Ptr Element -> Ptr () -> IO ()

- GI.Gst.Objects.Bin: type C_BinDeepElementRemovedCallback = Ptr () -> Ptr Bin -> Ptr Element -> Ptr () -> IO ()

- GI.Gst.Objects.Bin: type C_BinDoLatencyCallback = Ptr () -> Ptr () -> IO CInt

- GI.Gst.Objects.Bin: type C_BinElementAddedCallback = Ptr () -> Ptr Element -> Ptr () -> IO ()

- GI.Gst.Objects.Bin: type C_BinElementRemovedCallback = Ptr () -> Ptr Element -> Ptr () -> IO ()

- GI.Gst.Objects.Bin: wrap_BinDeepElementAddedCallback :: BinDeepElementAddedCallback -> C_BinDeepElementAddedCallback

- GI.Gst.Objects.Bin: wrap_BinDeepElementRemovedCallback :: BinDeepElementRemovedCallback -> C_BinDeepElementRemovedCallback

- GI.Gst.Objects.Bin: wrap_BinDoLatencyCallback :: BinDoLatencyCallback -> C_BinDoLatencyCallback

- GI.Gst.Objects.Bin: wrap_BinElementAddedCallback :: BinElementAddedCallback -> C_BinElementAddedCallback

- GI.Gst.Objects.Bin: wrap_BinElementRemovedCallback :: BinElementRemovedCallback -> C_BinElementRemovedCallback

- GI.Gst.Objects.Bus: genClosure_BusMessage :: MonadIO m => BusMessageCallback -> m (GClosure C_BusMessageCallback)

- GI.Gst.Objects.Bus: genClosure_BusSyncMessage :: MonadIO m => BusSyncMessageCallback -> m (GClosure C_BusSyncMessageCallback)

- GI.Gst.Objects.Bus: mk_BusMessageCallback :: C_BusMessageCallback -> IO (FunPtr C_BusMessageCallback)

- GI.Gst.Objects.Bus: mk_BusSyncMessageCallback :: C_BusSyncMessageCallback -> IO (FunPtr C_BusSyncMessageCallback)

- GI.Gst.Objects.Bus: noBusMessageCallback :: Maybe BusMessageCallback

- GI.Gst.Objects.Bus: noBusSyncMessageCallback :: Maybe BusSyncMessageCallback

- GI.Gst.Objects.Bus: type C_BusMessageCallback = Ptr () -> Ptr Message -> Ptr () -> IO ()

- GI.Gst.Objects.Bus: type C_BusSyncMessageCallback = Ptr () -> Ptr Message -> Ptr () -> IO ()

- GI.Gst.Objects.Bus: wrap_BusMessageCallback :: BusMessageCallback -> C_BusMessageCallback

- GI.Gst.Objects.Bus: wrap_BusSyncMessageCallback :: BusSyncMessageCallback -> C_BusSyncMessageCallback

- GI.Gst.Objects.Clock: genClosure_ClockSynced :: MonadIO m => ClockSyncedCallback -> m (GClosure C_ClockSyncedCallback)

- GI.Gst.Objects.Clock: mk_ClockSyncedCallback :: C_ClockSyncedCallback -> IO (FunPtr C_ClockSyncedCallback)

- GI.Gst.Objects.Clock: noClockSyncedCallback :: Maybe ClockSyncedCallback

- GI.Gst.Objects.Clock: type C_ClockSyncedCallback = Ptr () -> CInt -> Ptr () -> IO ()

- GI.Gst.Objects.Clock: wrap_ClockSyncedCallback :: ClockSyncedCallback -> C_ClockSyncedCallback

- GI.Gst.Objects.Device: genClosure_DeviceRemoved :: MonadIO m => DeviceRemovedCallback -> m (GClosure C_DeviceRemovedCallback)

- GI.Gst.Objects.Device: mk_DeviceRemovedCallback :: C_DeviceRemovedCallback -> IO (FunPtr C_DeviceRemovedCallback)

- GI.Gst.Objects.Device: noDeviceRemovedCallback :: Maybe DeviceRemovedCallback

- GI.Gst.Objects.Device: type C_DeviceRemovedCallback = Ptr () -> Ptr () -> IO ()

- GI.Gst.Objects.Device: wrap_DeviceRemovedCallback :: DeviceRemovedCallback -> C_DeviceRemovedCallback

- GI.Gst.Objects.DeviceProvider: genClosure_DeviceProviderProviderHidden :: MonadIO m => DeviceProviderProviderHiddenCallback -> m (GClosure C_DeviceProviderProviderHiddenCallback)

- GI.Gst.Objects.DeviceProvider: genClosure_DeviceProviderProviderUnhidden :: MonadIO m => DeviceProviderProviderUnhiddenCallback -> m (GClosure C_DeviceProviderProviderUnhiddenCallback)

- GI.Gst.Objects.DeviceProvider: mk_DeviceProviderProviderHiddenCallback :: C_DeviceProviderProviderHiddenCallback -> IO (FunPtr C_DeviceProviderProviderHiddenCallback)

- GI.Gst.Objects.DeviceProvider: mk_DeviceProviderProviderUnhiddenCallback :: C_DeviceProviderProviderUnhiddenCallback -> IO (FunPtr C_DeviceProviderProviderUnhiddenCallback)

- GI.Gst.Objects.DeviceProvider: noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback

- GI.Gst.Objects.DeviceProvider: noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderUnhiddenCallback

- GI.Gst.Objects.DeviceProvider: type C_DeviceProviderProviderHiddenCallback = Ptr () -> CString -> Ptr () -> IO ()

- GI.Gst.Objects.DeviceProvider: type C_DeviceProviderProviderUnhiddenCallback = Ptr () -> CString -> Ptr () -> IO ()

- GI.Gst.Objects.DeviceProvider: wrap_DeviceProviderProviderHiddenCallback :: DeviceProviderProviderHiddenCallback -> C_DeviceProviderProviderHiddenCallback

- GI.Gst.Objects.DeviceProvider: wrap_DeviceProviderProviderUnhiddenCallback :: DeviceProviderProviderUnhiddenCallback -> C_DeviceProviderProviderUnhiddenCallback

- GI.Gst.Objects.Element: genClosure_ElementNoMorePads :: MonadIO m => ElementNoMorePadsCallback -> m (GClosure C_ElementNoMorePadsCallback)

- GI.Gst.Objects.Element: genClosure_ElementPadAdded :: MonadIO m => ElementPadAddedCallback -> m (GClosure C_ElementPadAddedCallback)

- GI.Gst.Objects.Element: genClosure_ElementPadRemoved :: MonadIO m => ElementPadRemovedCallback -> m (GClosure C_ElementPadRemovedCallback)

- GI.Gst.Objects.Element: mk_ElementNoMorePadsCallback :: C_ElementNoMorePadsCallback -> IO (FunPtr C_ElementNoMorePadsCallback)

- GI.Gst.Objects.Element: mk_ElementPadAddedCallback :: C_ElementPadAddedCallback -> IO (FunPtr C_ElementPadAddedCallback)

- GI.Gst.Objects.Element: mk_ElementPadRemovedCallback :: C_ElementPadRemovedCallback -> IO (FunPtr C_ElementPadRemovedCallback)

- GI.Gst.Objects.Element: noElementNoMorePadsCallback :: Maybe ElementNoMorePadsCallback

- GI.Gst.Objects.Element: noElementPadAddedCallback :: Maybe ElementPadAddedCallback

- GI.Gst.Objects.Element: noElementPadRemovedCallback :: Maybe ElementPadRemovedCallback

- GI.Gst.Objects.Element: type C_ElementNoMorePadsCallback = Ptr () -> Ptr () -> IO ()

- GI.Gst.Objects.Element: type C_ElementPadAddedCallback = Ptr () -> Ptr Pad -> Ptr () -> IO ()

- GI.Gst.Objects.Element: type C_ElementPadRemovedCallback = Ptr () -> Ptr Pad -> Ptr () -> IO ()

- GI.Gst.Objects.Element: wrap_ElementNoMorePadsCallback :: ElementNoMorePadsCallback -> C_ElementNoMorePadsCallback

- GI.Gst.Objects.Element: wrap_ElementPadAddedCallback :: ElementPadAddedCallback -> C_ElementPadAddedCallback

- GI.Gst.Objects.Element: wrap_ElementPadRemovedCallback :: ElementPadRemovedCallback -> C_ElementPadRemovedCallback

- GI.Gst.Objects.Object: genClosure_ObjectDeepNotify :: MonadIO m => ObjectDeepNotifyCallback -> m (GClosure C_ObjectDeepNotifyCallback)

- GI.Gst.Objects.Object: mk_ObjectDeepNotifyCallback :: C_ObjectDeepNotifyCallback -> IO (FunPtr C_ObjectDeepNotifyCallback)

- GI.Gst.Objects.Object: noObjectDeepNotifyCallback :: Maybe ObjectDeepNotifyCallback

- GI.Gst.Objects.Object: type C_ObjectDeepNotifyCallback = Ptr () -> Ptr Object -> Ptr GParamSpec -> Ptr () -> IO ()

- GI.Gst.Objects.Object: wrap_ObjectDeepNotifyCallback :: ObjectDeepNotifyCallback -> C_ObjectDeepNotifyCallback

- GI.Gst.Objects.Pad: genClosure_PadLinked :: MonadIO m => PadLinkedCallback -> m (GClosure C_PadLinkedCallback)

- GI.Gst.Objects.Pad: genClosure_PadUnlinked :: MonadIO m => PadUnlinkedCallback -> m (GClosure C_PadUnlinkedCallback)

- GI.Gst.Objects.Pad: mk_PadLinkedCallback :: C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)

- GI.Gst.Objects.Pad: mk_PadUnlinkedCallback :: C_PadUnlinkedCallback -> IO (FunPtr C_PadUnlinkedCallback)

- GI.Gst.Objects.Pad: noPadLinkedCallback :: Maybe PadLinkedCallback

- GI.Gst.Objects.Pad: noPadUnlinkedCallback :: Maybe PadUnlinkedCallback

- GI.Gst.Objects.Pad: type C_PadLinkedCallback = Ptr () -> Ptr Pad -> Ptr () -> IO ()

- GI.Gst.Objects.Pad: type C_PadUnlinkedCallback = Ptr () -> Ptr Pad -> Ptr () -> IO ()

- GI.Gst.Objects.Pad: wrap_PadLinkedCallback :: PadLinkedCallback -> C_PadLinkedCallback

- GI.Gst.Objects.Pad: wrap_PadUnlinkedCallback :: PadUnlinkedCallback -> C_PadUnlinkedCallback

- GI.Gst.Objects.PadTemplate: genClosure_PadTemplatePadCreated :: MonadIO m => PadTemplatePadCreatedCallback -> m (GClosure C_PadTemplatePadCreatedCallback)

- GI.Gst.Objects.PadTemplate: mk_PadTemplatePadCreatedCallback :: C_PadTemplatePadCreatedCallback -> IO (FunPtr C_PadTemplatePadCreatedCallback)

- GI.Gst.Objects.PadTemplate: noPadTemplatePadCreatedCallback :: Maybe PadTemplatePadCreatedCallback

- GI.Gst.Objects.PadTemplate: type C_PadTemplatePadCreatedCallback = Ptr () -> Ptr Pad -> Ptr () -> IO ()

- GI.Gst.Objects.PadTemplate: wrap_PadTemplatePadCreatedCallback :: PadTemplatePadCreatedCallback -> C_PadTemplatePadCreatedCallback

- GI.Gst.Objects.Registry: genClosure_RegistryFeatureAdded :: MonadIO m => RegistryFeatureAddedCallback -> m (GClosure C_RegistryFeatureAddedCallback)

- GI.Gst.Objects.Registry: genClosure_RegistryPluginAdded :: MonadIO m => RegistryPluginAddedCallback -> m (GClosure C_RegistryPluginAddedCallback)

- GI.Gst.Objects.Registry: mk_RegistryFeatureAddedCallback :: C_RegistryFeatureAddedCallback -> IO (FunPtr C_RegistryFeatureAddedCallback)

- GI.Gst.Objects.Registry: mk_RegistryPluginAddedCallback :: C_RegistryPluginAddedCallback -> IO (FunPtr C_RegistryPluginAddedCallback)

- GI.Gst.Objects.Registry: noRegistryFeatureAddedCallback :: Maybe RegistryFeatureAddedCallback

- GI.Gst.Objects.Registry: noRegistryPluginAddedCallback :: Maybe RegistryPluginAddedCallback

- GI.Gst.Objects.Registry: type C_RegistryFeatureAddedCallback = Ptr () -> Ptr PluginFeature -> Ptr () -> IO ()

- GI.Gst.Objects.Registry: type C_RegistryPluginAddedCallback = Ptr () -> Ptr Plugin -> Ptr () -> IO ()

- GI.Gst.Objects.Registry: wrap_RegistryFeatureAddedCallback :: RegistryFeatureAddedCallback -> C_RegistryFeatureAddedCallback

- GI.Gst.Objects.Registry: wrap_RegistryPluginAddedCallback :: RegistryPluginAddedCallback -> C_RegistryPluginAddedCallback

- GI.Gst.Objects.StreamCollection: genClosure_StreamCollectionStreamNotify :: MonadIO m => StreamCollectionStreamNotifyCallback -> m (GClosure C_StreamCollectionStreamNotifyCallback)

- GI.Gst.Objects.StreamCollection: mk_StreamCollectionStreamNotifyCallback :: C_StreamCollectionStreamNotifyCallback -> IO (FunPtr C_StreamCollectionStreamNotifyCallback)

- GI.Gst.Objects.StreamCollection: noStreamCollectionStreamNotifyCallback :: Maybe StreamCollectionStreamNotifyCallback

- GI.Gst.Objects.StreamCollection: type C_StreamCollectionStreamNotifyCallback = Ptr () -> Ptr Stream -> Ptr GParamSpec -> Ptr () -> IO ()

- GI.Gst.Objects.StreamCollection: wrap_StreamCollectionStreamNotifyCallback :: StreamCollectionStreamNotifyCallback -> C_StreamCollectionStreamNotifyCallback

- GI.Gst.Structs.ClockEntry: clearClockEntryClock :: MonadIO m => ClockEntry -> m ()

- GI.Gst.Structs.ClockEntry: clearClockEntryDestroyData :: MonadIO m => ClockEntry -> m ()

- GI.Gst.Structs.ClockEntry: clearClockEntryFunc :: MonadIO m => ClockEntry -> m ()

- GI.Gst.Structs.ClockEntry: clearClockEntryUserData :: MonadIO m => ClockEntry -> m ()

- GI.Gst.Structs.ClockEntry: getClockEntryClock :: MonadIO m => ClockEntry -> m (Maybe Clock)

- GI.Gst.Structs.ClockEntry: getClockEntryDestroyData :: MonadIO m => ClockEntry -> m (Maybe DestroyNotify)

- GI.Gst.Structs.ClockEntry: getClockEntryFunc :: MonadIO m => ClockEntry -> m (Maybe ClockCallback_WithClosures)

- GI.Gst.Structs.ClockEntry: getClockEntryInterval :: MonadIO m => ClockEntry -> m Word64

- GI.Gst.Structs.ClockEntry: getClockEntryStatus :: MonadIO m => ClockEntry -> m ClockReturn

- GI.Gst.Structs.ClockEntry: getClockEntryTime :: MonadIO m => ClockEntry -> m Word64

- GI.Gst.Structs.ClockEntry: getClockEntryType :: MonadIO m => ClockEntry -> m ClockEntryType

- GI.Gst.Structs.ClockEntry: getClockEntryUnscheduled :: MonadIO m => ClockEntry -> m Bool

- GI.Gst.Structs.ClockEntry: getClockEntryUserData :: MonadIO m => ClockEntry -> m (Ptr ())

- GI.Gst.Structs.ClockEntry: getClockEntryWokenUp :: MonadIO m => ClockEntry -> m Bool

- GI.Gst.Structs.ClockEntry: setClockEntryClock :: MonadIO m => ClockEntry -> Ptr Clock -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryDestroyData :: MonadIO m => ClockEntry -> FunPtr C_DestroyNotify -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryFunc :: MonadIO m => ClockEntry -> FunPtr C_ClockCallback -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryInterval :: MonadIO m => ClockEntry -> Word64 -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryStatus :: MonadIO m => ClockEntry -> ClockReturn -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryTime :: MonadIO m => ClockEntry -> Word64 -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryType :: MonadIO m => ClockEntry -> ClockEntryType -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryUnscheduled :: MonadIO m => ClockEntry -> Bool -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryUserData :: MonadIO m => ClockEntry -> Ptr () -> m ()

- GI.Gst.Structs.ClockEntry: setClockEntryWokenUp :: MonadIO m => ClockEntry -> Bool -> m ()

- GI.Gst.Structs.MiniObject: instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gst.Structs.MiniObject.MiniObject

- GI.Gst.Structs.MiniObject: instance Data.GI.Base.BasicTypes.CallocPtr GI.Gst.Structs.MiniObject.MiniObject

+ GI.Gst.Callbacks: drop_closures_CustomMetaTransformFunction :: CustomMetaTransformFunction -> CustomMetaTransformFunction_WithClosures

+ GI.Gst.Callbacks: dynamic_CustomMetaTransformFunction :: (HasCallStack, MonadIO m) => FunPtr C_CustomMetaTransformFunction -> Buffer -> CustomMeta -> Buffer -> Word32 -> Ptr () -> Ptr () -> m Bool

+ GI.Gst.Callbacks: dynamic_MiniObjectCopyFunction :: (HasCallStack, MonadIO m) => FunPtr C_MiniObjectCopyFunction -> MiniObject -> m MiniObject

+ GI.Gst.Callbacks: dynamic_ValueDeserializeWithPSpecFunc :: (HasCallStack, MonadIO m) => FunPtr C_ValueDeserializeWithPSpecFunc -> GValue -> Text -> GParamSpec -> m Bool

+ GI.Gst.Callbacks: genClosure_CustomMetaTransformFunction :: MonadIO m => CustomMetaTransformFunction -> m (GClosure C_CustomMetaTransformFunction)

+ GI.Gst.Callbacks: genClosure_MiniObjectCopyFunction :: MonadIO m => MiniObjectCopyFunction -> m (GClosure C_MiniObjectCopyFunction)

+ GI.Gst.Callbacks: genClosure_ValueDeserializeWithPSpecFunc :: MonadIO m => ValueDeserializeWithPSpecFunc -> m (GClosure C_ValueDeserializeWithPSpecFunc)

+ GI.Gst.Callbacks: mk_CustomMetaTransformFunction :: C_CustomMetaTransformFunction -> IO (FunPtr C_CustomMetaTransformFunction)

+ GI.Gst.Callbacks: mk_MiniObjectCopyFunction :: C_MiniObjectCopyFunction -> IO (FunPtr C_MiniObjectCopyFunction)

+ GI.Gst.Callbacks: mk_ValueDeserializeWithPSpecFunc :: C_ValueDeserializeWithPSpecFunc -> IO (FunPtr C_ValueDeserializeWithPSpecFunc)

+ GI.Gst.Callbacks: noCustomMetaTransformFunction :: Maybe CustomMetaTransformFunction

+ GI.Gst.Callbacks: noCustomMetaTransformFunction_WithClosures :: Maybe CustomMetaTransformFunction_WithClosures

+ GI.Gst.Callbacks: noMiniObjectCopyFunction :: Maybe MiniObjectCopyFunction

+ GI.Gst.Callbacks: noValueDeserializeWithPSpecFunc :: Maybe ValueDeserializeWithPSpecFunc

+ GI.Gst.Callbacks: type C_CustomMetaTransformFunction = Ptr Buffer -> Ptr CustomMeta -> Ptr Buffer -> Word32 -> Ptr () -> Ptr () -> IO CInt

+ GI.Gst.Callbacks: type C_MiniObjectCopyFunction = Ptr MiniObject -> IO (Ptr MiniObject)

+ GI.Gst.Callbacks: type C_ValueDeserializeWithPSpecFunc = Ptr GValue -> CString -> Ptr GParamSpec -> IO CInt

+ GI.Gst.Callbacks: type CustomMetaTransformFunction = Buffer " /@transbuf@/: a t'GI.Gst.Structs.Buffer.Buffer'" -> CustomMeta " /@meta@/: a t'GI.Gst.Structs.CustomMeta.CustomMeta'" -> Buffer " /@buffer@/: a t'GI.Gst.Structs.Buffer.Buffer'" -> Word32 " /@type@/: the transform type" -> Ptr () " /@data@/: transform specific data." -> IO Bool " __Returns:__ 'P.True' if the transform could be performed"

+ GI.Gst.Callbacks: type CustomMetaTransformFunction_WithClosures = Buffer " /@transbuf@/: a t'GI.Gst.Structs.Buffer.Buffer'" -> CustomMeta " /@meta@/: a t'GI.Gst.Structs.CustomMeta.CustomMeta'" -> Buffer " /@buffer@/: a t'GI.Gst.Structs.Buffer.Buffer'" -> Word32 " /@type@/: the transform type" -> Ptr () " /@data@/: transform specific data." -> Ptr () " /@userData@/: user data passed when registering the meta" -> IO Bool " __Returns:__ 'P.True' if the transform could be performed"

+ GI.Gst.Callbacks: type MiniObjectCopyFunction = MiniObject " /@obj@/: MiniObject to copy" -> IO MiniObject " __Returns:__ reference to cloned instance."

+ GI.Gst.Callbacks: type ValueDeserializeWithPSpecFunc = GValue " /@dest@/: a t'GI.GObject.Structs.Value.Value'" -> Text " /@s@/: a string" -> GParamSpec " /@pspec@/: a t'GI.GObject.Objects.ParamSpec.ParamSpec' describing the expected value" -> IO Bool " __Returns:__ 'P.True' for success"

+ GI.Gst.Callbacks: wrap_CustomMetaTransformFunction :: Maybe (Ptr (FunPtr C_CustomMetaTransformFunction)) -> CustomMetaTransformFunction_WithClosures -> C_CustomMetaTransformFunction

+ GI.Gst.Callbacks: wrap_MiniObjectCopyFunction :: Maybe (Ptr (FunPtr C_MiniObjectCopyFunction)) -> MiniObjectCopyFunction -> C_MiniObjectCopyFunction

+ GI.Gst.Callbacks: wrap_ValueDeserializeWithPSpecFunc :: Maybe (Ptr (FunPtr C_ValueDeserializeWithPSpecFunc)) -> ValueDeserializeWithPSpecFunc -> C_ValueDeserializeWithPSpecFunc

+ GI.Gst.Flags: AnotherGapFlags :: Int -> GapFlags

+ GI.Gst.Flags: AnotherSerializeFlags :: Int -> SerializeFlags

+ GI.Gst.Flags: GapFlagsData :: GapFlags

+ GI.Gst.Flags: SerializeFlagsBackwardCompat :: SerializeFlags

+ GI.Gst.Flags: SerializeFlagsNone :: SerializeFlags

+ GI.Gst.Flags: data GapFlags

+ GI.Gst.Flags: data SerializeFlags

+ GI.Gst.Flags: instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gst.Flags.SerializeFlags

+ GI.Gst.Flags: instance Data.GI.Base.BasicTypes.IsGFlag GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance Data.GI.Base.BasicTypes.IsGFlag GI.Gst.Flags.SerializeFlags

+ GI.Gst.Flags: instance Data.GI.Base.BasicTypes.TypedObject GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance Data.GI.Base.BasicTypes.TypedObject GI.Gst.Flags.SerializeFlags

+ GI.Gst.Flags: instance Data.GI.Base.Overloading.HasParentTypes GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance Data.GI.Base.Overloading.HasParentTypes GI.Gst.Flags.SerializeFlags

+ GI.Gst.Flags: instance GHC.Classes.Eq GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance GHC.Classes.Eq GI.Gst.Flags.SerializeFlags

+ GI.Gst.Flags: instance GHC.Classes.Ord GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance GHC.Classes.Ord GI.Gst.Flags.SerializeFlags

+ GI.Gst.Flags: instance GHC.Enum.Enum GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance GHC.Enum.Enum GI.Gst.Flags.SerializeFlags

+ GI.Gst.Flags: instance GHC.Show.Show GI.Gst.Flags.GapFlags

+ GI.Gst.Flags: instance GHC.Show.Show GI.Gst.Flags.SerializeFlags

+ GI.Gst.Functions: valueDeserializeWithPspec :: (HasCallStack, MonadIO m) => Text -> Maybe GParamSpec -> m (Bool, GValue)

+ GI.Gst.Objects.DeviceProvider: deviceProviderIsStarted :: (HasCallStack, MonadIO m, IsDeviceProvider a) => a -> m Bool

+ GI.Gst.Objects.Element: elementRequestPadSimple :: (HasCallStack, MonadIO m, IsElement a) => a -> Text -> m (Maybe Pad)

+ GI.Gst.Objects.ElementFactory: elementFactoryCreateWithProperties :: (HasCallStack, MonadIO m, IsElementFactory a) => a -> Word32 -> Maybe Text -> Maybe GValue -> m (Maybe Element)

+ GI.Gst.Objects.ElementFactory: elementFactoryMakeWithProperties :: (HasCallStack, MonadIO m) => Text -> Word32 -> Maybe Text -> Maybe GValue -> m (Maybe Element)

+ GI.Gst.Objects.SharedTaskPool: SharedTaskPool :: ManagedPtr SharedTaskPool -> SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: class (GObject o, IsDescendantOf SharedTaskPool o) => IsSharedTaskPool o

+ GI.Gst.Objects.SharedTaskPool: instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gst.Objects.SharedTaskPool.SharedTaskPool o) => GI.Gst.Objects.SharedTaskPool.IsSharedTaskPool o

+ GI.Gst.Objects.SharedTaskPool: instance Data.GI.Base.BasicTypes.GObject GI.Gst.Objects.SharedTaskPool.SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gst.Objects.SharedTaskPool.SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: instance Data.GI.Base.BasicTypes.TypedObject GI.Gst.Objects.SharedTaskPool.SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Gst.Objects.SharedTaskPool.SharedTaskPool)

+ GI.Gst.Objects.SharedTaskPool: instance Data.GI.Base.Overloading.HasParentTypes GI.Gst.Objects.SharedTaskPool.SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: instance GHC.Classes.Eq GI.Gst.Objects.SharedTaskPool.SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: newtype SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: sharedTaskPoolGetMaxThreads :: (HasCallStack, MonadIO m, IsSharedTaskPool a) => a -> m Word32

+ GI.Gst.Objects.SharedTaskPool: sharedTaskPoolNew :: (HasCallStack, MonadIO m) => m SharedTaskPool

+ GI.Gst.Objects.SharedTaskPool: sharedTaskPoolSetMaxThreads :: (HasCallStack, MonadIO m, IsSharedTaskPool a) => a -> Word32 -> m ()

+ GI.Gst.Objects.SharedTaskPool: toSharedTaskPool :: (MonadIO m, IsSharedTaskPool o) => o -> m SharedTaskPool

+ GI.Gst.Objects.TaskPool: taskPoolDisposeHandle :: (HasCallStack, MonadIO m, IsTaskPool a) => a -> Ptr () -> m ()

+ GI.Gst.Structs.AllocationParams: allocationParamsNew :: (HasCallStack, MonadIO m) => m AllocationParams

+ GI.Gst.Structs.Buffer: bufferAddCustomMeta :: (HasCallStack, MonadIO m) => Buffer -> Text -> m (Maybe CustomMeta)

+ GI.Gst.Structs.Buffer: bufferGetCustomMeta :: (HasCallStack, MonadIO m) => Buffer -> Text -> m (Maybe CustomMeta)

+ GI.Gst.Structs.Buffer: bufferNewMemdup :: (HasCallStack, MonadIO m) => ByteString -> m Buffer

+ GI.Gst.Structs.Caps: capsSerialize :: (HasCallStack, MonadIO m) => Caps -> [SerializeFlags] -> m Text

+ GI.Gst.Structs.CapsFeatures: capsFeaturesNewSingle :: (HasCallStack, MonadIO m) => Text -> m CapsFeatures

+ GI.Gst.Structs.CustomMeta: CustomMeta :: ManagedPtr CustomMeta -> CustomMeta

+ GI.Gst.Structs.CustomMeta: customMetaGetStructure :: (HasCallStack, MonadIO m) => CustomMeta -> m Structure

+ GI.Gst.Structs.CustomMeta: customMetaHasName :: (HasCallStack, MonadIO m) => CustomMeta -> Text -> m Bool

+ GI.Gst.Structs.CustomMeta: getCustomMetaMeta :: MonadIO m => CustomMeta -> m Meta

+ GI.Gst.Structs.CustomMeta: instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gst.Structs.CustomMeta.CustomMeta tag

+ GI.Gst.Structs.CustomMeta: instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gst.Structs.CustomMeta.CustomMeta

+ GI.Gst.Structs.CustomMeta: instance Data.GI.Base.BasicTypes.CallocPtr GI.Gst.Structs.CustomMeta.CustomMeta

+ GI.Gst.Structs.CustomMeta: instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gst.Structs.CustomMeta.CustomMeta

+ GI.Gst.Structs.CustomMeta: instance GHC.Classes.Eq GI.Gst.Structs.CustomMeta.CustomMeta

+ GI.Gst.Structs.CustomMeta: newZeroCustomMeta :: MonadIO m => m CustomMeta

+ GI.Gst.Structs.CustomMeta: newtype CustomMeta

+ GI.Gst.Structs.Event: eventParseGapFlags :: (HasCallStack, MonadIO m) => Event -> m [GapFlags]

+ GI.Gst.Structs.Event: eventSetGapFlags :: (HasCallStack, MonadIO m) => Event -> [GapFlags] -> m ()

+ GI.Gst.Structs.Meta: metaRegisterCustom :: (HasCallStack, MonadIO m) => Text -> [Text] -> Maybe CustomMetaTransformFunction -> m MetaInfo

+ GI.Gst.Structs.MetaInfo: metaInfoIsCustom :: (HasCallStack, MonadIO m) => MetaInfo -> m Bool

+ GI.Gst.Structs.MiniObject: clearMiniObjectCopy :: MonadIO m => MiniObject -> m ()

+ GI.Gst.Structs.MiniObject: getMiniObjectCopy :: MonadIO m => MiniObject -> m (Maybe MiniObjectCopyFunction)

+ GI.Gst.Structs.MiniObject: instance Data.GI.Base.BasicTypes.GBoxed GI.Gst.Structs.MiniObject.MiniObject

+ GI.Gst.Structs.MiniObject: instance Data.GI.Base.BasicTypes.TypedObject GI.Gst.Structs.MiniObject.MiniObject

+ GI.Gst.Structs.MiniObject: instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.Gst.Structs.MiniObject.MiniObject)

+ GI.Gst.Structs.MiniObject: instance Data.GI.Base.Overloading.HasParentTypes GI.Gst.Structs.MiniObject.MiniObject

+ GI.Gst.Structs.MiniObject: setMiniObjectCopy :: MonadIO m => MiniObject -> FunPtr C_MiniObjectCopyFunction -> m ()

+ GI.Gst.Structs.Structure: structureSerialize :: (HasCallStack, MonadIO m) => Structure -> [SerializeFlags] -> m Text

+ GI.Gst.Structs.TypeFind: typeFindSuggestEmptySimple :: (HasCallStack, MonadIO m) => TypeFind -> Word32 -> Text -> m ()

+ GI.Gst.Structs.ValueTable: clearValueTableDeserializeWithPspec :: MonadIO m => ValueTable -> m ()

+ GI.Gst.Structs.ValueTable: getValueTableDeserializeWithPspec :: MonadIO m => ValueTable -> m (Maybe ValueDeserializeWithPSpecFunc)

+ GI.Gst.Structs.ValueTable: setValueTableDeserializeWithPspec :: MonadIO m => ValueTable -> FunPtr C_ValueDeserializeWithPSpecFunc -> m ()

- GI.Gst.Interfaces.ChildProxy: afterChildProxyChildAdded :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId

+ GI.Gst.Interfaces.ChildProxy: afterChildProxyChildAdded :: (IsChildProxy a, MonadIO m) => a -> ((?self :: a) => ChildProxyChildAddedCallback) -> m SignalHandlerId

- GI.Gst.Interfaces.ChildProxy: afterChildProxyChildRemoved :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId

+ GI.Gst.Interfaces.ChildProxy: afterChildProxyChildRemoved :: (IsChildProxy a, MonadIO m) => a -> ((?self :: a) => ChildProxyChildRemovedCallback) -> m SignalHandlerId

- GI.Gst.Interfaces.ChildProxy: onChildProxyChildAdded :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId

+ GI.Gst.Interfaces.ChildProxy: onChildProxyChildAdded :: (IsChildProxy a, MonadIO m) => a -> ((?self :: a) => ChildProxyChildAddedCallback) -> m SignalHandlerId

- GI.Gst.Interfaces.ChildProxy: onChildProxyChildRemoved :: (IsChildProxy a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId

+ GI.Gst.Interfaces.ChildProxy: onChildProxyChildRemoved :: (IsChildProxy a, MonadIO m) => a -> ((?self :: a) => ChildProxyChildRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: afterBinDeepElementAdded :: (IsBin a, MonadIO m) => a -> BinDeepElementAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: afterBinDeepElementAdded :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinDeepElementAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: afterBinDeepElementRemoved :: (IsBin a, MonadIO m) => a -> BinDeepElementRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: afterBinDeepElementRemoved :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinDeepElementRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: afterBinDoLatency :: (IsBin a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: afterBinDoLatency :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinDoLatencyCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: afterBinElementAdded :: (IsBin a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: afterBinElementAdded :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinElementAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: afterBinElementRemoved :: (IsBin a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: afterBinElementRemoved :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinElementRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: onBinDeepElementAdded :: (IsBin a, MonadIO m) => a -> BinDeepElementAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: onBinDeepElementAdded :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinDeepElementAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: onBinDeepElementRemoved :: (IsBin a, MonadIO m) => a -> BinDeepElementRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: onBinDeepElementRemoved :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinDeepElementRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: onBinDoLatency :: (IsBin a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: onBinDoLatency :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinDoLatencyCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: onBinElementAdded :: (IsBin a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: onBinElementAdded :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinElementAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bin: onBinElementRemoved :: (IsBin a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bin: onBinElementRemoved :: (IsBin a, MonadIO m) => a -> ((?self :: a) => BinElementRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bus: afterBusMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> BusMessageCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bus: afterBusMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => BusMessageCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bus: afterBusSyncMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> BusSyncMessageCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bus: afterBusSyncMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => BusSyncMessageCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bus: onBusMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> BusMessageCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bus: onBusMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => BusMessageCallback) -> m SignalHandlerId

- GI.Gst.Objects.Bus: onBusSyncMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> BusSyncMessageCallback -> m SignalHandlerId

+ GI.Gst.Objects.Bus: onBusSyncMessage :: (IsBus a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => BusSyncMessageCallback) -> m SignalHandlerId

- GI.Gst.Objects.Clock: afterClockSynced :: (IsClock a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Clock: afterClockSynced :: (IsClock a, MonadIO m) => a -> ((?self :: a) => ClockSyncedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Clock: onClockSynced :: (IsClock a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Clock: onClockSynced :: (IsClock a, MonadIO m) => a -> ((?self :: a) => ClockSyncedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Device: afterDeviceRemoved :: (IsDevice a, MonadIO m) => a -> DeviceRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Device: afterDeviceRemoved :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Device: onDeviceRemoved :: (IsDevice a, MonadIO m) => a -> DeviceRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Device: onDeviceRemoved :: (IsDevice a, MonadIO m) => a -> ((?self :: a) => DeviceRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.DeviceProvider: afterDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId

+ GI.Gst.Objects.DeviceProvider: afterDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderHiddenCallback) -> m SignalHandlerId

- GI.Gst.Objects.DeviceProvider: afterDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId

+ GI.Gst.Objects.DeviceProvider: afterDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderUnhiddenCallback) -> m SignalHandlerId

- GI.Gst.Objects.DeviceProvider: onDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId

+ GI.Gst.Objects.DeviceProvider: onDeviceProviderProviderHidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderHiddenCallback) -> m SignalHandlerId

- GI.Gst.Objects.DeviceProvider: onDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId

+ GI.Gst.Objects.DeviceProvider: onDeviceProviderProviderUnhidden :: (IsDeviceProvider a, MonadIO m) => a -> ((?self :: a) => DeviceProviderProviderUnhiddenCallback) -> m SignalHandlerId

- GI.Gst.Objects.Element: afterElementNoMorePads :: (IsElement a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId

+ GI.Gst.Objects.Element: afterElementNoMorePads :: (IsElement a, MonadIO m) => a -> ((?self :: a) => ElementNoMorePadsCallback) -> m SignalHandlerId

- GI.Gst.Objects.Element: afterElementPadAdded :: (IsElement a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Element: afterElementPadAdded :: (IsElement a, MonadIO m) => a -> ((?self :: a) => ElementPadAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Element: afterElementPadRemoved :: (IsElement a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Element: afterElementPadRemoved :: (IsElement a, MonadIO m) => a -> ((?self :: a) => ElementPadRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Element: onElementNoMorePads :: (IsElement a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId

+ GI.Gst.Objects.Element: onElementNoMorePads :: (IsElement a, MonadIO m) => a -> ((?self :: a) => ElementNoMorePadsCallback) -> m SignalHandlerId

- GI.Gst.Objects.Element: onElementPadAdded :: (IsElement a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Element: onElementPadAdded :: (IsElement a, MonadIO m) => a -> ((?self :: a) => ElementPadAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Element: onElementPadRemoved :: (IsElement a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Element: onElementPadRemoved :: (IsElement a, MonadIO m) => a -> ((?self :: a) => ElementPadRemovedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Object: afterObjectDeepNotify :: (IsObject a, MonadIO m) => a -> Maybe Text -> ObjectDeepNotifyCallback -> m SignalHandlerId

+ GI.Gst.Objects.Object: afterObjectDeepNotify :: (IsObject a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => ObjectDeepNotifyCallback) -> m SignalHandlerId

- GI.Gst.Objects.Object: onObjectDeepNotify :: (IsObject a, MonadIO m) => a -> Maybe Text -> ObjectDeepNotifyCallback -> m SignalHandlerId

+ GI.Gst.Objects.Object: onObjectDeepNotify :: (IsObject a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => ObjectDeepNotifyCallback) -> m SignalHandlerId

- GI.Gst.Objects.Pad: afterPadLinked :: (IsPad a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Pad: afterPadLinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadLinkedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Pad: afterPadUnlinked :: (IsPad a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Pad: afterPadUnlinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadUnlinkedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Pad: onPadLinked :: (IsPad a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Pad: onPadLinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadLinkedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Pad: onPadUnlinked :: (IsPad a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Pad: onPadUnlinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadUnlinkedCallback) -> m SignalHandlerId

- GI.Gst.Objects.PadTemplate: afterPadTemplatePadCreated :: (IsPadTemplate a, MonadIO m) => a -> PadTemplatePadCreatedCallback -> m SignalHandlerId

+ GI.Gst.Objects.PadTemplate: afterPadTemplatePadCreated :: (IsPadTemplate a, MonadIO m) => a -> ((?self :: a) => PadTemplatePadCreatedCallback) -> m SignalHandlerId

- GI.Gst.Objects.PadTemplate: onPadTemplatePadCreated :: (IsPadTemplate a, MonadIO m) => a -> PadTemplatePadCreatedCallback -> m SignalHandlerId

+ GI.Gst.Objects.PadTemplate: onPadTemplatePadCreated :: (IsPadTemplate a, MonadIO m) => a -> ((?self :: a) => PadTemplatePadCreatedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Registry: afterRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Registry: afterRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> ((?self :: a) => RegistryFeatureAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Registry: afterRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Registry: afterRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> ((?self :: a) => RegistryPluginAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Registry: onRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Registry: onRegistryFeatureAdded :: (IsRegistry a, MonadIO m) => a -> ((?self :: a) => RegistryFeatureAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.Registry: onRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId

+ GI.Gst.Objects.Registry: onRegistryPluginAdded :: (IsRegistry a, MonadIO m) => a -> ((?self :: a) => RegistryPluginAddedCallback) -> m SignalHandlerId

- GI.Gst.Objects.StreamCollection: afterStreamCollectionStreamNotify :: (IsStreamCollection a, MonadIO m) => a -> Maybe Text -> StreamCollectionStreamNotifyCallback -> m SignalHandlerId

+ GI.Gst.Objects.StreamCollection: afterStreamCollectionStreamNotify :: (IsStreamCollection a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => StreamCollectionStreamNotifyCallback) -> m SignalHandlerId

- GI.Gst.Objects.StreamCollection: onStreamCollectionStreamNotify :: (IsStreamCollection a, MonadIO m) => a -> Maybe Text -> StreamCollectionStreamNotifyCallback -> m SignalHandlerId

+ GI.Gst.Objects.StreamCollection: onStreamCollectionStreamNotify :: (IsStreamCollection a, MonadIO m) => a -> Maybe Text -> ((?self :: a) => StreamCollectionStreamNotifyCallback) -> m SignalHandlerId

- GI.Gst.Structs.DateTime: dateTimeNewFromGDateTime :: (HasCallStack, MonadIO m) => DateTime -> m (Maybe DateTime)

+ GI.Gst.Structs.DateTime: dateTimeNewFromGDateTime :: (HasCallStack, MonadIO m) => Maybe DateTime -> m (Maybe DateTime)

- GI.Gst.Structs.DateTime: dateTimeNewNowLocalTime :: (HasCallStack, MonadIO m) => m DateTime

+ GI.Gst.Structs.DateTime: dateTimeNewNowLocalTime :: (HasCallStack, MonadIO m) => m (Maybe DateTime)

- GI.Gst.Structs.DateTime: dateTimeNewNowUtc :: (HasCallStack, MonadIO m) => m DateTime

+ GI.Gst.Structs.DateTime: dateTimeNewNowUtc :: (HasCallStack, MonadIO m) => m (Maybe DateTime)

- GI.Gst.Structs.Meta: metaRegister :: (HasCallStack, MonadIO m) => GType -> Text -> Word64 -> MetaInitFunction -> MetaFreeFunction -> MetaTransformFunction -> m (Maybe MetaInfo)

+ GI.Gst.Structs.Meta: metaRegister :: (HasCallStack, MonadIO m) => GType -> Text -> Word64 -> MetaInitFunction -> MetaFreeFunction -> MetaTransformFunction -> m MetaInfo

Files

ChangeLog.md +4/−0
README.md +1/−1
Setup.hs +1/−1
gi-gst.cabal +5/−5

ChangeLog.md view

@@ -1,3 +1,7 @@+### 1.0.25+++ Update to haskell-gi(-base)-0.26+ ### 1.0.24  + Update to haskell-gi(-base)-0.25

README.md view

@@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst.html](https://hackage.haskell.org/package/gi-gst-1.0.24/docs/GI-Gst.html)+[https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst.html](https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst.html)  For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki).

Setup.hs view

@@ -11,7 +11,7 @@   where name = "Gst"         version = "1.0"         pkgName = "gi-gst"-        pkgVersion = "1.0.24"+        pkgVersion = "1.0.25"         overridesFile = Just "Gst.overrides"         verbose = False         outputDir = Nothing

gi-gst.cabal view

@@ -1,11 +1,11 @@ name:                 gi-gst-version:              1.0.24+version:              1.0.25 synopsis:             GStreamer bindings description:          Bindings for GStreamer, autogenerated by haskell-gi. homepage:             https://github.com/haskell-gi/haskell-gi license:              LGPL-2.1 license-file:         LICENSE-author:               Will Thompson, Iñaki García Etxebarria and Jonas Platte+author:               Iñaki García Etxebarria maintainer:           Iñaki García Etxebarria category:             Bindings build-type:           Custom@@ -16,7 +16,7 @@ custom-setup       setup-depends: base >= 4.9 && < 5,                      Cabal >= 1.24,-                     haskell-gi >= 0.25 && < 0.26,+                     haskell-gi >= 0.26 && < 0.27,                      gi-gobject == 2.0.*,                      gi-glib == 2.0.* @@ -28,8 +28,8 @@        pkgconfig-depends: gstreamer-1.0       build-depends: base >= 4.8 && <5,-                     haskell-gi-base >= 0.25 && < 0.26,-                     haskell-gi >= 0.25 && < 0.26,+                     haskell-gi-base >= 0.26 && < 0.27,+                     haskell-gi >= 0.26 && < 0.27,                      haskell-gi-overloading < 1.1,                      gi-gobject == 2.0.*,                      gi-glib == 2.0.*,