{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gst.Objects.Pad
(
Pad(..) ,
IsPad ,
toPad ,
#if defined(ENABLE_OVERLOADING)
ResolvePadMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
PadActivateModeMethodInfo ,
#endif
padActivateMode ,
#if defined(ENABLE_OVERLOADING)
PadAddProbeMethodInfo ,
#endif
padAddProbe ,
#if defined(ENABLE_OVERLOADING)
PadCanLinkMethodInfo ,
#endif
padCanLink ,
#if defined(ENABLE_OVERLOADING)
PadChainMethodInfo ,
#endif
padChain ,
#if defined(ENABLE_OVERLOADING)
PadChainListMethodInfo ,
#endif
padChainList ,
#if defined(ENABLE_OVERLOADING)
PadCheckReconfigureMethodInfo ,
#endif
padCheckReconfigure ,
#if defined(ENABLE_OVERLOADING)
PadCreateStreamIdMethodInfo ,
#endif
padCreateStreamId ,
#if defined(ENABLE_OVERLOADING)
PadEventDefaultMethodInfo ,
#endif
padEventDefault ,
#if defined(ENABLE_OVERLOADING)
PadForwardMethodInfo ,
#endif
padForward ,
#if defined(ENABLE_OVERLOADING)
PadGetAllowedCapsMethodInfo ,
#endif
padGetAllowedCaps ,
#if defined(ENABLE_OVERLOADING)
PadGetCurrentCapsMethodInfo ,
#endif
padGetCurrentCaps ,
#if defined(ENABLE_OVERLOADING)
PadGetDirectionMethodInfo ,
#endif
padGetDirection ,
#if defined(ENABLE_OVERLOADING)
PadGetElementPrivateMethodInfo ,
#endif
padGetElementPrivate ,
#if defined(ENABLE_OVERLOADING)
PadGetLastFlowReturnMethodInfo ,
#endif
padGetLastFlowReturn ,
#if defined(ENABLE_OVERLOADING)
PadGetOffsetMethodInfo ,
#endif
padGetOffset ,
#if defined(ENABLE_OVERLOADING)
PadGetPadTemplateMethodInfo ,
#endif
padGetPadTemplate ,
#if defined(ENABLE_OVERLOADING)
PadGetPadTemplateCapsMethodInfo ,
#endif
padGetPadTemplateCaps ,
#if defined(ENABLE_OVERLOADING)
PadGetParentElementMethodInfo ,
#endif
padGetParentElement ,
#if defined(ENABLE_OVERLOADING)
PadGetPeerMethodInfo ,
#endif
padGetPeer ,
#if defined(ENABLE_OVERLOADING)
PadGetRangeMethodInfo ,
#endif
padGetRange ,
#if defined(ENABLE_OVERLOADING)
PadGetSingleInternalLinkMethodInfo ,
#endif
padGetSingleInternalLink ,
#if defined(ENABLE_OVERLOADING)
PadGetStickyEventMethodInfo ,
#endif
padGetStickyEvent ,
#if defined(ENABLE_OVERLOADING)
PadGetStreamMethodInfo ,
#endif
padGetStream ,
#if defined(ENABLE_OVERLOADING)
PadGetStreamIdMethodInfo ,
#endif
padGetStreamId ,
#if defined(ENABLE_OVERLOADING)
PadGetTaskStateMethodInfo ,
#endif
padGetTaskState ,
#if defined(ENABLE_OVERLOADING)
PadHasCurrentCapsMethodInfo ,
#endif
padHasCurrentCaps ,
#if defined(ENABLE_OVERLOADING)
PadIsActiveMethodInfo ,
#endif
padIsActive ,
#if defined(ENABLE_OVERLOADING)
PadIsBlockedMethodInfo ,
#endif
padIsBlocked ,
#if defined(ENABLE_OVERLOADING)
PadIsBlockingMethodInfo ,
#endif
padIsBlocking ,
#if defined(ENABLE_OVERLOADING)
PadIsLinkedMethodInfo ,
#endif
padIsLinked ,
#if defined(ENABLE_OVERLOADING)
PadIterateInternalLinksMethodInfo ,
#endif
padIterateInternalLinks ,
#if defined(ENABLE_OVERLOADING)
PadIterateInternalLinksDefaultMethodInfo,
#endif
padIterateInternalLinksDefault ,
#if defined(ENABLE_OVERLOADING)
PadLinkMethodInfo ,
#endif
padLink ,
#if defined(ENABLE_OVERLOADING)
PadLinkFullMethodInfo ,
#endif
padLinkFull ,
padLinkGetName ,
#if defined(ENABLE_OVERLOADING)
PadLinkMaybeGhostingMethodInfo ,
#endif
padLinkMaybeGhosting ,
#if defined(ENABLE_OVERLOADING)
PadLinkMaybeGhostingFullMethodInfo ,
#endif
padLinkMaybeGhostingFull ,
#if defined(ENABLE_OVERLOADING)
PadMarkReconfigureMethodInfo ,
#endif
padMarkReconfigure ,
#if defined(ENABLE_OVERLOADING)
PadNeedsReconfigureMethodInfo ,
#endif
padNeedsReconfigure ,
padNew ,
padNewFromStaticTemplate ,
padNewFromTemplate ,
#if defined(ENABLE_OVERLOADING)
PadPauseTaskMethodInfo ,
#endif
padPauseTask ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryMethodInfo ,
#endif
padPeerQuery ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryAcceptCapsMethodInfo ,
#endif
padPeerQueryAcceptCaps ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryCapsMethodInfo ,
#endif
padPeerQueryCaps ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryConvertMethodInfo ,
#endif
padPeerQueryConvert ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryDurationMethodInfo ,
#endif
padPeerQueryDuration ,
#if defined(ENABLE_OVERLOADING)
PadPeerQueryPositionMethodInfo ,
#endif
padPeerQueryPosition ,
#if defined(ENABLE_OVERLOADING)
PadProxyQueryAcceptCapsMethodInfo ,
#endif
padProxyQueryAcceptCaps ,
#if defined(ENABLE_OVERLOADING)
PadProxyQueryCapsMethodInfo ,
#endif
padProxyQueryCaps ,
#if defined(ENABLE_OVERLOADING)
PadPullRangeMethodInfo ,
#endif
padPullRange ,
#if defined(ENABLE_OVERLOADING)
PadPushMethodInfo ,
#endif
padPush ,
#if defined(ENABLE_OVERLOADING)
PadPushEventMethodInfo ,
#endif
padPushEvent ,
#if defined(ENABLE_OVERLOADING)
PadPushListMethodInfo ,
#endif
padPushList ,
#if defined(ENABLE_OVERLOADING)
PadQueryMethodInfo ,
#endif
padQuery ,
#if defined(ENABLE_OVERLOADING)
PadQueryAcceptCapsMethodInfo ,
#endif
padQueryAcceptCaps ,
#if defined(ENABLE_OVERLOADING)
PadQueryCapsMethodInfo ,
#endif
padQueryCaps ,
#if defined(ENABLE_OVERLOADING)
PadQueryConvertMethodInfo ,
#endif
padQueryConvert ,
#if defined(ENABLE_OVERLOADING)
PadQueryDefaultMethodInfo ,
#endif
padQueryDefault ,
#if defined(ENABLE_OVERLOADING)
PadQueryDurationMethodInfo ,
#endif
padQueryDuration ,
#if defined(ENABLE_OVERLOADING)
PadQueryPositionMethodInfo ,
#endif
padQueryPosition ,
#if defined(ENABLE_OVERLOADING)
PadRemoveProbeMethodInfo ,
#endif
padRemoveProbe ,
#if defined(ENABLE_OVERLOADING)
PadSendEventMethodInfo ,
#endif
padSendEvent ,
#if defined(ENABLE_OVERLOADING)
PadSetActivateFunctionFullMethodInfo ,
#endif
padSetActivateFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetActivatemodeFunctionFullMethodInfo,
#endif
padSetActivatemodeFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetActiveMethodInfo ,
#endif
padSetActive ,
#if defined(ENABLE_OVERLOADING)
PadSetChainFunctionFullMethodInfo ,
#endif
padSetChainFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetChainListFunctionFullMethodInfo ,
#endif
padSetChainListFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetElementPrivateMethodInfo ,
#endif
padSetElementPrivate ,
#if defined(ENABLE_OVERLOADING)
PadSetEventFullFunctionFullMethodInfo ,
#endif
padSetEventFullFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetEventFunctionFullMethodInfo ,
#endif
padSetEventFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetGetrangeFunctionFullMethodInfo ,
#endif
padSetGetrangeFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetIterateInternalLinksFunctionFullMethodInfo,
#endif
padSetIterateInternalLinksFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetLinkFunctionFullMethodInfo ,
#endif
padSetLinkFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetOffsetMethodInfo ,
#endif
padSetOffset ,
#if defined(ENABLE_OVERLOADING)
PadSetQueryFunctionFullMethodInfo ,
#endif
padSetQueryFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadSetUnlinkFunctionFullMethodInfo ,
#endif
padSetUnlinkFunctionFull ,
#if defined(ENABLE_OVERLOADING)
PadStartTaskMethodInfo ,
#endif
padStartTask ,
#if defined(ENABLE_OVERLOADING)
PadStickyEventsForeachMethodInfo ,
#endif
padStickyEventsForeach ,
#if defined(ENABLE_OVERLOADING)
PadStopTaskMethodInfo ,
#endif
padStopTask ,
#if defined(ENABLE_OVERLOADING)
PadStoreStickyEventMethodInfo ,
#endif
padStoreStickyEvent ,
#if defined(ENABLE_OVERLOADING)
PadUnlinkMethodInfo ,
#endif
padUnlink ,
#if defined(ENABLE_OVERLOADING)
PadUseFixedCapsMethodInfo ,
#endif
padUseFixedCaps ,
#if defined(ENABLE_OVERLOADING)
PadCapsPropertyInfo ,
#endif
getPadCaps ,
#if defined(ENABLE_OVERLOADING)
padCaps ,
#endif
#if defined(ENABLE_OVERLOADING)
PadDirectionPropertyInfo ,
#endif
constructPadDirection ,
getPadDirection ,
#if defined(ENABLE_OVERLOADING)
padDirection ,
#endif
#if defined(ENABLE_OVERLOADING)
PadOffsetPropertyInfo ,
#endif
constructPadOffset ,
getPadOffset ,
#if defined(ENABLE_OVERLOADING)
padOffset ,
#endif
setPadOffset ,
#if defined(ENABLE_OVERLOADING)
PadTemplatePropertyInfo ,
#endif
clearPadTemplate ,
constructPadTemplate ,
getPadTemplate ,
#if defined(ENABLE_OVERLOADING)
padTemplate ,
#endif
setPadTemplate ,
PadLinkedCallback ,
#if defined(ENABLE_OVERLOADING)
PadLinkedSignalInfo ,
#endif
afterPadLinked ,
onPadLinked ,
PadUnlinkedCallback ,
#if defined(ENABLE_OVERLOADING)
PadUnlinkedSignalInfo ,
#endif
afterPadUnlinked ,
onPadUnlinked ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Element as Gst.Element
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.PadTemplate as Gst.PadTemplate
import {-# SOURCE #-} qualified GI.Gst.Objects.Stream as Gst.Stream
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.BufferList as Gst.BufferList
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.Event as Gst.Event
import {-# SOURCE #-} qualified GI.Gst.Structs.Iterator as Gst.Iterator
import {-# SOURCE #-} qualified GI.Gst.Structs.Query as Gst.Query
import {-# SOURCE #-} qualified GI.Gst.Structs.StaticPadTemplate as Gst.StaticPadTemplate
newtype Pad = Pad (SP.ManagedPtr Pad)
deriving (Pad -> Pad -> Bool
(Pad -> Pad -> Bool) -> (Pad -> Pad -> Bool) -> Eq Pad
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pad -> Pad -> Bool
$c/= :: Pad -> Pad -> Bool
== :: Pad -> Pad -> Bool
$c== :: Pad -> Pad -> Bool
Eq)
instance SP.ManagedPtrNewtype Pad where
toManagedPtr :: Pad -> ManagedPtr Pad
toManagedPtr (Pad ManagedPtr Pad
p) = ManagedPtr Pad
p
foreign import ccall "gst_pad_get_type"
c_gst_pad_get_type :: IO B.Types.GType
instance B.Types.TypedObject Pad where
glibType :: IO GType
glibType = IO GType
c_gst_pad_get_type
instance B.Types.GObject Pad
class (SP.GObject o, O.IsDescendantOf Pad o) => IsPad o
instance (SP.GObject o, O.IsDescendantOf Pad o) => IsPad o
instance O.HasParentTypes Pad
type instance O.ParentTypes Pad = '[Gst.Object.Object, GObject.Object.Object]
toPad :: (MIO.MonadIO m, IsPad o) => o -> m Pad
toPad :: forall (m :: * -> *) o. (MonadIO m, IsPad o) => o -> m Pad
toPad = IO Pad -> m Pad
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Pad -> m Pad) -> (o -> IO Pad) -> o -> m Pad
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Pad -> Pad) -> o -> IO Pad
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Pad -> Pad
Pad
instance B.GValue.IsGValue (Maybe Pad) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_pad_get_type
gvalueSet_ :: Ptr GValue -> Maybe Pad -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Pad
P.Nothing = Ptr GValue -> Ptr Pad -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Pad
forall a. Ptr a
FP.nullPtr :: FP.Ptr Pad)
gvalueSet_ Ptr GValue
gv (P.Just Pad
obj) = Pad -> (Ptr Pad -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Pad
obj (Ptr GValue -> Ptr Pad -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe Pad)
gvalueGet_ Ptr GValue
gv = do
Ptr Pad
ptr <- Ptr GValue -> IO (Ptr Pad)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Pad)
if Ptr Pad
ptr Ptr Pad -> Ptr Pad -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Pad
forall a. Ptr a
FP.nullPtr
then Pad -> Maybe Pad
forall a. a -> Maybe a
P.Just (Pad -> Maybe Pad) -> IO Pad -> IO (Maybe Pad)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Pad -> Pad
Pad Ptr Pad
ptr
else Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolvePadMethod (t :: Symbol) (o :: *) :: * where
ResolvePadMethod "activateMode" o = PadActivateModeMethodInfo
ResolvePadMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
ResolvePadMethod "addProbe" o = PadAddProbeMethodInfo
ResolvePadMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolvePadMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolvePadMethod "canLink" o = PadCanLinkMethodInfo
ResolvePadMethod "chain" o = PadChainMethodInfo
ResolvePadMethod "chainList" o = PadChainListMethodInfo
ResolvePadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo
ResolvePadMethod "createStreamId" o = PadCreateStreamIdMethodInfo
ResolvePadMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
ResolvePadMethod "eventDefault" o = PadEventDefaultMethodInfo
ResolvePadMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolvePadMethod "forward" o = PadForwardMethodInfo
ResolvePadMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolvePadMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolvePadMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
ResolvePadMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
ResolvePadMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
ResolvePadMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
ResolvePadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo
ResolvePadMethod "isActive" o = PadIsActiveMethodInfo
ResolvePadMethod "isBlocked" o = PadIsBlockedMethodInfo
ResolvePadMethod "isBlocking" o = PadIsBlockingMethodInfo
ResolvePadMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolvePadMethod "isLinked" o = PadIsLinkedMethodInfo
ResolvePadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo
ResolvePadMethod "iterateInternalLinksDefault" o = PadIterateInternalLinksDefaultMethodInfo
ResolvePadMethod "link" o = PadLinkMethodInfo
ResolvePadMethod "linkFull" o = PadLinkFullMethodInfo
ResolvePadMethod "linkMaybeGhosting" o = PadLinkMaybeGhostingMethodInfo
ResolvePadMethod "linkMaybeGhostingFull" o = PadLinkMaybeGhostingFullMethodInfo
ResolvePadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo
ResolvePadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo
ResolvePadMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolvePadMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolvePadMethod "pauseTask" o = PadPauseTaskMethodInfo
ResolvePadMethod "peerQuery" o = PadPeerQueryMethodInfo
ResolvePadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo
ResolvePadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo
ResolvePadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo
ResolvePadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo
ResolvePadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo
ResolvePadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo
ResolvePadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo
ResolvePadMethod "pullRange" o = PadPullRangeMethodInfo
ResolvePadMethod "push" o = PadPushMethodInfo
ResolvePadMethod "pushEvent" o = PadPushEventMethodInfo
ResolvePadMethod "pushList" o = PadPushListMethodInfo
ResolvePadMethod "query" o = PadQueryMethodInfo
ResolvePadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo
ResolvePadMethod "queryCaps" o = PadQueryCapsMethodInfo
ResolvePadMethod "queryConvert" o = PadQueryConvertMethodInfo
ResolvePadMethod "queryDefault" o = PadQueryDefaultMethodInfo
ResolvePadMethod "queryDuration" o = PadQueryDurationMethodInfo
ResolvePadMethod "queryPosition" o = PadQueryPositionMethodInfo
ResolvePadMethod "ref" o = Gst.Object.ObjectRefMethodInfo
ResolvePadMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolvePadMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
ResolvePadMethod "removeProbe" o = PadRemoveProbeMethodInfo
ResolvePadMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolvePadMethod "sendEvent" o = PadSendEventMethodInfo
ResolvePadMethod "startTask" o = PadStartTaskMethodInfo
ResolvePadMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolvePadMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolvePadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo
ResolvePadMethod "stopTask" o = PadStopTaskMethodInfo
ResolvePadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo
ResolvePadMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
ResolvePadMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
ResolvePadMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolvePadMethod "unlink" o = PadUnlinkMethodInfo
ResolvePadMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
ResolvePadMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
ResolvePadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo
ResolvePadMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolvePadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo
ResolvePadMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
ResolvePadMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
ResolvePadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo
ResolvePadMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolvePadMethod "getDirection" o = PadGetDirectionMethodInfo
ResolvePadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo
ResolvePadMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
ResolvePadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo
ResolvePadMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
ResolvePadMethod "getOffset" o = PadGetOffsetMethodInfo
ResolvePadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo
ResolvePadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo
ResolvePadMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
ResolvePadMethod "getParentElement" o = PadGetParentElementMethodInfo
ResolvePadMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
ResolvePadMethod "getPeer" o = PadGetPeerMethodInfo
ResolvePadMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolvePadMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolvePadMethod "getRange" o = PadGetRangeMethodInfo
ResolvePadMethod "getSingleInternalLink" o = PadGetSingleInternalLinkMethodInfo
ResolvePadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo
ResolvePadMethod "getStream" o = PadGetStreamMethodInfo
ResolvePadMethod "getStreamId" o = PadGetStreamIdMethodInfo
ResolvePadMethod "getTaskState" o = PadGetTaskStateMethodInfo
ResolvePadMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
ResolvePadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo
ResolvePadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo
ResolvePadMethod "setActive" o = PadSetActiveMethodInfo
ResolvePadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo
ResolvePadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo
ResolvePadMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
ResolvePadMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
ResolvePadMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
ResolvePadMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolvePadMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolvePadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo
ResolvePadMethod "setEventFullFunctionFull" o = PadSetEventFullFunctionFullMethodInfo
ResolvePadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo
ResolvePadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo
ResolvePadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo
ResolvePadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo
ResolvePadMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
ResolvePadMethod "setOffset" o = PadSetOffsetMethodInfo
ResolvePadMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
ResolvePadMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolvePadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo
ResolvePadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo
ResolvePadMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolvePadMethod t Pad, O.OverloadedMethod info Pad p) => OL.IsLabel t (Pad -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolvePadMethod t Pad, O.OverloadedMethod info Pad p, R.HasField t Pad p) => R.HasField t Pad p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolvePadMethod t Pad, O.OverloadedMethodInfo info Pad) => OL.IsLabel t (O.MethodProxy info Pad) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
type PadLinkedCallback =
Pad
-> IO ()
type C_PadLinkedCallback =
Ptr Pad ->
Ptr Pad ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_PadLinkedCallback :: C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
wrap_PadLinkedCallback ::
GObject a => (a -> PadLinkedCallback) ->
C_PadLinkedCallback
wrap_PadLinkedCallback :: forall a.
GObject a =>
(a -> PadLinkedCallback) -> C_PadLinkedCallback
wrap_PadLinkedCallback a -> PadLinkedCallback
gi'cb Ptr Pad
gi'selfPtr Ptr Pad
peer Ptr ()
_ = do
Pad
peer' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
peer
Ptr Pad -> PadLinkedCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Pad
gi'selfPtr (PadLinkedCallback -> IO ()) -> PadLinkedCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \Pad
gi'self -> a -> PadLinkedCallback
gi'cb (Pad -> a
Coerce.coerce Pad
gi'self) Pad
peer'
onPadLinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadLinkedCallback) -> m SignalHandlerId
onPadLinked :: forall a (m :: * -> *).
(IsPad a, MonadIO m) =>
a -> ((?self::a) => PadLinkedCallback) -> m SignalHandlerId
onPadLinked a
obj (?self::a) => PadLinkedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> PadLinkedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PadLinkedCallback
PadLinkedCallback
cb
let wrapped' :: C_PadLinkedCallback
wrapped' = (a -> PadLinkedCallback) -> C_PadLinkedCallback
forall a.
GObject a =>
(a -> PadLinkedCallback) -> C_PadLinkedCallback
wrap_PadLinkedCallback a -> PadLinkedCallback
wrapped
FunPtr C_PadLinkedCallback
wrapped'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadLinkedCallback C_PadLinkedCallback
wrapped'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"linked" FunPtr C_PadLinkedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterPadLinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadLinkedCallback) -> m SignalHandlerId
afterPadLinked :: forall a (m :: * -> *).
(IsPad a, MonadIO m) =>
a -> ((?self::a) => PadLinkedCallback) -> m SignalHandlerId
afterPadLinked a
obj (?self::a) => PadLinkedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> PadLinkedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PadLinkedCallback
PadLinkedCallback
cb
let wrapped' :: C_PadLinkedCallback
wrapped' = (a -> PadLinkedCallback) -> C_PadLinkedCallback
forall a.
GObject a =>
(a -> PadLinkedCallback) -> C_PadLinkedCallback
wrap_PadLinkedCallback a -> PadLinkedCallback
wrapped
FunPtr C_PadLinkedCallback
wrapped'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadLinkedCallback C_PadLinkedCallback
wrapped'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"linked" FunPtr C_PadLinkedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data PadLinkedSignalInfo
instance SignalInfo PadLinkedSignalInfo where
type HaskellCallbackType PadLinkedSignalInfo = PadLinkedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_PadLinkedCallback cb
cb'' <- mk_PadLinkedCallback cb'
connectSignalFunPtr obj "linked" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad::linked"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#g:signal:linked"})
#endif
type PadUnlinkedCallback =
Pad
-> IO ()
type C_PadUnlinkedCallback =
Ptr Pad ->
Ptr Pad ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_PadUnlinkedCallback :: C_PadUnlinkedCallback -> IO (FunPtr C_PadUnlinkedCallback)
wrap_PadUnlinkedCallback ::
GObject a => (a -> PadUnlinkedCallback) ->
C_PadUnlinkedCallback
wrap_PadUnlinkedCallback :: forall a.
GObject a =>
(a -> PadLinkedCallback) -> C_PadLinkedCallback
wrap_PadUnlinkedCallback a -> PadLinkedCallback
gi'cb Ptr Pad
gi'selfPtr Ptr Pad
peer Ptr ()
_ = do
Pad
peer' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
peer
Ptr Pad -> PadLinkedCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr Pad
gi'selfPtr (PadLinkedCallback -> IO ()) -> PadLinkedCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \Pad
gi'self -> a -> PadLinkedCallback
gi'cb (Pad -> a
Coerce.coerce Pad
gi'self) Pad
peer'
onPadUnlinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadUnlinkedCallback) -> m SignalHandlerId
onPadUnlinked :: forall a (m :: * -> *).
(IsPad a, MonadIO m) =>
a -> ((?self::a) => PadLinkedCallback) -> m SignalHandlerId
onPadUnlinked a
obj (?self::a) => PadLinkedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> PadLinkedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PadLinkedCallback
PadLinkedCallback
cb
let wrapped' :: C_PadLinkedCallback
wrapped' = (a -> PadLinkedCallback) -> C_PadLinkedCallback
forall a.
GObject a =>
(a -> PadLinkedCallback) -> C_PadLinkedCallback
wrap_PadUnlinkedCallback a -> PadLinkedCallback
wrapped
FunPtr C_PadLinkedCallback
wrapped'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadUnlinkedCallback C_PadLinkedCallback
wrapped'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unlinked" FunPtr C_PadLinkedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing
afterPadUnlinked :: (IsPad a, MonadIO m) => a -> ((?self :: a) => PadUnlinkedCallback) -> m SignalHandlerId
afterPadUnlinked :: forall a (m :: * -> *).
(IsPad a, MonadIO m) =>
a -> ((?self::a) => PadLinkedCallback) -> m SignalHandlerId
afterPadUnlinked a
obj (?self::a) => PadLinkedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
let wrapped :: a -> PadLinkedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => PadLinkedCallback
PadLinkedCallback
cb
let wrapped' :: C_PadLinkedCallback
wrapped' = (a -> PadLinkedCallback) -> C_PadLinkedCallback
forall a.
GObject a =>
(a -> PadLinkedCallback) -> C_PadLinkedCallback
wrap_PadUnlinkedCallback a -> PadLinkedCallback
wrapped
FunPtr C_PadLinkedCallback
wrapped'' <- C_PadLinkedCallback -> IO (FunPtr C_PadLinkedCallback)
mk_PadUnlinkedCallback C_PadLinkedCallback
wrapped'
a
-> Text
-> FunPtr C_PadLinkedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"unlinked" FunPtr C_PadLinkedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing
#if defined(ENABLE_OVERLOADING)
data PadUnlinkedSignalInfo
instance SignalInfo PadUnlinkedSignalInfo where
type HaskellCallbackType PadUnlinkedSignalInfo = PadUnlinkedCallback
connectSignal obj cb connectMode detail = do
let cb' = wrap_PadUnlinkedCallback cb
cb'' <- mk_PadUnlinkedCallback cb'
connectSignalFunPtr obj "unlinked" cb'' connectMode detail
dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad::unlinked"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#g:signal:unlinked"})
#endif
getPadCaps :: (MonadIO m, IsPad o) => o -> m (Maybe Gst.Caps.Caps)
getPadCaps :: forall (m :: * -> *) o. (MonadIO m, IsPad o) => o -> m (Maybe Caps)
getPadCaps o
obj = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ o -> String -> (ManagedPtr Caps -> Caps) -> IO (Maybe Caps)
forall a b.
(GObject a, GBoxed b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyBoxed o
obj String
"caps" ManagedPtr Caps -> Caps
Gst.Caps.Caps
#if defined(ENABLE_OVERLOADING)
data PadCapsPropertyInfo
instance AttrInfo PadCapsPropertyInfo where
type AttrAllowedOps PadCapsPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint PadCapsPropertyInfo = IsPad
type AttrSetTypeConstraint PadCapsPropertyInfo = (~) ()
type AttrTransferTypeConstraint PadCapsPropertyInfo = (~) ()
type AttrTransferType PadCapsPropertyInfo = ()
type AttrGetType PadCapsPropertyInfo = (Maybe Gst.Caps.Caps)
type AttrLabel PadCapsPropertyInfo = "caps"
type AttrOrigin PadCapsPropertyInfo = Pad
attrGet = getPadCaps
attrSet = undefined
attrTransfer _ = undefined
attrConstruct = undefined
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.caps"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#g:attr:caps"
})
#endif
getPadDirection :: (MonadIO m, IsPad o) => o -> m Gst.Enums.PadDirection
getPadDirection :: forall (m :: * -> *) o. (MonadIO m, IsPad o) => o -> m PadDirection
getPadDirection o
obj = IO PadDirection -> m PadDirection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO PadDirection -> m PadDirection)
-> IO PadDirection -> m PadDirection
forall a b. (a -> b) -> a -> b
$ o -> String -> IO PadDirection
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"direction"
constructPadDirection :: (IsPad o, MIO.MonadIO m) => Gst.Enums.PadDirection -> m (GValueConstruct o)
constructPadDirection :: forall o (m :: * -> *).
(IsPad o, MonadIO m) =>
PadDirection -> m (GValueConstruct o)
constructPadDirection PadDirection
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> PadDirection -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"direction" PadDirection
val
#if defined(ENABLE_OVERLOADING)
data PadDirectionPropertyInfo
instance AttrInfo PadDirectionPropertyInfo where
type AttrAllowedOps PadDirectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint PadDirectionPropertyInfo = IsPad
type AttrSetTypeConstraint PadDirectionPropertyInfo = (~) Gst.Enums.PadDirection
type AttrTransferTypeConstraint PadDirectionPropertyInfo = (~) Gst.Enums.PadDirection
type AttrTransferType PadDirectionPropertyInfo = Gst.Enums.PadDirection
type AttrGetType PadDirectionPropertyInfo = Gst.Enums.PadDirection
type AttrLabel PadDirectionPropertyInfo = "direction"
type AttrOrigin PadDirectionPropertyInfo = Pad
attrGet = getPadDirection
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructPadDirection
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.direction"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#g:attr:direction"
})
#endif
getPadOffset :: (MonadIO m, IsPad o) => o -> m Int64
getPadOffset :: forall (m :: * -> *) o. (MonadIO m, IsPad o) => o -> m Int64
getPadOffset o
obj = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int64
forall a. GObject a => a -> String -> IO Int64
B.Properties.getObjectPropertyInt64 o
obj String
"offset"
setPadOffset :: (MonadIO m, IsPad o) => o -> Int64 -> m ()
setPadOffset :: forall (m :: * -> *) o. (MonadIO m, IsPad o) => o -> Int64 -> m ()
setPadOffset o
obj Int64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Int64 -> IO ()
forall a. GObject a => a -> String -> Int64 -> IO ()
B.Properties.setObjectPropertyInt64 o
obj String
"offset" Int64
val
constructPadOffset :: (IsPad o, MIO.MonadIO m) => Int64 -> m (GValueConstruct o)
constructPadOffset :: forall o (m :: * -> *).
(IsPad o, MonadIO m) =>
Int64 -> m (GValueConstruct o)
constructPadOffset Int64
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int64 -> IO (GValueConstruct o)
forall o. String -> Int64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt64 String
"offset" Int64
val
#if defined(ENABLE_OVERLOADING)
data PadOffsetPropertyInfo
instance AttrInfo PadOffsetPropertyInfo where
type AttrAllowedOps PadOffsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint PadOffsetPropertyInfo = IsPad
type AttrSetTypeConstraint PadOffsetPropertyInfo = (~) Int64
type AttrTransferTypeConstraint PadOffsetPropertyInfo = (~) Int64
type AttrTransferType PadOffsetPropertyInfo = Int64
type AttrGetType PadOffsetPropertyInfo = Int64
type AttrLabel PadOffsetPropertyInfo = "offset"
type AttrOrigin PadOffsetPropertyInfo = Pad
attrGet = getPadOffset
attrSet = setPadOffset
attrTransfer _ v = do
return v
attrConstruct = constructPadOffset
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.offset"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#g:attr:offset"
})
#endif
getPadTemplate :: (MonadIO m, IsPad o) => o -> m (Maybe Gst.PadTemplate.PadTemplate)
getPadTemplate :: forall (m :: * -> *) o.
(MonadIO m, IsPad o) =>
o -> m (Maybe PadTemplate)
getPadTemplate o
obj = IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe PadTemplate) -> m (Maybe PadTemplate))
-> IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr PadTemplate -> PadTemplate)
-> IO (Maybe PadTemplate)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"template" ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate
setPadTemplate :: (MonadIO m, IsPad o, Gst.PadTemplate.IsPadTemplate a) => o -> a -> m ()
setPadTemplate :: forall (m :: * -> *) o a.
(MonadIO m, IsPad o, IsPadTemplate a) =>
o -> a -> m ()
setPadTemplate o
obj a
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"template" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)
constructPadTemplate :: (IsPad o, MIO.MonadIO m, Gst.PadTemplate.IsPadTemplate a) => a -> m (GValueConstruct o)
constructPadTemplate :: forall o (m :: * -> *) a.
(IsPad o, MonadIO m, IsPadTemplate a) =>
a -> m (GValueConstruct o)
constructPadTemplate a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"template" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)
clearPadTemplate :: (MonadIO m, IsPad o) => o -> m ()
clearPadTemplate :: forall (m :: * -> *) o. (MonadIO m, IsPad o) => o -> m ()
clearPadTemplate o
obj = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe PadTemplate -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"template" (Maybe PadTemplate
forall a. Maybe a
Nothing :: Maybe Gst.PadTemplate.PadTemplate)
#if defined(ENABLE_OVERLOADING)
data PadTemplatePropertyInfo
instance AttrInfo PadTemplatePropertyInfo where
type AttrAllowedOps PadTemplatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrBaseTypeConstraint PadTemplatePropertyInfo = IsPad
type AttrSetTypeConstraint PadTemplatePropertyInfo = Gst.PadTemplate.IsPadTemplate
type AttrTransferTypeConstraint PadTemplatePropertyInfo = Gst.PadTemplate.IsPadTemplate
type AttrTransferType PadTemplatePropertyInfo = Gst.PadTemplate.PadTemplate
type AttrGetType PadTemplatePropertyInfo = (Maybe Gst.PadTemplate.PadTemplate)
type AttrLabel PadTemplatePropertyInfo = "template"
type AttrOrigin PadTemplatePropertyInfo = Pad
attrGet = getPadTemplate
attrSet = setPadTemplate
attrTransfer _ v = do
unsafeCastTo Gst.PadTemplate.PadTemplate v
attrConstruct = constructPadTemplate
attrClear = clearPadTemplate
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.template"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#g:attr:template"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Pad
type instance O.AttributeList Pad = PadAttributeList
type PadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
padCaps :: AttrLabelProxy "caps"
padCaps = AttrLabelProxy
padDirection :: AttrLabelProxy "direction"
padDirection = AttrLabelProxy
padOffset :: AttrLabelProxy "offset"
padOffset = AttrLabelProxy
padTemplate :: AttrLabelProxy "template"
padTemplate = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Pad = PadSignalList
type PadSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "gst_pad_new" gst_pad_new ::
CString ->
CUInt ->
IO (Ptr Pad)
padNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Maybe (T.Text)
-> Gst.Enums.PadDirection
-> m (Maybe Pad)
padNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Maybe Text -> PadDirection -> m (Maybe Pad)
padNew Maybe Text
name PadDirection
direction = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
let direction' :: CUInt
direction' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadDirection -> Int) -> PadDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PadDirection
direction
Ptr Pad
result <- Ptr CChar -> CUInt -> IO (Ptr Pad)
gst_pad_new Ptr CChar
maybeName CUInt
direction'
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_pad_new_from_static_template" gst_pad_new_from_static_template ::
Ptr Gst.StaticPadTemplate.StaticPadTemplate ->
CString ->
IO (Ptr Pad)
padNewFromStaticTemplate ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.StaticPadTemplate.StaticPadTemplate
-> T.Text
-> m (Maybe Pad)
padNewFromStaticTemplate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StaticPadTemplate -> Text -> m (Maybe Pad)
padNewFromStaticTemplate StaticPadTemplate
templ Text
name = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr StaticPadTemplate
templ' <- StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StaticPadTemplate
templ
Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
Ptr Pad
result <- Ptr StaticPadTemplate -> Ptr CChar -> IO (Ptr Pad)
gst_pad_new_from_static_template Ptr StaticPadTemplate
templ' Ptr CChar
name'
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
StaticPadTemplate -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StaticPadTemplate
templ
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_pad_new_from_template" gst_pad_new_from_template ::
Ptr Gst.PadTemplate.PadTemplate ->
CString ->
IO (Ptr Pad)
padNewFromTemplate ::
(B.CallStack.HasCallStack, MonadIO m, Gst.PadTemplate.IsPadTemplate a) =>
a
-> Maybe (T.Text)
-> m (Maybe Pad)
padNewFromTemplate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPadTemplate a) =>
a -> Maybe Text -> m (Maybe Pad)
padNewFromTemplate a
templ Maybe Text
name = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr PadTemplate
templ' <- a -> IO (Ptr PadTemplate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
templ
Ptr CChar
maybeName <- case Maybe Text
name of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jName -> do
Ptr CChar
jName' <- Text -> IO (Ptr CChar)
textToCString Text
jName
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jName'
Ptr Pad
result <- Ptr PadTemplate -> Ptr CChar -> IO (Ptr Pad)
gst_pad_new_from_template Ptr PadTemplate
templ' Ptr CChar
maybeName
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
templ
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeName
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "gst_pad_activate_mode" gst_pad_activate_mode ::
Ptr Pad ->
CUInt ->
CInt ->
IO CInt
padActivateMode ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.PadMode
-> Bool
-> m Bool
padActivateMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadMode -> Bool -> m Bool
padActivateMode a
pad PadMode
mode Bool
active = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let mode' :: CUInt
mode' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadMode -> Int) -> PadMode -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadMode -> Int
forall a. Enum a => a -> Int
fromEnum) PadMode
mode
let active' :: CInt
active' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
active
CInt
result <- Ptr Pad -> CUInt -> CInt -> IO CInt
gst_pad_activate_mode Ptr Pad
pad' CUInt
mode' CInt
active'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadActivateModeMethodInfo
instance (signature ~ (Gst.Enums.PadMode -> Bool -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadActivateModeMethodInfo a signature where
overloadedMethod = padActivateMode
instance O.OverloadedMethodInfo PadActivateModeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padActivateMode",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padActivateMode"
})
#endif
foreign import ccall "gst_pad_add_probe" gst_pad_add_probe ::
Ptr Pad ->
CUInt ->
FunPtr Gst.Callbacks.C_PadProbeCallback ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO CULong
padAddProbe ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> [Gst.Flags.PadProbeType]
-> Gst.Callbacks.PadProbeCallback
-> m CULong
padAddProbe :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> [PadProbeType] -> PadProbeCallback -> m SignalHandlerId
padAddProbe a
pad [PadProbeType]
mask PadProbeCallback
callback = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let mask' :: CUInt
mask' = [PadProbeType] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadProbeType]
mask
FunPtr C_PadProbeCallback
callback' <- C_PadProbeCallback -> IO (FunPtr C_PadProbeCallback)
Gst.Callbacks.mk_PadProbeCallback (Maybe (Ptr (FunPtr C_PadProbeCallback))
-> PadProbeCallback_WithClosures -> C_PadProbeCallback
Gst.Callbacks.wrap_PadProbeCallback Maybe (Ptr (FunPtr C_PadProbeCallback))
forall a. Maybe a
Nothing (PadProbeCallback -> PadProbeCallback_WithClosures
Gst.Callbacks.drop_closures_PadProbeCallback PadProbeCallback
callback))
let userData :: Ptr ()
userData = FunPtr C_PadProbeCallback -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadProbeCallback
callback'
let destroyData :: FunPtr (Ptr a -> IO ())
destroyData = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
SignalHandlerId
result <- Ptr Pad
-> CUInt
-> FunPtr C_PadProbeCallback
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO SignalHandlerId
gst_pad_add_probe Ptr Pad
pad' CUInt
mask' FunPtr C_PadProbeCallback
callback' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
destroyData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
SignalHandlerId -> IO SignalHandlerId
forall (m :: * -> *) a. Monad m => a -> m a
return SignalHandlerId
result
#if defined(ENABLE_OVERLOADING)
data PadAddProbeMethodInfo
instance (signature ~ ([Gst.Flags.PadProbeType] -> Gst.Callbacks.PadProbeCallback -> m CULong), MonadIO m, IsPad a) => O.OverloadedMethod PadAddProbeMethodInfo a signature where
overloadedMethod = padAddProbe
instance O.OverloadedMethodInfo PadAddProbeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padAddProbe",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padAddProbe"
})
#endif
foreign import ccall "gst_pad_can_link" gst_pad_can_link ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padCanLink ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Bool
padCanLink :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a -> b -> m Bool
padCanLink a
srcpad b
sinkpad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_can_link Ptr Pad
srcpad' Ptr Pad
sinkpad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadCanLinkMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.OverloadedMethod PadCanLinkMethodInfo a signature where
overloadedMethod = padCanLink
instance O.OverloadedMethodInfo PadCanLinkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padCanLink",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padCanLink"
})
#endif
foreign import ccall "gst_pad_chain" gst_pad_chain ::
Ptr Pad ->
Ptr Gst.Buffer.Buffer ->
IO CInt
padChain ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Buffer.Buffer
-> m Gst.Enums.FlowReturn
padChain :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Buffer -> m FlowReturn
padChain a
pad Buffer
buffer = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buffer
CInt
result <- Ptr Pad -> Ptr Buffer -> IO CInt
gst_pad_chain Ptr Pad
pad' Ptr Buffer
buffer'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadChainMethodInfo
instance (signature ~ (Gst.Buffer.Buffer -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.OverloadedMethod PadChainMethodInfo a signature where
overloadedMethod = padChain
instance O.OverloadedMethodInfo PadChainMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padChain",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padChain"
})
#endif
foreign import ccall "gst_pad_chain_list" gst_pad_chain_list ::
Ptr Pad ->
Ptr Gst.BufferList.BufferList ->
IO CInt
padChainList ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.BufferList.BufferList
-> m Gst.Enums.FlowReturn
padChainList :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> BufferList -> m FlowReturn
padChainList a
pad BufferList
list = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed BufferList
list
CInt
result <- Ptr Pad -> Ptr BufferList -> IO CInt
gst_pad_chain_list Ptr Pad
pad' Ptr BufferList
list'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadChainListMethodInfo
instance (signature ~ (Gst.BufferList.BufferList -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.OverloadedMethod PadChainListMethodInfo a signature where
overloadedMethod = padChainList
instance O.OverloadedMethodInfo PadChainListMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padChainList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padChainList"
})
#endif
foreign import ccall "gst_pad_check_reconfigure" gst_pad_check_reconfigure ::
Ptr Pad ->
IO CInt
padCheckReconfigure ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padCheckReconfigure :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padCheckReconfigure a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_check_reconfigure Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadCheckReconfigureMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadCheckReconfigureMethodInfo a signature where
overloadedMethod = padCheckReconfigure
instance O.OverloadedMethodInfo PadCheckReconfigureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padCheckReconfigure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padCheckReconfigure"
})
#endif
foreign import ccall "gst_pad_create_stream_id" gst_pad_create_stream_id ::
Ptr Pad ->
Ptr Gst.Element.Element ->
CString ->
IO CString
padCreateStreamId ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Element.IsElement b) =>
a
-> b
-> Maybe (T.Text)
-> m T.Text
padCreateStreamId :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsElement b) =>
a -> b -> Maybe Text -> m Text
padCreateStreamId a
pad b
parent Maybe Text
streamId = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Element
parent' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
parent
Ptr CChar
maybeStreamId <- case Maybe Text
streamId of
Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
Just Text
jStreamId -> do
Ptr CChar
jStreamId' <- Text -> IO (Ptr CChar)
textToCString Text
jStreamId
Ptr CChar -> IO (Ptr CChar)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jStreamId'
Ptr CChar
result <- Ptr Pad -> Ptr Element -> Ptr CChar -> IO (Ptr CChar)
gst_pad_create_stream_id Ptr Pad
pad' Ptr Element
parent' Ptr CChar
maybeStreamId
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padCreateStreamId" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
parent
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeStreamId
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data PadCreateStreamIdMethodInfo
instance (signature ~ (b -> Maybe (T.Text) -> m T.Text), MonadIO m, IsPad a, Gst.Element.IsElement b) => O.OverloadedMethod PadCreateStreamIdMethodInfo a signature where
overloadedMethod = padCreateStreamId
instance O.OverloadedMethodInfo PadCreateStreamIdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padCreateStreamId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padCreateStreamId"
})
#endif
foreign import ccall "gst_pad_event_default" gst_pad_event_default ::
Ptr Pad ->
Ptr Gst.Object.Object ->
Ptr Gst.Event.Event ->
IO CInt
padEventDefault ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) =>
a
-> Maybe (b)
-> Gst.Event.Event
-> m Bool
padEventDefault :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsObject b) =>
a -> Maybe b -> Event -> m Bool
padEventDefault a
pad Maybe b
parent Event
event = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Object
maybeParent <- case Maybe b
parent of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just b
jParent -> do
Ptr Object
jParent' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jParent'
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Event
event
CInt
result <- Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt
gst_pad_event_default Ptr Pad
pad' Ptr Object
maybeParent Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadEventDefaultMethodInfo
instance (signature ~ (Maybe (b) -> Gst.Event.Event -> m Bool), MonadIO m, IsPad a, Gst.Object.IsObject b) => O.OverloadedMethod PadEventDefaultMethodInfo a signature where
overloadedMethod = padEventDefault
instance O.OverloadedMethodInfo PadEventDefaultMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padEventDefault",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padEventDefault"
})
#endif
foreign import ccall "gst_pad_forward" gst_pad_forward ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadForwardFunction ->
Ptr () ->
IO CInt
padForward ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadForwardFunction
-> m Bool
padForward :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadForwardFunction -> m Bool
padForward a
pad PadForwardFunction
forward = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadForwardFunction
forward' <- C_PadForwardFunction -> IO (FunPtr C_PadForwardFunction)
Gst.Callbacks.mk_PadForwardFunction (Maybe (Ptr (FunPtr C_PadForwardFunction))
-> PadForwardFunction_WithClosures -> C_PadForwardFunction
Gst.Callbacks.wrap_PadForwardFunction Maybe (Ptr (FunPtr C_PadForwardFunction))
forall a. Maybe a
Nothing (PadForwardFunction -> PadForwardFunction_WithClosures
Gst.Callbacks.drop_closures_PadForwardFunction PadForwardFunction
forward))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
CInt
result <- Ptr Pad -> FunPtr C_PadForwardFunction -> Ptr () -> IO CInt
gst_pad_forward Ptr Pad
pad' FunPtr C_PadForwardFunction
forward' Ptr ()
forall a. Ptr a
userData
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_PadForwardFunction -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadForwardFunction
forward'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadForwardMethodInfo
instance (signature ~ (Gst.Callbacks.PadForwardFunction -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadForwardMethodInfo a signature where
overloadedMethod = padForward
instance O.OverloadedMethodInfo PadForwardMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padForward",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padForward"
})
#endif
foreign import ccall "gst_pad_get_allowed_caps" gst_pad_get_allowed_caps ::
Ptr Pad ->
IO (Ptr Gst.Caps.Caps)
padGetAllowedCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Caps.Caps)
padGetAllowedCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Caps)
padGetAllowedCaps a
pad = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
result <- Ptr Pad -> IO (Ptr Caps)
gst_pad_get_allowed_caps Ptr Pad
pad'
Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Caps -> IO (Maybe Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetAllowedCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetAllowedCapsMethodInfo a signature where
overloadedMethod = padGetAllowedCaps
instance O.OverloadedMethodInfo PadGetAllowedCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetAllowedCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetAllowedCaps"
})
#endif
foreign import ccall "gst_pad_get_current_caps" gst_pad_get_current_caps ::
Ptr Pad ->
IO (Ptr Gst.Caps.Caps)
padGetCurrentCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Caps.Caps)
padGetCurrentCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Caps)
padGetCurrentCaps a
pad = IO (Maybe Caps) -> m (Maybe Caps)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Caps) -> m (Maybe Caps))
-> IO (Maybe Caps) -> m (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
result <- Ptr Pad -> IO (Ptr Caps)
gst_pad_get_current_caps Ptr Pad
pad'
Maybe Caps
maybeResult <- Ptr Caps -> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Caps
result ((Ptr Caps -> IO Caps) -> IO (Maybe Caps))
-> (Ptr Caps -> IO Caps) -> IO (Maybe Caps)
forall a b. (a -> b) -> a -> b
$ \Ptr Caps
result' -> do
Caps
result'' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result'
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Caps -> IO (Maybe Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Caps
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetCurrentCapsMethodInfo
instance (signature ~ (m (Maybe Gst.Caps.Caps)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetCurrentCapsMethodInfo a signature where
overloadedMethod = padGetCurrentCaps
instance O.OverloadedMethodInfo PadGetCurrentCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetCurrentCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetCurrentCaps"
})
#endif
foreign import ccall "gst_pad_get_direction" gst_pad_get_direction ::
Ptr Pad ->
IO CUInt
padGetDirection ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Enums.PadDirection
padGetDirection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m PadDirection
padGetDirection a
pad = IO PadDirection -> m PadDirection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadDirection -> m PadDirection)
-> IO PadDirection -> m PadDirection
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CUInt
result <- Ptr Pad -> IO CUInt
gst_pad_get_direction Ptr Pad
pad'
let result' :: PadDirection
result' = (Int -> PadDirection
forall a. Enum a => Int -> a
toEnum (Int -> PadDirection) -> (CUInt -> Int) -> CUInt -> PadDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
PadDirection -> IO PadDirection
forall (m :: * -> *) a. Monad m => a -> m a
return PadDirection
result'
#if defined(ENABLE_OVERLOADING)
data PadGetDirectionMethodInfo
instance (signature ~ (m Gst.Enums.PadDirection), MonadIO m, IsPad a) => O.OverloadedMethod PadGetDirectionMethodInfo a signature where
overloadedMethod = padGetDirection
instance O.OverloadedMethodInfo PadGetDirectionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetDirection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetDirection"
})
#endif
foreign import ccall "gst_pad_get_element_private" gst_pad_get_element_private ::
Ptr Pad ->
IO (Ptr ())
padGetElementPrivate ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Ptr ())
padGetElementPrivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Ptr ())
padGetElementPrivate a
pad = IO (Ptr ()) -> m (Ptr ())
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr ()
result <- Ptr Pad -> IO (Ptr ())
gst_pad_get_element_private Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr () -> IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
#if defined(ENABLE_OVERLOADING)
data PadGetElementPrivateMethodInfo
instance (signature ~ (m (Ptr ())), MonadIO m, IsPad a) => O.OverloadedMethod PadGetElementPrivateMethodInfo a signature where
overloadedMethod = padGetElementPrivate
instance O.OverloadedMethodInfo PadGetElementPrivateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetElementPrivate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetElementPrivate"
})
#endif
foreign import ccall "gst_pad_get_last_flow_return" gst_pad_get_last_flow_return ::
Ptr Pad ->
IO CInt
padGetLastFlowReturn ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Enums.FlowReturn
padGetLastFlowReturn :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m FlowReturn
padGetLastFlowReturn a
pad = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_get_last_flow_return Ptr Pad
pad'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadGetLastFlowReturnMethodInfo
instance (signature ~ (m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.OverloadedMethod PadGetLastFlowReturnMethodInfo a signature where
overloadedMethod = padGetLastFlowReturn
instance O.OverloadedMethodInfo PadGetLastFlowReturnMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetLastFlowReturn",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetLastFlowReturn"
})
#endif
foreign import ccall "gst_pad_get_offset" gst_pad_get_offset ::
Ptr Pad ->
IO Int64
padGetOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Int64
padGetOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Int64
padGetOffset a
pad = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Int64
result <- Ptr Pad -> IO Int64
gst_pad_get_offset Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Int64 -> IO Int64
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
data PadGetOffsetMethodInfo
instance (signature ~ (m Int64), MonadIO m, IsPad a) => O.OverloadedMethod PadGetOffsetMethodInfo a signature where
overloadedMethod = padGetOffset
instance O.OverloadedMethodInfo PadGetOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetOffset"
})
#endif
foreign import ccall "gst_pad_get_pad_template" gst_pad_get_pad_template ::
Ptr Pad ->
IO (Ptr Gst.PadTemplate.PadTemplate)
padGetPadTemplate ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.PadTemplate.PadTemplate)
padGetPadTemplate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe PadTemplate)
padGetPadTemplate a
pad = IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PadTemplate) -> m (Maybe PadTemplate))
-> IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr PadTemplate
result <- Ptr Pad -> IO (Ptr PadTemplate)
gst_pad_get_pad_template Ptr Pad
pad'
Maybe PadTemplate
maybeResult <- Ptr PadTemplate
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PadTemplate
result ((Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate))
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ \Ptr PadTemplate
result' -> do
PadTemplate
result'' <- ((ManagedPtr PadTemplate -> PadTemplate)
-> Ptr PadTemplate -> IO PadTemplate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate) Ptr PadTemplate
result'
PadTemplate -> IO PadTemplate
forall (m :: * -> *) a. Monad m => a -> m a
return PadTemplate
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe PadTemplate -> IO (Maybe PadTemplate)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PadTemplate
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetPadTemplateMethodInfo
instance (signature ~ (m (Maybe Gst.PadTemplate.PadTemplate)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetPadTemplateMethodInfo a signature where
overloadedMethod = padGetPadTemplate
instance O.OverloadedMethodInfo PadGetPadTemplateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetPadTemplate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetPadTemplate"
})
#endif
foreign import ccall "gst_pad_get_pad_template_caps" gst_pad_get_pad_template_caps ::
Ptr Pad ->
IO (Ptr Gst.Caps.Caps)
padGetPadTemplateCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Caps.Caps
padGetPadTemplateCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Caps
padGetPadTemplateCaps a
pad = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
result <- Ptr Pad -> IO (Ptr Caps)
gst_pad_get_pad_template_caps Ptr Pad
pad'
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padGetPadTemplateCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data PadGetPadTemplateCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m, IsPad a) => O.OverloadedMethod PadGetPadTemplateCapsMethodInfo a signature where
overloadedMethod = padGetPadTemplateCaps
instance O.OverloadedMethodInfo PadGetPadTemplateCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetPadTemplateCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetPadTemplateCaps"
})
#endif
foreign import ccall "gst_pad_get_parent_element" gst_pad_get_parent_element ::
Ptr Pad ->
IO (Ptr Gst.Element.Element)
padGetParentElement ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Element.Element)
padGetParentElement :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Element)
padGetParentElement a
pad = IO (Maybe Element) -> m (Maybe Element)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Element) -> m (Maybe Element))
-> IO (Maybe Element) -> m (Maybe Element)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Element
result <- Ptr Pad -> IO (Ptr Element)
gst_pad_get_parent_element Ptr Pad
pad'
Maybe Element
maybeResult <- Ptr Element -> (Ptr Element -> IO Element) -> IO (Maybe Element)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Element
result ((Ptr Element -> IO Element) -> IO (Maybe Element))
-> (Ptr Element -> IO Element) -> IO (Maybe Element)
forall a b. (a -> b) -> a -> b
$ \Ptr Element
result' -> do
Element
result'' <- ((ManagedPtr Element -> Element) -> Ptr Element -> IO Element
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Element -> Element
Gst.Element.Element) Ptr Element
result'
Element -> IO Element
forall (m :: * -> *) a. Monad m => a -> m a
return Element
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Element -> IO (Maybe Element)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Element
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetParentElementMethodInfo
instance (signature ~ (m (Maybe Gst.Element.Element)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetParentElementMethodInfo a signature where
overloadedMethod = padGetParentElement
instance O.OverloadedMethodInfo PadGetParentElementMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetParentElement",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetParentElement"
})
#endif
foreign import ccall "gst_pad_get_peer" gst_pad_get_peer ::
Ptr Pad ->
IO (Ptr Pad)
padGetPeer ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Pad)
padGetPeer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Pad)
padGetPeer a
pad = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad
result <- Ptr Pad -> IO (Ptr Pad)
gst_pad_get_peer Ptr Pad
pad'
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetPeerMethodInfo
instance (signature ~ (m (Maybe Pad)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetPeerMethodInfo a signature where
overloadedMethod = padGetPeer
instance O.OverloadedMethodInfo PadGetPeerMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetPeer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetPeer"
})
#endif
foreign import ccall "gst_pad_get_range" gst_pad_get_range ::
Ptr Pad ->
Word64 ->
Word32 ->
Ptr (Ptr Gst.Buffer.Buffer) ->
IO CInt
padGetRange ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Word64
-> Word32
-> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
padGetRange :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Word64 -> Word32 -> m (FlowReturn, Buffer)
padGetRange a
pad Word64
offset Word32
size = IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer))
-> IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr (Ptr Buffer)
buffer <- IO (Ptr (Ptr Buffer))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))
CInt
result <- Ptr Pad -> Word64 -> Word32 -> Ptr (Ptr Buffer) -> IO CInt
gst_pad_get_range Ptr Pad
pad' Word64
offset Word32
size Ptr (Ptr Buffer)
buffer
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Ptr Buffer
buffer' <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Buffer)
buffer
Buffer
buffer'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
buffer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr (Ptr Buffer) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Buffer)
buffer
(FlowReturn, Buffer) -> IO (FlowReturn, Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return (FlowReturn
result', Buffer
buffer'')
#if defined(ENABLE_OVERLOADING)
data PadGetRangeMethodInfo
instance (signature ~ (Word64 -> Word32 -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))), MonadIO m, IsPad a) => O.OverloadedMethod PadGetRangeMethodInfo a signature where
overloadedMethod = padGetRange
instance O.OverloadedMethodInfo PadGetRangeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetRange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetRange"
})
#endif
foreign import ccall "gst_pad_get_single_internal_link" gst_pad_get_single_internal_link ::
Ptr Pad ->
IO (Ptr Pad)
padGetSingleInternalLink ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Pad)
padGetSingleInternalLink :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Pad)
padGetSingleInternalLink a
pad = IO (Maybe Pad) -> m (Maybe Pad)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Pad) -> m (Maybe Pad))
-> IO (Maybe Pad) -> m (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad
result <- Ptr Pad -> IO (Ptr Pad)
gst_pad_get_single_internal_link Ptr Pad
pad'
Maybe Pad
maybeResult <- Ptr Pad -> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Pad
result ((Ptr Pad -> IO Pad) -> IO (Maybe Pad))
-> (Ptr Pad -> IO Pad) -> IO (Maybe Pad)
forall a b. (a -> b) -> a -> b
$ \Ptr Pad
result' -> do
Pad
result'' <- ((ManagedPtr Pad -> Pad) -> Ptr Pad -> IO Pad
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Pad -> Pad
Pad) Ptr Pad
result'
Pad -> IO Pad
forall (m :: * -> *) a. Monad m => a -> m a
return Pad
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Pad -> IO (Maybe Pad)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pad
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetSingleInternalLinkMethodInfo
instance (signature ~ (m (Maybe Pad)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetSingleInternalLinkMethodInfo a signature where
overloadedMethod = padGetSingleInternalLink
instance O.OverloadedMethodInfo PadGetSingleInternalLinkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetSingleInternalLink",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetSingleInternalLink"
})
#endif
foreign import ccall "gst_pad_get_sticky_event" gst_pad_get_sticky_event ::
Ptr Pad ->
CUInt ->
Word32 ->
IO (Ptr Gst.Event.Event)
padGetStickyEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.EventType
-> Word32
-> m (Maybe Gst.Event.Event)
padGetStickyEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> EventType -> Word32 -> m (Maybe Event)
padGetStickyEvent a
pad EventType
eventType Word32
idx = IO (Maybe Event) -> m (Maybe Event)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Event) -> m (Maybe Event))
-> IO (Maybe Event) -> m (Maybe Event)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let eventType' :: CUInt
eventType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (EventType -> Int) -> EventType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. EventType -> Int
forall a. Enum a => a -> Int
fromEnum) EventType
eventType
Ptr Event
result <- Ptr Pad -> CUInt -> Word32 -> IO (Ptr Event)
gst_pad_get_sticky_event Ptr Pad
pad' CUInt
eventType' Word32
idx
Maybe Event
maybeResult <- Ptr Event -> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Event
result ((Ptr Event -> IO Event) -> IO (Maybe Event))
-> (Ptr Event -> IO Event) -> IO (Maybe Event)
forall a b. (a -> b) -> a -> b
$ \Ptr Event
result' -> do
Event
result'' <- ((ManagedPtr Event -> Event) -> Ptr Event -> IO Event
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Event -> Event
Gst.Event.Event) Ptr Event
result'
Event -> IO Event
forall (m :: * -> *) a. Monad m => a -> m a
return Event
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Event -> IO (Maybe Event)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Event
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetStickyEventMethodInfo
instance (signature ~ (Gst.Enums.EventType -> Word32 -> m (Maybe Gst.Event.Event)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetStickyEventMethodInfo a signature where
overloadedMethod = padGetStickyEvent
instance O.OverloadedMethodInfo PadGetStickyEventMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetStickyEvent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetStickyEvent"
})
#endif
foreign import ccall "gst_pad_get_stream" gst_pad_get_stream ::
Ptr Pad ->
IO (Ptr Gst.Stream.Stream)
padGetStream ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Stream.Stream)
padGetStream :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Stream)
padGetStream a
pad = IO (Maybe Stream) -> m (Maybe Stream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Stream) -> m (Maybe Stream))
-> IO (Maybe Stream) -> m (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Stream
result <- Ptr Pad -> IO (Ptr Stream)
gst_pad_get_stream Ptr Pad
pad'
Maybe Stream
maybeResult <- Ptr Stream -> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Stream
result ((Ptr Stream -> IO Stream) -> IO (Maybe Stream))
-> (Ptr Stream -> IO Stream) -> IO (Maybe Stream)
forall a b. (a -> b) -> a -> b
$ \Ptr Stream
result' -> do
Stream
result'' <- ((ManagedPtr Stream -> Stream) -> Ptr Stream -> IO Stream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Stream -> Stream
Gst.Stream.Stream) Ptr Stream
result'
Stream -> IO Stream
forall (m :: * -> *) a. Monad m => a -> m a
return Stream
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Stream -> IO (Maybe Stream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Stream
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetStreamMethodInfo
instance (signature ~ (m (Maybe Gst.Stream.Stream)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetStreamMethodInfo a signature where
overloadedMethod = padGetStream
instance O.OverloadedMethodInfo PadGetStreamMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetStream",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetStream"
})
#endif
foreign import ccall "gst_pad_get_stream_id" gst_pad_get_stream_id ::
Ptr Pad ->
IO CString
padGetStreamId ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe T.Text)
padGetStreamId :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Text)
padGetStreamId a
pad = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr CChar
result <- Ptr Pad -> IO (Ptr CChar)
gst_pad_get_stream_id Ptr Pad
pad'
Maybe Text
maybeResult <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
result ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
result' -> do
Text
result'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result'
Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadGetStreamIdMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsPad a) => O.OverloadedMethod PadGetStreamIdMethodInfo a signature where
overloadedMethod = padGetStreamId
instance O.OverloadedMethodInfo PadGetStreamIdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetStreamId",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetStreamId"
})
#endif
foreign import ccall "gst_pad_get_task_state" gst_pad_get_task_state ::
Ptr Pad ->
IO CUInt
padGetTaskState ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Gst.Enums.TaskState
padGetTaskState :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m TaskState
padGetTaskState a
pad = IO TaskState -> m TaskState
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TaskState -> m TaskState) -> IO TaskState -> m TaskState
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CUInt
result <- Ptr Pad -> IO CUInt
gst_pad_get_task_state Ptr Pad
pad'
let result' :: TaskState
result' = (Int -> TaskState
forall a. Enum a => Int -> a
toEnum (Int -> TaskState) -> (CUInt -> Int) -> CUInt -> TaskState
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
TaskState -> IO TaskState
forall (m :: * -> *) a. Monad m => a -> m a
return TaskState
result'
#if defined(ENABLE_OVERLOADING)
data PadGetTaskStateMethodInfo
instance (signature ~ (m Gst.Enums.TaskState), MonadIO m, IsPad a) => O.OverloadedMethod PadGetTaskStateMethodInfo a signature where
overloadedMethod = padGetTaskState
instance O.OverloadedMethodInfo PadGetTaskStateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padGetTaskState",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padGetTaskState"
})
#endif
foreign import ccall "gst_pad_has_current_caps" gst_pad_has_current_caps ::
Ptr Pad ->
IO CInt
padHasCurrentCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padHasCurrentCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padHasCurrentCaps a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_has_current_caps Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadHasCurrentCapsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadHasCurrentCapsMethodInfo a signature where
overloadedMethod = padHasCurrentCaps
instance O.OverloadedMethodInfo PadHasCurrentCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padHasCurrentCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padHasCurrentCaps"
})
#endif
foreign import ccall "gst_pad_is_active" gst_pad_is_active ::
Ptr Pad ->
IO CInt
padIsActive ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsActive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padIsActive a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_active Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsActiveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadIsActiveMethodInfo a signature where
overloadedMethod = padIsActive
instance O.OverloadedMethodInfo PadIsActiveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padIsActive",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padIsActive"
})
#endif
foreign import ccall "gst_pad_is_blocked" gst_pad_is_blocked ::
Ptr Pad ->
IO CInt
padIsBlocked ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsBlocked :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padIsBlocked a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_blocked Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsBlockedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadIsBlockedMethodInfo a signature where
overloadedMethod = padIsBlocked
instance O.OverloadedMethodInfo PadIsBlockedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padIsBlocked",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padIsBlocked"
})
#endif
foreign import ccall "gst_pad_is_blocking" gst_pad_is_blocking ::
Ptr Pad ->
IO CInt
padIsBlocking ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsBlocking :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padIsBlocking a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_blocking Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsBlockingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadIsBlockingMethodInfo a signature where
overloadedMethod = padIsBlocking
instance O.OverloadedMethodInfo PadIsBlockingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padIsBlocking",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padIsBlocking"
})
#endif
foreign import ccall "gst_pad_is_linked" gst_pad_is_linked ::
Ptr Pad ->
IO CInt
padIsLinked ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padIsLinked :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padIsLinked a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_is_linked Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadIsLinkedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadIsLinkedMethodInfo a signature where
overloadedMethod = padIsLinked
instance O.OverloadedMethodInfo PadIsLinkedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padIsLinked",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padIsLinked"
})
#endif
foreign import ccall "gst_pad_iterate_internal_links" gst_pad_iterate_internal_links ::
Ptr Pad ->
IO (Ptr Gst.Iterator.Iterator)
padIterateInternalLinks ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m (Maybe Gst.Iterator.Iterator)
padIterateInternalLinks :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m (Maybe Iterator)
padIterateInternalLinks a
pad = IO (Maybe Iterator) -> m (Maybe Iterator)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Iterator) -> m (Maybe Iterator))
-> IO (Maybe Iterator) -> m (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Iterator
result <- Ptr Pad -> IO (Ptr Iterator)
gst_pad_iterate_internal_links Ptr Pad
pad'
Maybe Iterator
maybeResult <- Ptr Iterator
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Iterator
result ((Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator))
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ \Ptr Iterator
result' -> do
Iterator
result'' <- ((ManagedPtr Iterator -> Iterator) -> Ptr Iterator -> IO Iterator
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Iterator -> Iterator
Gst.Iterator.Iterator) Ptr Iterator
result'
Iterator -> IO Iterator
forall (m :: * -> *) a. Monad m => a -> m a
return Iterator
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Iterator -> IO (Maybe Iterator)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Iterator
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadIterateInternalLinksMethodInfo
instance (signature ~ (m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsPad a) => O.OverloadedMethod PadIterateInternalLinksMethodInfo a signature where
overloadedMethod = padIterateInternalLinks
instance O.OverloadedMethodInfo PadIterateInternalLinksMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padIterateInternalLinks",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padIterateInternalLinks"
})
#endif
foreign import ccall "gst_pad_iterate_internal_links_default" gst_pad_iterate_internal_links_default ::
Ptr Pad ->
Ptr Gst.Object.Object ->
IO (Ptr Gst.Iterator.Iterator)
padIterateInternalLinksDefault ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) =>
a
-> Maybe (b)
-> m (Maybe Gst.Iterator.Iterator)
padIterateInternalLinksDefault :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsObject b) =>
a -> Maybe b -> m (Maybe Iterator)
padIterateInternalLinksDefault a
pad Maybe b
parent = IO (Maybe Iterator) -> m (Maybe Iterator)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Iterator) -> m (Maybe Iterator))
-> IO (Maybe Iterator) -> m (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Object
maybeParent <- case Maybe b
parent of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just b
jParent -> do
Ptr Object
jParent' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jParent'
Ptr Iterator
result <- Ptr Pad -> Ptr Object -> IO (Ptr Iterator)
gst_pad_iterate_internal_links_default Ptr Pad
pad' Ptr Object
maybeParent
Maybe Iterator
maybeResult <- Ptr Iterator
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Iterator
result ((Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator))
-> (Ptr Iterator -> IO Iterator) -> IO (Maybe Iterator)
forall a b. (a -> b) -> a -> b
$ \Ptr Iterator
result' -> do
Iterator
result'' <- ((ManagedPtr Iterator -> Iterator) -> Ptr Iterator -> IO Iterator
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Iterator -> Iterator
Gst.Iterator.Iterator) Ptr Iterator
result'
Iterator -> IO Iterator
forall (m :: * -> *) a. Monad m => a -> m a
return Iterator
result''
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe Iterator -> IO (Maybe Iterator)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Iterator
maybeResult
#if defined(ENABLE_OVERLOADING)
data PadIterateInternalLinksDefaultMethodInfo
instance (signature ~ (Maybe (b) -> m (Maybe Gst.Iterator.Iterator)), MonadIO m, IsPad a, Gst.Object.IsObject b) => O.OverloadedMethod PadIterateInternalLinksDefaultMethodInfo a signature where
overloadedMethod = padIterateInternalLinksDefault
instance O.OverloadedMethodInfo PadIterateInternalLinksDefaultMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padIterateInternalLinksDefault",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padIterateInternalLinksDefault"
})
#endif
foreign import ccall "gst_pad_link" gst_pad_link ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padLink ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Gst.Enums.PadLinkReturn
padLink :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a -> b -> m PadLinkReturn
padLink a
srcpad b
sinkpad = IO PadLinkReturn -> m PadLinkReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadLinkReturn -> m PadLinkReturn)
-> IO PadLinkReturn -> m PadLinkReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_link Ptr Pad
srcpad' Ptr Pad
sinkpad'
let result' :: PadLinkReturn
result' = (Int -> PadLinkReturn
forall a. Enum a => Int -> a
toEnum (Int -> PadLinkReturn) -> (CInt -> Int) -> CInt -> PadLinkReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
PadLinkReturn -> IO PadLinkReturn
forall (m :: * -> *) a. Monad m => a -> m a
return PadLinkReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkMethodInfo
instance (signature ~ (b -> m Gst.Enums.PadLinkReturn), MonadIO m, IsPad a, IsPad b) => O.OverloadedMethod PadLinkMethodInfo a signature where
overloadedMethod = padLink
instance O.OverloadedMethodInfo PadLinkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padLink",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padLink"
})
#endif
foreign import ccall "gst_pad_link_full" gst_pad_link_full ::
Ptr Pad ->
Ptr Pad ->
CUInt ->
IO CInt
padLinkFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> [Gst.Flags.PadLinkCheck]
-> m Gst.Enums.PadLinkReturn
padLinkFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a -> b -> [PadLinkCheck] -> m PadLinkReturn
padLinkFull a
srcpad b
sinkpad [PadLinkCheck]
flags = IO PadLinkReturn -> m PadLinkReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadLinkReturn -> m PadLinkReturn)
-> IO PadLinkReturn -> m PadLinkReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
let flags' :: CUInt
flags' = [PadLinkCheck] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadLinkCheck]
flags
CInt
result <- Ptr Pad -> Ptr Pad -> CUInt -> IO CInt
gst_pad_link_full Ptr Pad
srcpad' Ptr Pad
sinkpad' CUInt
flags'
let result' :: PadLinkReturn
result' = (Int -> PadLinkReturn
forall a. Enum a => Int -> a
toEnum (Int -> PadLinkReturn) -> (CInt -> Int) -> CInt -> PadLinkReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
PadLinkReturn -> IO PadLinkReturn
forall (m :: * -> *) a. Monad m => a -> m a
return PadLinkReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkFullMethodInfo
instance (signature ~ (b -> [Gst.Flags.PadLinkCheck] -> m Gst.Enums.PadLinkReturn), MonadIO m, IsPad a, IsPad b) => O.OverloadedMethod PadLinkFullMethodInfo a signature where
overloadedMethod = padLinkFull
instance O.OverloadedMethodInfo PadLinkFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padLinkFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padLinkFull"
})
#endif
foreign import ccall "gst_pad_link_maybe_ghosting" gst_pad_link_maybe_ghosting ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padLinkMaybeGhosting ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Bool
padLinkMaybeGhosting :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a -> b -> m Bool
padLinkMaybeGhosting a
src b
sink = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
src' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Pad
sink' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sink
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_link_maybe_ghosting Ptr Pad
src' Ptr Pad
sink'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sink
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkMaybeGhostingMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.OverloadedMethod PadLinkMaybeGhostingMethodInfo a signature where
overloadedMethod = padLinkMaybeGhosting
instance O.OverloadedMethodInfo PadLinkMaybeGhostingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padLinkMaybeGhosting",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padLinkMaybeGhosting"
})
#endif
foreign import ccall "gst_pad_link_maybe_ghosting_full" gst_pad_link_maybe_ghosting_full ::
Ptr Pad ->
Ptr Pad ->
CUInt ->
IO CInt
padLinkMaybeGhostingFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> [Gst.Flags.PadLinkCheck]
-> m Bool
padLinkMaybeGhostingFull :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a -> b -> [PadLinkCheck] -> m Bool
padLinkMaybeGhostingFull a
src b
sink [PadLinkCheck]
flags = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
src' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
src
Ptr Pad
sink' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sink
let flags' :: CUInt
flags' = [PadLinkCheck] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PadLinkCheck]
flags
CInt
result <- Ptr Pad -> Ptr Pad -> CUInt -> IO CInt
gst_pad_link_maybe_ghosting_full Ptr Pad
src' Ptr Pad
sink' CUInt
flags'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
src
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sink
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadLinkMaybeGhostingFullMethodInfo
instance (signature ~ (b -> [Gst.Flags.PadLinkCheck] -> m Bool), MonadIO m, IsPad a, IsPad b) => O.OverloadedMethod PadLinkMaybeGhostingFullMethodInfo a signature where
overloadedMethod = padLinkMaybeGhostingFull
instance O.OverloadedMethodInfo PadLinkMaybeGhostingFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padLinkMaybeGhostingFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padLinkMaybeGhostingFull"
})
#endif
foreign import ccall "gst_pad_mark_reconfigure" gst_pad_mark_reconfigure ::
Ptr Pad ->
IO ()
padMarkReconfigure ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m ()
padMarkReconfigure :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m ()
padMarkReconfigure a
pad = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> IO ()
gst_pad_mark_reconfigure Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadMarkReconfigureMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadMarkReconfigureMethodInfo a signature where
overloadedMethod = padMarkReconfigure
instance O.OverloadedMethodInfo PadMarkReconfigureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padMarkReconfigure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padMarkReconfigure"
})
#endif
foreign import ccall "gst_pad_needs_reconfigure" gst_pad_needs_reconfigure ::
Ptr Pad ->
IO CInt
padNeedsReconfigure ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padNeedsReconfigure :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padNeedsReconfigure a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_needs_reconfigure Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadNeedsReconfigureMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadNeedsReconfigureMethodInfo a signature where
overloadedMethod = padNeedsReconfigure
instance O.OverloadedMethodInfo PadNeedsReconfigureMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padNeedsReconfigure",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padNeedsReconfigure"
})
#endif
foreign import ccall "gst_pad_pause_task" gst_pad_pause_task ::
Ptr Pad ->
IO CInt
padPauseTask ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padPauseTask :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padPauseTask a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_pause_task Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadPauseTaskMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadPauseTaskMethodInfo a signature where
overloadedMethod = padPauseTask
instance O.OverloadedMethodInfo PadPauseTaskMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPauseTask",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPauseTask"
})
#endif
foreign import ccall "gst_pad_peer_query" gst_pad_peer_query ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padPeerQuery ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padPeerQuery :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Query -> m Bool
padPeerQuery a
pad Query
query = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_peer_query Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadPeerQueryMethodInfo a signature where
overloadedMethod = padPeerQuery
instance O.OverloadedMethodInfo PadPeerQueryMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPeerQuery",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPeerQuery"
})
#endif
foreign import ccall "gst_pad_peer_query_accept_caps" gst_pad_peer_query_accept_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO CInt
padPeerQueryAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Caps.Caps
-> m Bool
padPeerQueryAcceptCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Caps -> m Bool
padPeerQueryAcceptCaps a
pad Caps
caps = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
CInt
result <- Ptr Pad -> Ptr Caps -> IO CInt
gst_pad_peer_query_accept_caps Ptr Pad
pad' Ptr Caps
caps'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryAcceptCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadPeerQueryAcceptCapsMethodInfo a signature where
overloadedMethod = padPeerQueryAcceptCaps
instance O.OverloadedMethodInfo PadPeerQueryAcceptCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPeerQueryAcceptCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPeerQueryAcceptCaps"
})
#endif
foreign import ccall "gst_pad_peer_query_caps" gst_pad_peer_query_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.Caps.Caps)
padPeerQueryCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Maybe (Gst.Caps.Caps)
-> m Gst.Caps.Caps
padPeerQueryCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Maybe Caps -> m Caps
padPeerQueryCaps a
pad Maybe Caps
filter = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
maybeFilter <- case Maybe Caps
filter of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just Caps
jFilter -> do
Ptr Caps
jFilter' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jFilter
Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jFilter'
Ptr Caps
result <- Ptr Pad -> Ptr Caps -> IO (Ptr Caps)
gst_pad_peer_query_caps Ptr Pad
pad' Ptr Caps
maybeFilter
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padPeerQueryCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
filter Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryCapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsPad a) => O.OverloadedMethod PadPeerQueryCapsMethodInfo a signature where
overloadedMethod = padPeerQueryCaps
instance O.OverloadedMethodInfo PadPeerQueryCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPeerQueryCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPeerQueryCaps"
})
#endif
foreign import ccall "gst_pad_peer_query_convert" gst_pad_peer_query_convert ::
Ptr Pad ->
CUInt ->
Int64 ->
CUInt ->
Ptr Int64 ->
IO CInt
padPeerQueryConvert ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> Int64
-> Gst.Enums.Format
-> m ((Bool, Int64))
padPeerQueryConvert :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Format -> Int64 -> Format -> m (Bool, Int64)
padPeerQueryConvert a
pad Format
srcFormat Int64
srcVal Format
destFormat = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let srcFormat' :: CUInt
srcFormat' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
srcFormat
let destFormat' :: CUInt
destFormat' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
destFormat
Ptr Int64
destVal <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Pad -> CUInt -> Int64 -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_peer_query_convert Ptr Pad
pad' CUInt
srcFormat' Int64
srcVal CUInt
destFormat' Ptr Int64
destVal
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
destVal' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
destVal
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
destVal
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
destVal')
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryConvertMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.OverloadedMethod PadPeerQueryConvertMethodInfo a signature where
overloadedMethod = padPeerQueryConvert
instance O.OverloadedMethodInfo PadPeerQueryConvertMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPeerQueryConvert",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPeerQueryConvert"
})
#endif
foreign import ccall "gst_pad_peer_query_duration" gst_pad_peer_query_duration ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padPeerQueryDuration ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padPeerQueryDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Format -> m (Bool, Int64)
padPeerQueryDuration a
pad Format
format = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Int64
duration <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_peer_query_duration Ptr Pad
pad' CUInt
format' Ptr Int64
duration
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
duration' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
duration
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
duration
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
duration')
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryDurationMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.OverloadedMethod PadPeerQueryDurationMethodInfo a signature where
overloadedMethod = padPeerQueryDuration
instance O.OverloadedMethodInfo PadPeerQueryDurationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPeerQueryDuration",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPeerQueryDuration"
})
#endif
foreign import ccall "gst_pad_peer_query_position" gst_pad_peer_query_position ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padPeerQueryPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padPeerQueryPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Format -> m (Bool, Int64)
padPeerQueryPosition a
pad Format
format = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Int64
cur <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_peer_query_position Ptr Pad
pad' CUInt
format' Ptr Int64
cur
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
cur' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
cur
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
cur
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
cur')
#if defined(ENABLE_OVERLOADING)
data PadPeerQueryPositionMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.OverloadedMethod PadPeerQueryPositionMethodInfo a signature where
overloadedMethod = padPeerQueryPosition
instance O.OverloadedMethodInfo PadPeerQueryPositionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPeerQueryPosition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPeerQueryPosition"
})
#endif
foreign import ccall "gst_pad_proxy_query_accept_caps" gst_pad_proxy_query_accept_caps ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padProxyQueryAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padProxyQueryAcceptCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Query -> m Bool
padProxyQueryAcceptCaps a
pad Query
query = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_proxy_query_accept_caps Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadProxyQueryAcceptCapsMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadProxyQueryAcceptCapsMethodInfo a signature where
overloadedMethod = padProxyQueryAcceptCaps
instance O.OverloadedMethodInfo PadProxyQueryAcceptCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padProxyQueryAcceptCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padProxyQueryAcceptCaps"
})
#endif
foreign import ccall "gst_pad_proxy_query_caps" gst_pad_proxy_query_caps ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padProxyQueryCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padProxyQueryCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Query -> m Bool
padProxyQueryCaps a
pad Query
query = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_proxy_query_caps Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadProxyQueryCapsMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadProxyQueryCapsMethodInfo a signature where
overloadedMethod = padProxyQueryCaps
instance O.OverloadedMethodInfo PadProxyQueryCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padProxyQueryCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padProxyQueryCaps"
})
#endif
foreign import ccall "gst_pad_pull_range" gst_pad_pull_range ::
Ptr Pad ->
Word64 ->
Word32 ->
Ptr (Ptr Gst.Buffer.Buffer) ->
IO CInt
padPullRange ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Word64
-> Word32
-> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))
padPullRange :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Word64 -> Word32 -> m (FlowReturn, Buffer)
padPullRange a
pad Word64
offset Word32
size = IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer))
-> IO (FlowReturn, Buffer) -> m (FlowReturn, Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr (Ptr Buffer)
buffer <- IO (Ptr (Ptr Buffer))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Gst.Buffer.Buffer))
CInt
result <- Ptr Pad -> Word64 -> Word32 -> Ptr (Ptr Buffer) -> IO CInt
gst_pad_pull_range Ptr Pad
pad' Word64
offset Word32
size Ptr (Ptr Buffer)
buffer
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
Ptr Buffer
buffer' <- Ptr (Ptr Buffer) -> IO (Ptr Buffer)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Buffer)
buffer
Buffer
buffer'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Gst.Buffer.Buffer) Ptr Buffer
buffer'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr (Ptr Buffer) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Buffer)
buffer
(FlowReturn, Buffer) -> IO (FlowReturn, Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return (FlowReturn
result', Buffer
buffer'')
#if defined(ENABLE_OVERLOADING)
data PadPullRangeMethodInfo
instance (signature ~ (Word64 -> Word32 -> m ((Gst.Enums.FlowReturn, Gst.Buffer.Buffer))), MonadIO m, IsPad a) => O.OverloadedMethod PadPullRangeMethodInfo a signature where
overloadedMethod = padPullRange
instance O.OverloadedMethodInfo PadPullRangeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPullRange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPullRange"
})
#endif
foreign import ccall "gst_pad_push" gst_pad_push ::
Ptr Pad ->
Ptr Gst.Buffer.Buffer ->
IO CInt
padPush ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Buffer.Buffer
-> m Gst.Enums.FlowReturn
padPush :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Buffer -> m FlowReturn
padPush a
pad Buffer
buffer = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Buffer
buffer
CInt
result <- Ptr Pad -> Ptr Buffer -> IO CInt
gst_pad_push Ptr Pad
pad' Ptr Buffer
buffer'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadPushMethodInfo
instance (signature ~ (Gst.Buffer.Buffer -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.OverloadedMethod PadPushMethodInfo a signature where
overloadedMethod = padPush
instance O.OverloadedMethodInfo PadPushMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPush",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPush"
})
#endif
foreign import ccall "gst_pad_push_event" gst_pad_push_event ::
Ptr Pad ->
Ptr Gst.Event.Event ->
IO CInt
padPushEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Event.Event
-> m Bool
padPushEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Event -> m Bool
padPushEvent a
pad Event
event = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Event
event
CInt
result <- Ptr Pad -> Ptr Event -> IO CInt
gst_pad_push_event Ptr Pad
pad' Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadPushEventMethodInfo
instance (signature ~ (Gst.Event.Event -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadPushEventMethodInfo a signature where
overloadedMethod = padPushEvent
instance O.OverloadedMethodInfo PadPushEventMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPushEvent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPushEvent"
})
#endif
foreign import ccall "gst_pad_push_list" gst_pad_push_list ::
Ptr Pad ->
Ptr Gst.BufferList.BufferList ->
IO CInt
padPushList ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.BufferList.BufferList
-> m Gst.Enums.FlowReturn
padPushList :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> BufferList -> m FlowReturn
padPushList a
pad BufferList
list = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr BufferList
list' <- BufferList -> IO (Ptr BufferList)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed BufferList
list
CInt
result <- Ptr Pad -> Ptr BufferList -> IO CInt
gst_pad_push_list Ptr Pad
pad' Ptr BufferList
list'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
BufferList -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BufferList
list
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadPushListMethodInfo
instance (signature ~ (Gst.BufferList.BufferList -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.OverloadedMethod PadPushListMethodInfo a signature where
overloadedMethod = padPushList
instance O.OverloadedMethodInfo PadPushListMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padPushList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padPushList"
})
#endif
foreign import ccall "gst_pad_query" gst_pad_query ::
Ptr Pad ->
Ptr Gst.Query.Query ->
IO CInt
padQuery ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Query.Query
-> m Bool
padQuery :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Query -> m Bool
padQuery a
pad Query
query = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Query -> IO CInt
gst_pad_query Ptr Pad
pad' Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadQueryMethodInfo
instance (signature ~ (Gst.Query.Query -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadQueryMethodInfo a signature where
overloadedMethod = padQuery
instance O.OverloadedMethodInfo PadQueryMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padQuery",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padQuery"
})
#endif
foreign import ccall "gst_pad_query_accept_caps" gst_pad_query_accept_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO CInt
padQueryAcceptCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Caps.Caps
-> m Bool
padQueryAcceptCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Caps -> m Bool
padQueryAcceptCaps a
pad Caps
caps = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
CInt
result <- Ptr Pad -> Ptr Caps -> IO CInt
gst_pad_query_accept_caps Ptr Pad
pad' Ptr Caps
caps'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadQueryAcceptCapsMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadQueryAcceptCapsMethodInfo a signature where
overloadedMethod = padQueryAcceptCaps
instance O.OverloadedMethodInfo PadQueryAcceptCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padQueryAcceptCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padQueryAcceptCaps"
})
#endif
foreign import ccall "gst_pad_query_caps" gst_pad_query_caps ::
Ptr Pad ->
Ptr Gst.Caps.Caps ->
IO (Ptr Gst.Caps.Caps)
padQueryCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Maybe (Gst.Caps.Caps)
-> m Gst.Caps.Caps
padQueryCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Maybe Caps -> m Caps
padQueryCaps a
pad Maybe Caps
filter = IO Caps -> m Caps
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Caps
maybeFilter <- case Maybe Caps
filter of
Maybe Caps
Nothing -> Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
forall a. Ptr a
nullPtr
Just Caps
jFilter -> do
Ptr Caps
jFilter' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
jFilter
Ptr Caps -> IO (Ptr Caps)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Caps
jFilter'
Ptr Caps
result <- Ptr Pad -> Ptr Caps -> IO (Ptr Caps)
gst_pad_query_caps Ptr Pad
pad' Ptr Caps
maybeFilter
Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padQueryCaps" Ptr Caps
result
Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe Caps -> (Caps -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe Caps
filter Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Caps -> IO Caps
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'
#if defined(ENABLE_OVERLOADING)
data PadQueryCapsMethodInfo
instance (signature ~ (Maybe (Gst.Caps.Caps) -> m Gst.Caps.Caps), MonadIO m, IsPad a) => O.OverloadedMethod PadQueryCapsMethodInfo a signature where
overloadedMethod = padQueryCaps
instance O.OverloadedMethodInfo PadQueryCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padQueryCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padQueryCaps"
})
#endif
foreign import ccall "gst_pad_query_convert" gst_pad_query_convert ::
Ptr Pad ->
CUInt ->
Int64 ->
CUInt ->
Ptr Int64 ->
IO CInt
padQueryConvert ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> Int64
-> Gst.Enums.Format
-> m ((Bool, Int64))
padQueryConvert :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Format -> Int64 -> Format -> m (Bool, Int64)
padQueryConvert a
pad Format
srcFormat Int64
srcVal Format
destFormat = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let srcFormat' :: CUInt
srcFormat' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
srcFormat
let destFormat' :: CUInt
destFormat' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
destFormat
Ptr Int64
destVal <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Pad -> CUInt -> Int64 -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_query_convert Ptr Pad
pad' CUInt
srcFormat' Int64
srcVal CUInt
destFormat' Ptr Int64
destVal
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
destVal' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
destVal
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
destVal
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
destVal')
#if defined(ENABLE_OVERLOADING)
data PadQueryConvertMethodInfo
instance (signature ~ (Gst.Enums.Format -> Int64 -> Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.OverloadedMethod PadQueryConvertMethodInfo a signature where
overloadedMethod = padQueryConvert
instance O.OverloadedMethodInfo PadQueryConvertMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padQueryConvert",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padQueryConvert"
})
#endif
foreign import ccall "gst_pad_query_default" gst_pad_query_default ::
Ptr Pad ->
Ptr Gst.Object.Object ->
Ptr Gst.Query.Query ->
IO CInt
padQueryDefault ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, Gst.Object.IsObject b) =>
a
-> Maybe (b)
-> Gst.Query.Query
-> m Bool
padQueryDefault :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsObject b) =>
a -> Maybe b -> Query -> m Bool
padQueryDefault a
pad Maybe b
parent Query
query = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Object
maybeParent <- case Maybe b
parent of
Maybe b
Nothing -> Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
forall a. Ptr a
nullPtr
Just b
jParent -> do
Ptr Object
jParent' <- b -> IO (Ptr Object)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jParent
Ptr Object -> IO (Ptr Object)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Object
jParent'
Ptr Query
query' <- Query -> IO (Ptr Query)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Query
query
CInt
result <- Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt
gst_pad_query_default Ptr Pad
pad' Ptr Object
maybeParent Ptr Query
query'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
parent b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Query -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Query
query
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadQueryDefaultMethodInfo
instance (signature ~ (Maybe (b) -> Gst.Query.Query -> m Bool), MonadIO m, IsPad a, Gst.Object.IsObject b) => O.OverloadedMethod PadQueryDefaultMethodInfo a signature where
overloadedMethod = padQueryDefault
instance O.OverloadedMethodInfo PadQueryDefaultMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padQueryDefault",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padQueryDefault"
})
#endif
foreign import ccall "gst_pad_query_duration" gst_pad_query_duration ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padQueryDuration ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padQueryDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Format -> m (Bool, Int64)
padQueryDuration a
pad Format
format = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Int64
duration <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_query_duration Ptr Pad
pad' CUInt
format' Ptr Int64
duration
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
duration' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
duration
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
duration
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
duration')
#if defined(ENABLE_OVERLOADING)
data PadQueryDurationMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.OverloadedMethod PadQueryDurationMethodInfo a signature where
overloadedMethod = padQueryDuration
instance O.OverloadedMethodInfo PadQueryDurationMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padQueryDuration",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padQueryDuration"
})
#endif
foreign import ccall "gst_pad_query_position" gst_pad_query_position ::
Ptr Pad ->
CUInt ->
Ptr Int64 ->
IO CInt
padQueryPosition ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Enums.Format
-> m ((Bool, Int64))
padQueryPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Format -> m (Bool, Int64)
padQueryPosition a
pad Format
format = IO (Bool, Int64) -> m (Bool, Int64)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64) -> m (Bool, Int64))
-> IO (Bool, Int64) -> m (Bool, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Format -> Int) -> Format -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Format -> Int
forall a. Enum a => a -> Int
fromEnum) Format
format
Ptr Int64
cur <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr Pad -> CUInt -> Ptr Int64 -> IO CInt
gst_pad_query_position Ptr Pad
pad' CUInt
format' Ptr Int64
cur
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
cur' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
cur
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
cur
(Bool, Int64) -> IO (Bool, Int64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
cur')
#if defined(ENABLE_OVERLOADING)
data PadQueryPositionMethodInfo
instance (signature ~ (Gst.Enums.Format -> m ((Bool, Int64))), MonadIO m, IsPad a) => O.OverloadedMethod PadQueryPositionMethodInfo a signature where
overloadedMethod = padQueryPosition
instance O.OverloadedMethodInfo PadQueryPositionMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padQueryPosition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padQueryPosition"
})
#endif
foreign import ccall "gst_pad_remove_probe" gst_pad_remove_probe ::
Ptr Pad ->
CULong ->
IO ()
padRemoveProbe ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> CULong
-> m ()
padRemoveProbe :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> SignalHandlerId -> m ()
padRemoveProbe a
pad SignalHandlerId
id = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> SignalHandlerId -> IO ()
gst_pad_remove_probe Ptr Pad
pad' SignalHandlerId
id
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadRemoveProbeMethodInfo
instance (signature ~ (CULong -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadRemoveProbeMethodInfo a signature where
overloadedMethod = padRemoveProbe
instance O.OverloadedMethodInfo PadRemoveProbeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padRemoveProbe",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padRemoveProbe"
})
#endif
foreign import ccall "gst_pad_send_event" gst_pad_send_event ::
Ptr Pad ->
Ptr Gst.Event.Event ->
IO CInt
padSendEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Event.Event
-> m Bool
padSendEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Event -> m Bool
padSendEvent a
pad Event
event = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Event
event
CInt
result <- Ptr Pad -> Ptr Event -> IO CInt
gst_pad_send_event Ptr Pad
pad' Ptr Event
event'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadSendEventMethodInfo
instance (signature ~ (Gst.Event.Event -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadSendEventMethodInfo a signature where
overloadedMethod = padSendEvent
instance O.OverloadedMethodInfo PadSendEventMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSendEvent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSendEvent"
})
#endif
foreign import ccall "gst_pad_set_activate_function_full" gst_pad_set_activate_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadActivateFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetActivateFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadActivateFunction
-> m ()
padSetActivateFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadActivateFunction -> m ()
padSetActivateFunctionFull a
pad PadActivateFunction
activate = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadActivateFunction
activate' <- C_PadActivateFunction -> IO (FunPtr C_PadActivateFunction)
Gst.Callbacks.mk_PadActivateFunction (Maybe (Ptr (FunPtr C_PadActivateFunction))
-> PadActivateFunction -> C_PadActivateFunction
Gst.Callbacks.wrap_PadActivateFunction Maybe (Ptr (FunPtr C_PadActivateFunction))
forall a. Maybe a
Nothing PadActivateFunction
activate)
let userData :: Ptr ()
userData = FunPtr C_PadActivateFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadActivateFunction
activate'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadActivateFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_activate_function_full Ptr Pad
pad' FunPtr C_PadActivateFunction
activate' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetActivateFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadActivateFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetActivateFunctionFullMethodInfo a signature where
overloadedMethod = padSetActivateFunctionFull
instance O.OverloadedMethodInfo PadSetActivateFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetActivateFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetActivateFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_activatemode_function_full" gst_pad_set_activatemode_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadActivateModeFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetActivatemodeFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadActivateModeFunction
-> m ()
padSetActivatemodeFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadActivateModeFunction -> m ()
padSetActivatemodeFunctionFull a
pad PadActivateModeFunction
activatemode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadActivateModeFunction
activatemode' <- C_PadActivateModeFunction -> IO (FunPtr C_PadActivateModeFunction)
Gst.Callbacks.mk_PadActivateModeFunction (Maybe (Ptr (FunPtr C_PadActivateModeFunction))
-> PadActivateModeFunction -> C_PadActivateModeFunction
Gst.Callbacks.wrap_PadActivateModeFunction Maybe (Ptr (FunPtr C_PadActivateModeFunction))
forall a. Maybe a
Nothing PadActivateModeFunction
activatemode)
let userData :: Ptr ()
userData = FunPtr C_PadActivateModeFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadActivateModeFunction
activatemode'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadActivateModeFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_activatemode_function_full Ptr Pad
pad' FunPtr C_PadActivateModeFunction
activatemode' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetActivatemodeFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadActivateModeFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetActivatemodeFunctionFullMethodInfo a signature where
overloadedMethod = padSetActivatemodeFunctionFull
instance O.OverloadedMethodInfo PadSetActivatemodeFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetActivatemodeFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetActivatemodeFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_active" gst_pad_set_active ::
Ptr Pad ->
CInt ->
IO CInt
padSetActive ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Bool
-> m Bool
padSetActive :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Bool -> m Bool
padSetActive a
pad Bool
active = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
let active' :: CInt
active' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
active
CInt
result <- Ptr Pad -> CInt -> IO CInt
gst_pad_set_active Ptr Pad
pad' CInt
active'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadSetActiveMethodInfo
instance (signature ~ (Bool -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadSetActiveMethodInfo a signature where
overloadedMethod = padSetActive
instance O.OverloadedMethodInfo PadSetActiveMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetActive",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetActive"
})
#endif
foreign import ccall "gst_pad_set_chain_function_full" gst_pad_set_chain_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadChainFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetChainFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadChainFunction
-> m ()
padSetChainFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadChainFunction -> m ()
padSetChainFunctionFull a
pad PadChainFunction
chain = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadChainFunction
chain' <- C_PadChainFunction -> IO (FunPtr C_PadChainFunction)
Gst.Callbacks.mk_PadChainFunction (Maybe (Ptr (FunPtr C_PadChainFunction))
-> PadChainFunction -> C_PadChainFunction
Gst.Callbacks.wrap_PadChainFunction Maybe (Ptr (FunPtr C_PadChainFunction))
forall a. Maybe a
Nothing PadChainFunction
chain)
let userData :: Ptr ()
userData = FunPtr C_PadChainFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadChainFunction
chain'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadChainFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_chain_function_full Ptr Pad
pad' FunPtr C_PadChainFunction
chain' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetChainFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadChainFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetChainFunctionFullMethodInfo a signature where
overloadedMethod = padSetChainFunctionFull
instance O.OverloadedMethodInfo PadSetChainFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetChainFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetChainFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_chain_list_function_full" gst_pad_set_chain_list_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadChainListFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetChainListFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadChainListFunction
-> m ()
padSetChainListFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadChainListFunction -> m ()
padSetChainListFunctionFull a
pad PadChainListFunction
chainlist = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadChainListFunction
chainlist' <- C_PadChainListFunction -> IO (FunPtr C_PadChainListFunction)
Gst.Callbacks.mk_PadChainListFunction (Maybe (Ptr (FunPtr C_PadChainListFunction))
-> PadChainListFunction -> C_PadChainListFunction
Gst.Callbacks.wrap_PadChainListFunction Maybe (Ptr (FunPtr C_PadChainListFunction))
forall a. Maybe a
Nothing PadChainListFunction
chainlist)
let userData :: Ptr ()
userData = FunPtr C_PadChainListFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadChainListFunction
chainlist'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadChainListFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_chain_list_function_full Ptr Pad
pad' FunPtr C_PadChainListFunction
chainlist' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetChainListFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadChainListFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetChainListFunctionFullMethodInfo a signature where
overloadedMethod = padSetChainListFunctionFull
instance O.OverloadedMethodInfo PadSetChainListFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetChainListFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetChainListFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_element_private" gst_pad_set_element_private ::
Ptr Pad ->
Ptr () ->
IO ()
padSetElementPrivate ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Ptr ()
-> m ()
padSetElementPrivate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Ptr () -> m ()
padSetElementPrivate a
pad Ptr ()
priv = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> C_DestroyNotify
gst_pad_set_element_private Ptr Pad
pad' Ptr ()
priv
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetElementPrivateMethodInfo
instance (signature ~ (Ptr () -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetElementPrivateMethodInfo a signature where
overloadedMethod = padSetElementPrivate
instance O.OverloadedMethodInfo PadSetElementPrivateMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetElementPrivate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetElementPrivate"
})
#endif
foreign import ccall "gst_pad_set_event_full_function_full" gst_pad_set_event_full_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadEventFullFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetEventFullFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadEventFullFunction
-> m ()
padSetEventFullFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadEventFullFunction -> m ()
padSetEventFullFunctionFull a
pad PadEventFullFunction
event = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' <- (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> IO (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt))
Gst.Callbacks.mk_PadEventFullFunction (Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
-> PadEventFullFunction
-> Ptr Pad
-> Ptr Object
-> Ptr Event
-> IO CInt
Gst.Callbacks.wrap_PadEventFullFunction Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
forall a. Maybe a
Nothing PadEventFullFunction
event)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_event_full_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetEventFullFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadEventFullFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetEventFullFunctionFullMethodInfo a signature where
overloadedMethod = padSetEventFullFunctionFull
instance O.OverloadedMethodInfo PadSetEventFullFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetEventFullFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetEventFullFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_event_function_full" gst_pad_set_event_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadEventFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetEventFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadEventFunction
-> m ()
padSetEventFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadEventFunction -> m ()
padSetEventFunctionFull a
pad PadEventFunction
event = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' <- (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> IO (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt))
Gst.Callbacks.mk_PadEventFunction (Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
-> PadEventFunction
-> Ptr Pad
-> Ptr Object
-> Ptr Event
-> IO CInt
Gst.Callbacks.wrap_PadEventFunction Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)))
forall a. Maybe a
Nothing PadEventFunction
event)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_event_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> Ptr Event -> IO CInt)
event' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetEventFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadEventFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetEventFunctionFullMethodInfo a signature where
overloadedMethod = padSetEventFunctionFull
instance O.OverloadedMethodInfo PadSetEventFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetEventFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetEventFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_getrange_function_full" gst_pad_set_getrange_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadGetRangeFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetGetrangeFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadGetRangeFunction
-> m ()
padSetGetrangeFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadGetRangeFunction -> m ()
padSetGetrangeFunctionFull a
pad PadGetRangeFunction
get = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadGetRangeFunction
get' <- C_PadGetRangeFunction -> IO (FunPtr C_PadGetRangeFunction)
Gst.Callbacks.mk_PadGetRangeFunction (Maybe (Ptr (FunPtr C_PadGetRangeFunction))
-> PadGetRangeFunction -> C_PadGetRangeFunction
Gst.Callbacks.wrap_PadGetRangeFunction Maybe (Ptr (FunPtr C_PadGetRangeFunction))
forall a. Maybe a
Nothing PadGetRangeFunction
get)
let userData :: Ptr ()
userData = FunPtr C_PadGetRangeFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadGetRangeFunction
get'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadGetRangeFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_getrange_function_full Ptr Pad
pad' FunPtr C_PadGetRangeFunction
get' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetGetrangeFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadGetRangeFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetGetrangeFunctionFullMethodInfo a signature where
overloadedMethod = padSetGetrangeFunctionFull
instance O.OverloadedMethodInfo PadSetGetrangeFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetGetrangeFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetGetrangeFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_iterate_internal_links_function_full" gst_pad_set_iterate_internal_links_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadIterIntLinkFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetIterateInternalLinksFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadIterIntLinkFunction
-> m ()
padSetIterateInternalLinksFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadIterIntLinkFunction -> m ()
padSetIterateInternalLinksFunctionFull a
pad PadIterIntLinkFunction
iterintlink = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
iterintlink' <- (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
-> IO (FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator)))
Gst.Callbacks.mk_PadIterIntLinkFunction (Maybe (Ptr (FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))))
-> PadIterIntLinkFunction
-> Ptr Pad
-> Ptr Object
-> IO (Ptr Iterator)
Gst.Callbacks.wrap_PadIterIntLinkFunction Maybe (Ptr (FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))))
forall a. Maybe a
Nothing PadIterIntLinkFunction
iterintlink)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator)) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
iterintlink'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_iterate_internal_links_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> IO (Ptr Iterator))
iterintlink' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetIterateInternalLinksFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadIterIntLinkFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetIterateInternalLinksFunctionFullMethodInfo a signature where
overloadedMethod = padSetIterateInternalLinksFunctionFull
instance O.OverloadedMethodInfo PadSetIterateInternalLinksFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetIterateInternalLinksFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetIterateInternalLinksFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_link_function_full" gst_pad_set_link_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadLinkFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetLinkFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadLinkFunction
-> m ()
padSetLinkFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadLinkFunction -> m ()
padSetLinkFunctionFull a
pad PadLinkFunction
link = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadLinkFunction
link' <- C_PadLinkFunction -> IO (FunPtr C_PadLinkFunction)
Gst.Callbacks.mk_PadLinkFunction (Maybe (Ptr (FunPtr C_PadLinkFunction))
-> PadLinkFunction -> C_PadLinkFunction
Gst.Callbacks.wrap_PadLinkFunction Maybe (Ptr (FunPtr C_PadLinkFunction))
forall a. Maybe a
Nothing PadLinkFunction
link)
let userData :: Ptr ()
userData = FunPtr C_PadLinkFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadLinkFunction
link'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadLinkFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_link_function_full Ptr Pad
pad' FunPtr C_PadLinkFunction
link' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetLinkFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadLinkFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetLinkFunctionFullMethodInfo a signature where
overloadedMethod = padSetLinkFunctionFull
instance O.OverloadedMethodInfo PadSetLinkFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetLinkFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetLinkFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_offset" gst_pad_set_offset ::
Ptr Pad ->
Int64 ->
IO ()
padSetOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Int64
-> m ()
padSetOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Int64 -> m ()
padSetOffset a
pad Int64
offset = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> Int64 -> IO ()
gst_pad_set_offset Ptr Pad
pad' Int64
offset
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetOffsetMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetOffsetMethodInfo a signature where
overloadedMethod = padSetOffset
instance O.OverloadedMethodInfo PadSetOffsetMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetOffset",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetOffset"
})
#endif
foreign import ccall "gst_pad_set_query_function_full" gst_pad_set_query_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadQueryFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetQueryFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadQueryFunction
-> m ()
padSetQueryFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadQueryFunction -> m ()
padSetQueryFunctionFull a
pad PadQueryFunction
query = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
query' <- (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
-> IO (FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt))
Gst.Callbacks.mk_PadQueryFunction (Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)))
-> PadQueryFunction
-> Ptr Pad
-> Ptr Object
-> Ptr Query
-> IO CInt
Gst.Callbacks.wrap_PadQueryFunction Maybe
(Ptr (FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)))
forall a. Maybe a
Nothing PadQueryFunction
query)
let userData :: Ptr ()
userData = FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt) -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
query'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_query_function_full Ptr Pad
pad' FunPtr (Ptr Pad -> Ptr Object -> Ptr Query -> IO CInt)
query' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetQueryFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadQueryFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetQueryFunctionFullMethodInfo a signature where
overloadedMethod = padSetQueryFunctionFull
instance O.OverloadedMethodInfo PadSetQueryFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetQueryFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetQueryFunctionFull"
})
#endif
foreign import ccall "gst_pad_set_unlink_function_full" gst_pad_set_unlink_function_full ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadUnlinkFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
padSetUnlinkFunctionFull ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadUnlinkFunction
-> m ()
padSetUnlinkFunctionFull :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadUnlinkFunction -> m ()
padSetUnlinkFunctionFull a
pad PadUnlinkFunction
unlink = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadUnlinkFunction
unlink' <- C_PadUnlinkFunction -> IO (FunPtr C_PadUnlinkFunction)
Gst.Callbacks.mk_PadUnlinkFunction (Maybe (Ptr (FunPtr C_PadUnlinkFunction))
-> PadUnlinkFunction -> C_PadUnlinkFunction
Gst.Callbacks.wrap_PadUnlinkFunction Maybe (Ptr (FunPtr C_PadUnlinkFunction))
forall a. Maybe a
Nothing PadUnlinkFunction
unlink)
let userData :: Ptr ()
userData = FunPtr C_PadUnlinkFunction -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadUnlinkFunction
unlink'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
Ptr Pad
-> FunPtr C_PadUnlinkFunction
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO ()
gst_pad_set_unlink_function_full Ptr Pad
pad' FunPtr C_PadUnlinkFunction
unlink' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadSetUnlinkFunctionFullMethodInfo
instance (signature ~ (Gst.Callbacks.PadUnlinkFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadSetUnlinkFunctionFullMethodInfo a signature where
overloadedMethod = padSetUnlinkFunctionFull
instance O.OverloadedMethodInfo PadSetUnlinkFunctionFullMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padSetUnlinkFunctionFull",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padSetUnlinkFunctionFull"
})
#endif
foreign import ccall "gst_pad_start_task" gst_pad_start_task ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_TaskFunction ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO CInt
padStartTask ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.TaskFunction
-> m Bool
padStartTask :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> IO () -> m Bool
padStartTask a
pad IO ()
func = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_DestroyNotify
func' <- C_DestroyNotify -> IO (FunPtr C_DestroyNotify)
Gst.Callbacks.mk_TaskFunction (Maybe (Ptr (FunPtr C_DestroyNotify))
-> C_DestroyNotify -> C_DestroyNotify
Gst.Callbacks.wrap_TaskFunction Maybe (Ptr (FunPtr C_DestroyNotify))
forall a. Maybe a
Nothing (IO () -> C_DestroyNotify
Gst.Callbacks.drop_closures_TaskFunction IO ()
func))
let userData :: Ptr ()
userData = FunPtr C_DestroyNotify -> Ptr ()
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_DestroyNotify
func'
let notify :: FunPtr (Ptr a -> IO ())
notify = FunPtr (Ptr a -> IO ())
forall a. FunPtr (Ptr a -> IO ())
SP.safeFreeFunPtrPtr
CInt
result <- Ptr Pad
-> FunPtr C_DestroyNotify
-> Ptr ()
-> FunPtr C_DestroyNotify
-> IO CInt
gst_pad_start_task Ptr Pad
pad' FunPtr C_DestroyNotify
func' Ptr ()
userData FunPtr C_DestroyNotify
forall a. FunPtr (Ptr a -> IO ())
notify
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadStartTaskMethodInfo
instance (signature ~ (Gst.Callbacks.TaskFunction -> m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadStartTaskMethodInfo a signature where
overloadedMethod = padStartTask
instance O.OverloadedMethodInfo PadStartTaskMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padStartTask",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padStartTask"
})
#endif
foreign import ccall "gst_pad_sticky_events_foreach" gst_pad_sticky_events_foreach ::
Ptr Pad ->
FunPtr Gst.Callbacks.C_PadStickyEventsForeachFunction ->
Ptr () ->
IO ()
padStickyEventsForeach ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Callbacks.PadStickyEventsForeachFunction
-> m ()
padStickyEventsForeach :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> PadStickyEventsForeachFunction -> m ()
padStickyEventsForeach a
pad PadStickyEventsForeachFunction
foreachFunc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
FunPtr C_PadStickyEventsForeachFunction
foreachFunc' <- C_PadStickyEventsForeachFunction
-> IO (FunPtr C_PadStickyEventsForeachFunction)
Gst.Callbacks.mk_PadStickyEventsForeachFunction (Maybe (Ptr (FunPtr C_PadStickyEventsForeachFunction))
-> PadStickyEventsForeachFunction_WithClosures
-> C_PadStickyEventsForeachFunction
Gst.Callbacks.wrap_PadStickyEventsForeachFunction Maybe (Ptr (FunPtr C_PadStickyEventsForeachFunction))
forall a. Maybe a
Nothing (PadStickyEventsForeachFunction
-> PadStickyEventsForeachFunction_WithClosures
Gst.Callbacks.drop_closures_PadStickyEventsForeachFunction PadStickyEventsForeachFunction
foreachFunc))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr Pad
-> FunPtr C_PadStickyEventsForeachFunction -> C_DestroyNotify
gst_pad_sticky_events_foreach Ptr Pad
pad' FunPtr C_PadStickyEventsForeachFunction
foreachFunc' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_PadStickyEventsForeachFunction -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_PadStickyEventsForeachFunction
foreachFunc'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadStickyEventsForeachMethodInfo
instance (signature ~ (Gst.Callbacks.PadStickyEventsForeachFunction -> m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadStickyEventsForeachMethodInfo a signature where
overloadedMethod = padStickyEventsForeach
instance O.OverloadedMethodInfo PadStickyEventsForeachMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padStickyEventsForeach",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padStickyEventsForeach"
})
#endif
foreign import ccall "gst_pad_stop_task" gst_pad_stop_task ::
Ptr Pad ->
IO CInt
padStopTask ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m Bool
padStopTask :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m Bool
padStopTask a
pad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
CInt
result <- Ptr Pad -> IO CInt
gst_pad_stop_task Ptr Pad
pad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadStopTaskMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsPad a) => O.OverloadedMethod PadStopTaskMethodInfo a signature where
overloadedMethod = padStopTask
instance O.OverloadedMethodInfo PadStopTaskMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padStopTask",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padStopTask"
})
#endif
foreign import ccall "gst_pad_store_sticky_event" gst_pad_store_sticky_event ::
Ptr Pad ->
Ptr Gst.Event.Event ->
IO CInt
padStoreStickyEvent ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> Gst.Event.Event
-> m Gst.Enums.FlowReturn
padStoreStickyEvent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> Event -> m FlowReturn
padStoreStickyEvent a
pad Event
event = IO FlowReturn -> m FlowReturn
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FlowReturn -> m FlowReturn) -> IO FlowReturn -> m FlowReturn
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Event
event' <- Event -> IO (Ptr Event)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Event
event
CInt
result <- Ptr Pad -> Ptr Event -> IO CInt
gst_pad_store_sticky_event Ptr Pad
pad' Ptr Event
event'
let result' :: FlowReturn
result' = (Int -> FlowReturn
forall a. Enum a => Int -> a
toEnum (Int -> FlowReturn) -> (CInt -> Int) -> CInt -> FlowReturn
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
Event -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Event
event
FlowReturn -> IO FlowReturn
forall (m :: * -> *) a. Monad m => a -> m a
return FlowReturn
result'
#if defined(ENABLE_OVERLOADING)
data PadStoreStickyEventMethodInfo
instance (signature ~ (Gst.Event.Event -> m Gst.Enums.FlowReturn), MonadIO m, IsPad a) => O.OverloadedMethod PadStoreStickyEventMethodInfo a signature where
overloadedMethod = padStoreStickyEvent
instance O.OverloadedMethodInfo PadStoreStickyEventMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padStoreStickyEvent",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padStoreStickyEvent"
})
#endif
foreign import ccall "gst_pad_unlink" gst_pad_unlink ::
Ptr Pad ->
Ptr Pad ->
IO CInt
padUnlink ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a
-> b
-> m Bool
padUnlink :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPad a, IsPad b) =>
a -> b -> m Bool
padUnlink a
srcpad b
sinkpad = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
srcpad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
srcpad
Ptr Pad
sinkpad' <- b -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
sinkpad
CInt
result <- Ptr Pad -> Ptr Pad -> IO CInt
gst_pad_unlink Ptr Pad
srcpad' Ptr Pad
sinkpad'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
srcpad
b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
sinkpad
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data PadUnlinkMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPad a, IsPad b) => O.OverloadedMethod PadUnlinkMethodInfo a signature where
overloadedMethod = padUnlink
instance O.OverloadedMethodInfo PadUnlinkMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padUnlink",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padUnlink"
})
#endif
foreign import ccall "gst_pad_use_fixed_caps" gst_pad_use_fixed_caps ::
Ptr Pad ->
IO ()
padUseFixedCaps ::
(B.CallStack.HasCallStack, MonadIO m, IsPad a) =>
a
-> m ()
padUseFixedCaps :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPad a) =>
a -> m ()
padUseFixedCaps a
pad = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr Pad
pad' <- a -> IO (Ptr Pad)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pad
Ptr Pad -> IO ()
gst_pad_use_fixed_caps Ptr Pad
pad'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pad
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data PadUseFixedCapsMethodInfo
instance (signature ~ (m ()), MonadIO m, IsPad a) => O.OverloadedMethod PadUseFixedCapsMethodInfo a signature where
overloadedMethod = padUseFixedCaps
instance O.OverloadedMethodInfo PadUseFixedCapsMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gst.Objects.Pad.padUseFixedCaps",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.25/docs/GI-Gst-Objects-Pad.html#v:padUseFixedCaps"
})
#endif
foreign import ccall "gst_pad_link_get_name" gst_pad_link_get_name ::
CInt ->
IO CString
padLinkGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
Gst.Enums.PadLinkReturn
-> m T.Text
padLinkGetName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
PadLinkReturn -> m Text
padLinkGetName PadLinkReturn
ret = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let ret' :: CInt
ret' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (PadLinkReturn -> Int) -> PadLinkReturn -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadLinkReturn -> Int
forall a. Enum a => a -> Int
fromEnum) PadLinkReturn
ret
Ptr CChar
result <- CInt -> IO (Ptr CChar)
gst_pad_link_get_name CInt
ret'
Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"padLinkGetName" Ptr CChar
result
Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
#endif