{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.GES.Objects.Pipeline.Pipeline' can take an audio-video t'GI.GES.Objects.Timeline.Timeline' and conveniently
-- link its t'GI.GES.Objects.Track.Track'-s to an internal @/playsink/@ element, for
-- preview\/playback, and an internal @/encodebin/@ element, for rendering.
-- You can switch between these modes using 'GI.GES.Objects.Pipeline.pipelineSetMode'.
-- 
-- You can choose the specific audio and video sinks used for previewing
-- the timeline by setting the [Pipeline:audioSink]("GI.GES.Objects.Pipeline#g:attr:audioSink") and
-- [Pipeline:videoSink]("GI.GES.Objects.Pipeline#g:attr:videoSink") properties.
-- 
-- You can set the encoding and save location used in rendering by calling
-- 'GI.GES.Objects.Pipeline.pipelineSetRenderSettings'.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GES.Objects.Pipeline
    ( 

-- * Exported types
    Pipeline(..)                            ,
    IsPipeline                              ,
    toPipeline                              ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [abortState]("GI.Gst.Objects.Element#g:method:abortState"), [add]("GI.Gst.Objects.Bin#g:method:add"), [addControlBinding]("GI.Gst.Objects.Object#g:method:addControlBinding"), [addPad]("GI.Gst.Objects.Element#g:method:addPad"), [addPropertyDeepNotifyWatch]("GI.Gst.Objects.Element#g:method:addPropertyDeepNotifyWatch"), [addPropertyNotifyWatch]("GI.Gst.Objects.Element#g:method:addPropertyNotifyWatch"), [autoClock]("GI.Gst.Objects.Pipeline#g:method:autoClock"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [callAsync]("GI.Gst.Objects.Element#g:method:callAsync"), [changeState]("GI.Gst.Objects.Element#g:method:changeState"), [childAdded]("GI.Gst.Interfaces.ChildProxy#g:method:childAdded"), [childRemoved]("GI.Gst.Interfaces.ChildProxy#g:method:childRemoved"), [continueState]("GI.Gst.Objects.Element#g:method:continueState"), [createAllPads]("GI.Gst.Objects.Element#g:method:createAllPads"), [defaultError]("GI.Gst.Objects.Object#g:method:defaultError"), [expose]("GI.GstVideo.Interfaces.VideoOverlay#g:method:expose"), [findUnlinkedPad]("GI.Gst.Objects.Bin#g:method:findUnlinkedPad"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreachPad]("GI.Gst.Objects.Element#g:method:foreachPad"), [foreachSinkPad]("GI.Gst.Objects.Element#g:method:foreachSinkPad"), [foreachSrcPad]("GI.Gst.Objects.Element#g:method:foreachSrcPad"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [gotWindowHandle]("GI.GstVideo.Interfaces.VideoOverlay#g:method:gotWindowHandle"), [handleEvents]("GI.GstVideo.Interfaces.VideoOverlay#g:method:handleEvents"), [hasActiveControlBindings]("GI.Gst.Objects.Object#g:method:hasActiveControlBindings"), [hasAncestor]("GI.Gst.Objects.Object#g:method:hasAncestor"), [hasAsAncestor]("GI.Gst.Objects.Object#g:method:hasAsAncestor"), [hasAsParent]("GI.Gst.Objects.Object#g:method:hasAsParent"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isLockedState]("GI.Gst.Objects.Element#g:method:isLockedState"), [iterateAllByElementFactoryName]("GI.Gst.Objects.Bin#g:method:iterateAllByElementFactoryName"), [iterateAllByInterface]("GI.Gst.Objects.Bin#g:method:iterateAllByInterface"), [iterateElements]("GI.Gst.Objects.Bin#g:method:iterateElements"), [iteratePads]("GI.Gst.Objects.Element#g:method:iteratePads"), [iterateRecurse]("GI.Gst.Objects.Bin#g:method:iterateRecurse"), [iterateSinkPads]("GI.Gst.Objects.Element#g:method:iterateSinkPads"), [iterateSinks]("GI.Gst.Objects.Bin#g:method:iterateSinks"), [iterateSorted]("GI.Gst.Objects.Bin#g:method:iterateSorted"), [iterateSources]("GI.Gst.Objects.Bin#g:method:iterateSources"), [iterateSrcPads]("GI.Gst.Objects.Element#g:method:iterateSrcPads"), [link]("GI.Gst.Objects.Element#g:method:link"), [linkFiltered]("GI.Gst.Objects.Element#g:method:linkFiltered"), [linkPads]("GI.Gst.Objects.Element#g:method:linkPads"), [linkPadsFiltered]("GI.Gst.Objects.Element#g:method:linkPadsFiltered"), [linkPadsFull]("GI.Gst.Objects.Element#g:method:linkPadsFull"), [lookup]("GI.Gst.Interfaces.ChildProxy#g:method:lookup"), [lostState]("GI.Gst.Objects.Element#g:method:lostState"), [messageFull]("GI.Gst.Objects.Element#g:method:messageFull"), [messageFullWithDetails]("GI.Gst.Objects.Element#g:method:messageFullWithDetails"), [noMorePads]("GI.Gst.Objects.Element#g:method:noMorePads"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [postMessage]("GI.Gst.Objects.Element#g:method:postMessage"), [prepareWindowHandle]("GI.GstVideo.Interfaces.VideoOverlay#g:method:prepareWindowHandle"), [previewGetAudioSink]("GI.GES.Objects.Pipeline#g:method:previewGetAudioSink"), [previewGetVideoSink]("GI.GES.Objects.Pipeline#g:method:previewGetVideoSink"), [previewSetAudioSink]("GI.GES.Objects.Pipeline#g:method:previewSetAudioSink"), [previewSetVideoSink]("GI.GES.Objects.Pipeline#g:method:previewSetVideoSink"), [provideClock]("GI.Gst.Objects.Element#g:method:provideClock"), [query]("GI.Gst.Objects.Element#g:method:query"), [queryConvert]("GI.Gst.Objects.Element#g:method:queryConvert"), [queryDuration]("GI.Gst.Objects.Element#g:method:queryDuration"), [queryPosition]("GI.Gst.Objects.Element#g:method:queryPosition"), [recalculateLatency]("GI.Gst.Objects.Bin#g:method:recalculateLatency"), [ref]("GI.Gst.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [releaseRequestPad]("GI.Gst.Objects.Element#g:method:releaseRequestPad"), [remove]("GI.Gst.Objects.Bin#g:method:remove"), [removeControlBinding]("GI.Gst.Objects.Object#g:method:removeControlBinding"), [removePad]("GI.Gst.Objects.Element#g:method:removePad"), [removePropertyNotifyWatch]("GI.Gst.Objects.Element#g:method:removePropertyNotifyWatch"), [requestPad]("GI.Gst.Objects.Element#g:method:requestPad"), [requestPadSimple]("GI.Gst.Objects.Element#g:method:requestPadSimple"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [saveThumbnail]("GI.GES.Objects.Pipeline#g:method:saveThumbnail"), [seek]("GI.Gst.Objects.Element#g:method:seek"), [seekSimple]("GI.Gst.Objects.Element#g:method:seekSimple"), [sendEvent]("GI.Gst.Objects.Element#g:method:sendEvent"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [suggestNextSync]("GI.Gst.Objects.Object#g:method:suggestNextSync"), [syncChildrenStates]("GI.Gst.Objects.Bin#g:method:syncChildrenStates"), [syncStateWithParent]("GI.Gst.Objects.Element#g:method:syncStateWithParent"), [syncValues]("GI.Gst.Objects.Object#g:method:syncValues"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unlink]("GI.Gst.Objects.Element#g:method:unlink"), [unlinkPads]("GI.Gst.Objects.Element#g:method:unlinkPads"), [unparent]("GI.Gst.Objects.Object#g:method:unparent"), [unref]("GI.Gst.Objects.Object#g:method:unref"), [useClock]("GI.Gst.Objects.Pipeline#g:method:useClock"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAutoFlushBus]("GI.Gst.Objects.Pipeline#g:method:getAutoFlushBus"), [getBaseTime]("GI.Gst.Objects.Element#g:method:getBaseTime"), [getBus]("GI.Gst.Objects.Pipeline#g:method:getBus"), [getByInterface]("GI.Gst.Objects.Bin#g:method:getByInterface"), [getByName]("GI.Gst.Objects.Bin#g:method:getByName"), [getByNameRecurseUp]("GI.Gst.Objects.Bin#g:method:getByNameRecurseUp"), [getChildByIndex]("GI.Gst.Interfaces.ChildProxy#g:method:getChildByIndex"), [getChildByName]("GI.Gst.Interfaces.ChildProxy#g:method:getChildByName"), [getChildByNameRecurse]("GI.Gst.Interfaces.ChildProxy#g:method:getChildByNameRecurse"), [getChildrenCount]("GI.Gst.Interfaces.ChildProxy#g:method:getChildrenCount"), [getClock]("GI.Gst.Objects.Element#g:method:getClock"), [getCompatiblePad]("GI.Gst.Objects.Element#g:method:getCompatiblePad"), [getCompatiblePadTemplate]("GI.Gst.Objects.Element#g:method:getCompatiblePadTemplate"), [getContext]("GI.Gst.Objects.Element#g:method:getContext"), [getContextUnlocked]("GI.Gst.Objects.Element#g:method:getContextUnlocked"), [getContexts]("GI.Gst.Objects.Element#g:method:getContexts"), [getControlBinding]("GI.Gst.Objects.Object#g:method:getControlBinding"), [getControlRate]("GI.Gst.Objects.Object#g:method:getControlRate"), [getCurrentClockTime]("GI.Gst.Objects.Element#g:method:getCurrentClockTime"), [getCurrentRunningTime]("GI.Gst.Objects.Element#g:method:getCurrentRunningTime"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDelay]("GI.Gst.Objects.Pipeline#g:method:getDelay"), [getFactory]("GI.Gst.Objects.Element#g:method:getFactory"), [getGValueArray]("GI.Gst.Objects.Object#g:method:getGValueArray"), [getLatency]("GI.Gst.Objects.Pipeline#g:method:getLatency"), [getMetadata]("GI.Gst.Objects.Element#g:method:getMetadata"), [getMode]("GI.GES.Objects.Pipeline#g:method:getMode"), [getName]("GI.Gst.Objects.Object#g:method:getName"), [getPadTemplate]("GI.Gst.Objects.Element#g:method:getPadTemplate"), [getPadTemplateList]("GI.Gst.Objects.Element#g:method:getPadTemplateList"), [getParent]("GI.Gst.Objects.Object#g:method:getParent"), [getPathString]("GI.Gst.Objects.Object#g:method:getPathString"), [getPipelineClock]("GI.Gst.Objects.Pipeline#g:method:getPipelineClock"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRequestPad]("GI.Gst.Objects.Element#g:method:getRequestPad"), [getStartTime]("GI.Gst.Objects.Element#g:method:getStartTime"), [getState]("GI.Gst.Objects.Element#g:method:getState"), [getStaticPad]("GI.Gst.Objects.Element#g:method:getStaticPad"), [getSuppressedFlags]("GI.Gst.Objects.Bin#g:method:getSuppressedFlags"), [getThumbnail]("GI.GES.Objects.Pipeline#g:method:getThumbnail"), [getThumbnailRgb24]("GI.GES.Objects.Pipeline#g:method:getThumbnailRgb24"), [getValue]("GI.Gst.Objects.Object#g:method:getValue").
-- 
-- ==== Setters
-- [setAutoFlushBus]("GI.Gst.Objects.Pipeline#g:method:setAutoFlushBus"), [setBaseTime]("GI.Gst.Objects.Element#g:method:setBaseTime"), [setBus]("GI.Gst.Objects.Element#g:method:setBus"), [setClock]("GI.Gst.Objects.Element#g:method:setClock"), [setContext]("GI.Gst.Objects.Element#g:method:setContext"), [setControlBindingDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingDisabled"), [setControlBindingsDisabled]("GI.Gst.Objects.Object#g:method:setControlBindingsDisabled"), [setControlRate]("GI.Gst.Objects.Object#g:method:setControlRate"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDelay]("GI.Gst.Objects.Pipeline#g:method:setDelay"), [setLatency]("GI.Gst.Objects.Pipeline#g:method:setLatency"), [setLockedState]("GI.Gst.Objects.Element#g:method:setLockedState"), [setMode]("GI.GES.Objects.Pipeline#g:method:setMode"), [setName]("GI.Gst.Objects.Object#g:method:setName"), [setParent]("GI.Gst.Objects.Object#g:method:setParent"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRenderRectangle]("GI.GstVideo.Interfaces.VideoOverlay#g:method:setRenderRectangle"), [setRenderSettings]("GI.GES.Objects.Pipeline#g:method:setRenderSettings"), [setStartTime]("GI.Gst.Objects.Element#g:method:setStartTime"), [setState]("GI.Gst.Objects.Element#g:method:setState"), [setSuppressedFlags]("GI.Gst.Objects.Bin#g:method:setSuppressedFlags"), [setTimeline]("GI.GES.Objects.Pipeline#g:method:setTimeline"), [setWindowHandle]("GI.GstVideo.Interfaces.VideoOverlay#g:method:setWindowHandle").

#if defined(ENABLE_OVERLOADING)
    ResolvePipelineMethod                   ,
#endif

-- ** getMode #method:getMode#

#if defined(ENABLE_OVERLOADING)
    PipelineGetModeMethodInfo               ,
#endif
    pipelineGetMode                         ,


-- ** getThumbnail #method:getThumbnail#

#if defined(ENABLE_OVERLOADING)
    PipelineGetThumbnailMethodInfo          ,
#endif
    pipelineGetThumbnail                    ,


-- ** getThumbnailRgb24 #method:getThumbnailRgb24#

#if defined(ENABLE_OVERLOADING)
    PipelineGetThumbnailRgb24MethodInfo     ,
#endif
    pipelineGetThumbnailRgb24               ,


-- ** new #method:new#

    pipelineNew                             ,


-- ** previewGetAudioSink #method:previewGetAudioSink#

#if defined(ENABLE_OVERLOADING)
    PipelinePreviewGetAudioSinkMethodInfo   ,
#endif
    pipelinePreviewGetAudioSink             ,


-- ** previewGetVideoSink #method:previewGetVideoSink#

#if defined(ENABLE_OVERLOADING)
    PipelinePreviewGetVideoSinkMethodInfo   ,
#endif
    pipelinePreviewGetVideoSink             ,


-- ** previewSetAudioSink #method:previewSetAudioSink#

#if defined(ENABLE_OVERLOADING)
    PipelinePreviewSetAudioSinkMethodInfo   ,
#endif
    pipelinePreviewSetAudioSink             ,


-- ** previewSetVideoSink #method:previewSetVideoSink#

#if defined(ENABLE_OVERLOADING)
    PipelinePreviewSetVideoSinkMethodInfo   ,
#endif
    pipelinePreviewSetVideoSink             ,


-- ** saveThumbnail #method:saveThumbnail#

#if defined(ENABLE_OVERLOADING)
    PipelineSaveThumbnailMethodInfo         ,
#endif
    pipelineSaveThumbnail                   ,


-- ** setMode #method:setMode#

#if defined(ENABLE_OVERLOADING)
    PipelineSetModeMethodInfo               ,
#endif
    pipelineSetMode                         ,


-- ** setRenderSettings #method:setRenderSettings#

#if defined(ENABLE_OVERLOADING)
    PipelineSetRenderSettingsMethodInfo     ,
#endif
    pipelineSetRenderSettings               ,


-- ** setTimeline #method:setTimeline#

#if defined(ENABLE_OVERLOADING)
    PipelineSetTimelineMethodInfo           ,
#endif
    pipelineSetTimeline                     ,




 -- * Properties


-- ** audioFilter #attr:audioFilter#
-- | The audio filter(s) to apply during playback in preview mode,
-- immediately before the [Pipeline:audioSink]("GI.GES.Objects.Pipeline#g:attr:audioSink"). This exposes the
-- @/playsink:audio-filter/@ property of the internal @/playsink/@.
-- 
-- /Since: 1.6.0/

#if defined(ENABLE_OVERLOADING)
    PipelineAudioFilterPropertyInfo         ,
#endif
    clearPipelineAudioFilter                ,
    constructPipelineAudioFilter            ,
    getPipelineAudioFilter                  ,
#if defined(ENABLE_OVERLOADING)
    pipelineAudioFilter                     ,
#endif
    setPipelineAudioFilter                  ,


-- ** audioSink #attr:audioSink#
-- | The audio sink used for preview. This exposes the
-- @/playsink:audio-sink/@ property of the internal @/playsink/@.

#if defined(ENABLE_OVERLOADING)
    PipelineAudioSinkPropertyInfo           ,
#endif
    clearPipelineAudioSink                  ,
    constructPipelineAudioSink              ,
    getPipelineAudioSink                    ,
#if defined(ENABLE_OVERLOADING)
    pipelineAudioSink                       ,
#endif
    setPipelineAudioSink                    ,


-- ** mode #attr:mode#
-- | The pipeline\'s mode. In preview mode (for audio or video, or both)
-- the pipeline can display the timeline\'s content to an end user. In
-- rendering mode the pipeline can encode the timeline\'s content and
-- save it to a file.

#if defined(ENABLE_OVERLOADING)
    PipelineModePropertyInfo                ,
#endif
    constructPipelineMode                   ,
    getPipelineMode                         ,
#if defined(ENABLE_OVERLOADING)
    pipelineMode                            ,
#endif
    setPipelineMode                         ,


-- ** timeline #attr:timeline#
-- | The timeline used by this pipeline, whose content it will play and
-- render, or 'P.Nothing' if the pipeline does not yet have a timeline.
-- 
-- Note that after you set the timeline for the first time, subsequent
-- calls to change the timeline will fail.

#if defined(ENABLE_OVERLOADING)
    PipelineTimelinePropertyInfo            ,
#endif
    clearPipelineTimeline                   ,
    constructPipelineTimeline               ,
    getPipelineTimeline                     ,
#if defined(ENABLE_OVERLOADING)
    pipelineTimeline                        ,
#endif
    setPipelineTimeline                     ,


-- ** videoFilter #attr:videoFilter#
-- | The video filter(s) to apply during playback in preview mode,
-- immediately before the [Pipeline:videoSink]("GI.GES.Objects.Pipeline#g:attr:videoSink"). This exposes the
-- @/playsink:video-filter/@ property of the internal @/playsink/@.
-- 
-- /Since: 1.6.0/

#if defined(ENABLE_OVERLOADING)
    PipelineVideoFilterPropertyInfo         ,
#endif
    clearPipelineVideoFilter                ,
    constructPipelineVideoFilter            ,
    getPipelineVideoFilter                  ,
#if defined(ENABLE_OVERLOADING)
    pipelineVideoFilter                     ,
#endif
    setPipelineVideoFilter                  ,


-- ** videoSink #attr:videoSink#
-- | The video sink used for preview. This exposes the
-- @/playsink:video-sink/@ property of the internal @/playsink/@.

#if defined(ENABLE_OVERLOADING)
    PipelineVideoSinkPropertyInfo           ,
#endif
    clearPipelineVideoSink                  ,
    constructPipelineVideoSink              ,
    getPipelineVideoSink                    ,
#if defined(ENABLE_OVERLOADING)
    pipelineVideoSink                       ,
#endif
    setPipelineVideoSink                    ,




    ) 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.GHashTable as B.GHT
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.Kind as DK
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 {-# SOURCE #-} qualified GI.GES.Flags as GES.Flags
import {-# SOURCE #-} qualified GI.GES.Objects.Timeline as GES.Timeline
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Interfaces.ChildProxy as Gst.ChildProxy
import qualified GI.Gst.Objects.Bin as Gst.Bin
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Objects.Pipeline as Gst.Pipeline
import qualified GI.Gst.Structs.Caps as Gst.Caps
import qualified GI.Gst.Structs.Sample as Gst.Sample
import qualified GI.GstPbutils.Objects.EncodingProfile as GstPbutils.EncodingProfile
import qualified GI.GstVideo.Interfaces.VideoOverlay as GstVideo.VideoOverlay

-- | Memory-managed wrapper type.
newtype Pipeline = Pipeline (SP.ManagedPtr Pipeline)
    deriving (Pipeline -> Pipeline -> Bool
(Pipeline -> Pipeline -> Bool)
-> (Pipeline -> Pipeline -> Bool) -> Eq Pipeline
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pipeline -> Pipeline -> Bool
== :: Pipeline -> Pipeline -> Bool
$c/= :: Pipeline -> Pipeline -> Bool
/= :: Pipeline -> Pipeline -> Bool
Eq)

instance SP.ManagedPtrNewtype Pipeline where
    toManagedPtr :: Pipeline -> ManagedPtr Pipeline
toManagedPtr (Pipeline ManagedPtr Pipeline
p) = ManagedPtr Pipeline
p

foreign import ccall "ges_pipeline_get_type"
    c_ges_pipeline_get_type :: IO B.Types.GType

instance B.Types.TypedObject Pipeline where
    glibType :: IO GType
glibType = IO GType
c_ges_pipeline_get_type

instance B.Types.GObject Pipeline

-- | Type class for types which can be safely cast to `Pipeline`, for instance with `toPipeline`.
class (SP.GObject o, O.IsDescendantOf Pipeline o) => IsPipeline o
instance (SP.GObject o, O.IsDescendantOf Pipeline o) => IsPipeline o

instance O.HasParentTypes Pipeline
type instance O.ParentTypes Pipeline = '[Gst.Pipeline.Pipeline, Gst.Bin.Bin, Gst.Element.Element, Gst.Object.Object, GObject.Object.Object, Gst.ChildProxy.ChildProxy, GstVideo.VideoOverlay.VideoOverlay]

-- | Cast to `Pipeline`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toPipeline :: (MIO.MonadIO m, IsPipeline o) => o -> m Pipeline
toPipeline :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> m Pipeline
toPipeline = IO Pipeline -> m Pipeline
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Pipeline -> m Pipeline)
-> (o -> IO Pipeline) -> o -> m Pipeline
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Pipeline -> Pipeline) -> o -> IO Pipeline
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Pipeline -> Pipeline
Pipeline

-- | Convert 'Pipeline' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Pipeline) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ges_pipeline_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Pipeline -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Pipeline
P.Nothing = Ptr GValue -> Ptr Pipeline -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Pipeline
forall a. Ptr a
FP.nullPtr :: FP.Ptr Pipeline)
    gvalueSet_ Ptr GValue
gv (P.Just Pipeline
obj) = Pipeline -> (Ptr Pipeline -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Pipeline
obj (Ptr GValue -> Ptr Pipeline -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Pipeline)
gvalueGet_ Ptr GValue
gv = do
        Ptr Pipeline
ptr <- Ptr GValue -> IO (Ptr Pipeline)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Pipeline)
        if Ptr Pipeline
ptr Ptr Pipeline -> Ptr Pipeline -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Pipeline
forall a. Ptr a
FP.nullPtr
        then Pipeline -> Maybe Pipeline
forall a. a -> Maybe a
P.Just (Pipeline -> Maybe Pipeline) -> IO Pipeline -> IO (Maybe Pipeline)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Pipeline -> Pipeline) -> Ptr Pipeline -> IO Pipeline
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Pipeline -> Pipeline
Pipeline Ptr Pipeline
ptr
        else Maybe Pipeline -> IO (Maybe Pipeline)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Pipeline
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolvePipelineMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolvePipelineMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo
    ResolvePipelineMethod "add" o = Gst.Bin.BinAddMethodInfo
    ResolvePipelineMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolvePipelineMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo
    ResolvePipelineMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo
    ResolvePipelineMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo
    ResolvePipelineMethod "autoClock" o = Gst.Pipeline.PipelineAutoClockMethodInfo
    ResolvePipelineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolvePipelineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolvePipelineMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo
    ResolvePipelineMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo
    ResolvePipelineMethod "childAdded" o = Gst.ChildProxy.ChildProxyChildAddedMethodInfo
    ResolvePipelineMethod "childRemoved" o = Gst.ChildProxy.ChildProxyChildRemovedMethodInfo
    ResolvePipelineMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo
    ResolvePipelineMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo
    ResolvePipelineMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolvePipelineMethod "expose" o = GstVideo.VideoOverlay.VideoOverlayExposeMethodInfo
    ResolvePipelineMethod "findUnlinkedPad" o = Gst.Bin.BinFindUnlinkedPadMethodInfo
    ResolvePipelineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolvePipelineMethod "foreachPad" o = Gst.Element.ElementForeachPadMethodInfo
    ResolvePipelineMethod "foreachSinkPad" o = Gst.Element.ElementForeachSinkPadMethodInfo
    ResolvePipelineMethod "foreachSrcPad" o = Gst.Element.ElementForeachSrcPadMethodInfo
    ResolvePipelineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolvePipelineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolvePipelineMethod "gotWindowHandle" o = GstVideo.VideoOverlay.VideoOverlayGotWindowHandleMethodInfo
    ResolvePipelineMethod "handleEvents" o = GstVideo.VideoOverlay.VideoOverlayHandleEventsMethodInfo
    ResolvePipelineMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolvePipelineMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolvePipelineMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolvePipelineMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolvePipelineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolvePipelineMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo
    ResolvePipelineMethod "iterateAllByElementFactoryName" o = Gst.Bin.BinIterateAllByElementFactoryNameMethodInfo
    ResolvePipelineMethod "iterateAllByInterface" o = Gst.Bin.BinIterateAllByInterfaceMethodInfo
    ResolvePipelineMethod "iterateElements" o = Gst.Bin.BinIterateElementsMethodInfo
    ResolvePipelineMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo
    ResolvePipelineMethod "iterateRecurse" o = Gst.Bin.BinIterateRecurseMethodInfo
    ResolvePipelineMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo
    ResolvePipelineMethod "iterateSinks" o = Gst.Bin.BinIterateSinksMethodInfo
    ResolvePipelineMethod "iterateSorted" o = Gst.Bin.BinIterateSortedMethodInfo
    ResolvePipelineMethod "iterateSources" o = Gst.Bin.BinIterateSourcesMethodInfo
    ResolvePipelineMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo
    ResolvePipelineMethod "link" o = Gst.Element.ElementLinkMethodInfo
    ResolvePipelineMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo
    ResolvePipelineMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo
    ResolvePipelineMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo
    ResolvePipelineMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo
    ResolvePipelineMethod "lookup" o = Gst.ChildProxy.ChildProxyLookupMethodInfo
    ResolvePipelineMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo
    ResolvePipelineMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo
    ResolvePipelineMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo
    ResolvePipelineMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo
    ResolvePipelineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolvePipelineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolvePipelineMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo
    ResolvePipelineMethod "prepareWindowHandle" o = GstVideo.VideoOverlay.VideoOverlayPrepareWindowHandleMethodInfo
    ResolvePipelineMethod "previewGetAudioSink" o = PipelinePreviewGetAudioSinkMethodInfo
    ResolvePipelineMethod "previewGetVideoSink" o = PipelinePreviewGetVideoSinkMethodInfo
    ResolvePipelineMethod "previewSetAudioSink" o = PipelinePreviewSetAudioSinkMethodInfo
    ResolvePipelineMethod "previewSetVideoSink" o = PipelinePreviewSetVideoSinkMethodInfo
    ResolvePipelineMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo
    ResolvePipelineMethod "query" o = Gst.Element.ElementQueryMethodInfo
    ResolvePipelineMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo
    ResolvePipelineMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo
    ResolvePipelineMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo
    ResolvePipelineMethod "recalculateLatency" o = Gst.Bin.BinRecalculateLatencyMethodInfo
    ResolvePipelineMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolvePipelineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolvePipelineMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo
    ResolvePipelineMethod "remove" o = Gst.Bin.BinRemoveMethodInfo
    ResolvePipelineMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolvePipelineMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo
    ResolvePipelineMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo
    ResolvePipelineMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo
    ResolvePipelineMethod "requestPadSimple" o = Gst.Element.ElementRequestPadSimpleMethodInfo
    ResolvePipelineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolvePipelineMethod "saveThumbnail" o = PipelineSaveThumbnailMethodInfo
    ResolvePipelineMethod "seek" o = Gst.Element.ElementSeekMethodInfo
    ResolvePipelineMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo
    ResolvePipelineMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo
    ResolvePipelineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolvePipelineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolvePipelineMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolvePipelineMethod "syncChildrenStates" o = Gst.Bin.BinSyncChildrenStatesMethodInfo
    ResolvePipelineMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo
    ResolvePipelineMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolvePipelineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolvePipelineMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo
    ResolvePipelineMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo
    ResolvePipelineMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolvePipelineMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolvePipelineMethod "useClock" o = Gst.Pipeline.PipelineUseClockMethodInfo
    ResolvePipelineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolvePipelineMethod "getAutoFlushBus" o = Gst.Pipeline.PipelineGetAutoFlushBusMethodInfo
    ResolvePipelineMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo
    ResolvePipelineMethod "getBus" o = Gst.Pipeline.PipelineGetBusMethodInfo
    ResolvePipelineMethod "getByInterface" o = Gst.Bin.BinGetByInterfaceMethodInfo
    ResolvePipelineMethod "getByName" o = Gst.Bin.BinGetByNameMethodInfo
    ResolvePipelineMethod "getByNameRecurseUp" o = Gst.Bin.BinGetByNameRecurseUpMethodInfo
    ResolvePipelineMethod "getChildByIndex" o = Gst.ChildProxy.ChildProxyGetChildByIndexMethodInfo
    ResolvePipelineMethod "getChildByName" o = Gst.ChildProxy.ChildProxyGetChildByNameMethodInfo
    ResolvePipelineMethod "getChildByNameRecurse" o = Gst.ChildProxy.ChildProxyGetChildByNameRecurseMethodInfo
    ResolvePipelineMethod "getChildrenCount" o = Gst.ChildProxy.ChildProxyGetChildrenCountMethodInfo
    ResolvePipelineMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo
    ResolvePipelineMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo
    ResolvePipelineMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo
    ResolvePipelineMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo
    ResolvePipelineMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo
    ResolvePipelineMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo
    ResolvePipelineMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolvePipelineMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolvePipelineMethod "getCurrentClockTime" o = Gst.Element.ElementGetCurrentClockTimeMethodInfo
    ResolvePipelineMethod "getCurrentRunningTime" o = Gst.Element.ElementGetCurrentRunningTimeMethodInfo
    ResolvePipelineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolvePipelineMethod "getDelay" o = Gst.Pipeline.PipelineGetDelayMethodInfo
    ResolvePipelineMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo
    ResolvePipelineMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolvePipelineMethod "getLatency" o = Gst.Pipeline.PipelineGetLatencyMethodInfo
    ResolvePipelineMethod "getMetadata" o = Gst.Element.ElementGetMetadataMethodInfo
    ResolvePipelineMethod "getMode" o = PipelineGetModeMethodInfo
    ResolvePipelineMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolvePipelineMethod "getPadTemplate" o = Gst.Element.ElementGetPadTemplateMethodInfo
    ResolvePipelineMethod "getPadTemplateList" o = Gst.Element.ElementGetPadTemplateListMethodInfo
    ResolvePipelineMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolvePipelineMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolvePipelineMethod "getPipelineClock" o = Gst.Pipeline.PipelineGetPipelineClockMethodInfo
    ResolvePipelineMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolvePipelineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolvePipelineMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo
    ResolvePipelineMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo
    ResolvePipelineMethod "getState" o = Gst.Element.ElementGetStateMethodInfo
    ResolvePipelineMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo
    ResolvePipelineMethod "getSuppressedFlags" o = Gst.Bin.BinGetSuppressedFlagsMethodInfo
    ResolvePipelineMethod "getThumbnail" o = PipelineGetThumbnailMethodInfo
    ResolvePipelineMethod "getThumbnailRgb24" o = PipelineGetThumbnailRgb24MethodInfo
    ResolvePipelineMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolvePipelineMethod "setAutoFlushBus" o = Gst.Pipeline.PipelineSetAutoFlushBusMethodInfo
    ResolvePipelineMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo
    ResolvePipelineMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo
    ResolvePipelineMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo
    ResolvePipelineMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo
    ResolvePipelineMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolvePipelineMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolvePipelineMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolvePipelineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolvePipelineMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolvePipelineMethod "setDelay" o = Gst.Pipeline.PipelineSetDelayMethodInfo
    ResolvePipelineMethod "setLatency" o = Gst.Pipeline.PipelineSetLatencyMethodInfo
    ResolvePipelineMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo
    ResolvePipelineMethod "setMode" o = PipelineSetModeMethodInfo
    ResolvePipelineMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolvePipelineMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolvePipelineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolvePipelineMethod "setRenderRectangle" o = GstVideo.VideoOverlay.VideoOverlaySetRenderRectangleMethodInfo
    ResolvePipelineMethod "setRenderSettings" o = PipelineSetRenderSettingsMethodInfo
    ResolvePipelineMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo
    ResolvePipelineMethod "setState" o = Gst.Element.ElementSetStateMethodInfo
    ResolvePipelineMethod "setSuppressedFlags" o = Gst.Bin.BinSetSuppressedFlagsMethodInfo
    ResolvePipelineMethod "setTimeline" o = PipelineSetTimelineMethodInfo
    ResolvePipelineMethod "setWindowHandle" o = GstVideo.VideoOverlay.VideoOverlaySetWindowHandleMethodInfo
    ResolvePipelineMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolvePipelineMethod t Pipeline, O.OverloadedMethod info Pipeline p) => OL.IsLabel t (Pipeline -> 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 ~ ResolvePipelineMethod t Pipeline, O.OverloadedMethod info Pipeline p, R.HasField t Pipeline p) => R.HasField t Pipeline p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolvePipelineMethod t Pipeline, O.OverloadedMethodInfo info Pipeline) => OL.IsLabel t (O.MethodProxy info Pipeline) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "audio-filter"
   -- Type: TInterface (Name {namespace = "Gst", name = "Element"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@audio-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pipeline #audioFilter
-- @
getPipelineAudioFilter :: (MonadIO m, IsPipeline o) => o -> m (Maybe Gst.Element.Element)
getPipelineAudioFilter :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> m (Maybe Element)
getPipelineAudioFilter o
obj = IO (Maybe Element) -> m (Maybe Element)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Element) -> m (Maybe Element))
-> IO (Maybe Element) -> m (Maybe Element)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Element -> Element) -> IO (Maybe Element)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"audio-filter" ManagedPtr Element -> Element
Gst.Element.Element

-- | Set the value of the “@audio-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pipeline [ #audioFilter 'Data.GI.Base.Attributes.:=' value ]
-- @
setPipelineAudioFilter :: (MonadIO m, IsPipeline o, Gst.Element.IsElement a) => o -> a -> m ()
setPipelineAudioFilter :: forall (m :: * -> *) o a.
(MonadIO m, IsPipeline o, IsElement a) =>
o -> a -> m ()
setPipelineAudioFilter o
obj a
val = IO () -> m ()
forall a. IO a -> m a
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
"audio-filter" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@audio-filter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPipelineAudioFilter :: (IsPipeline o, MIO.MonadIO m, Gst.Element.IsElement a) => a -> m (GValueConstruct o)
constructPipelineAudioFilter :: forall o (m :: * -> *) a.
(IsPipeline o, MonadIO m, IsElement a) =>
a -> m (GValueConstruct o)
constructPipelineAudioFilter a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"audio-filter" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@audio-filter@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #audioFilter
-- @
clearPipelineAudioFilter :: (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineAudioFilter :: forall (m :: * -> *) o. (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineAudioFilter o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Element -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"audio-filter" (Maybe Element
forall a. Maybe a
Nothing :: Maybe Gst.Element.Element)

#if defined(ENABLE_OVERLOADING)
data PipelineAudioFilterPropertyInfo
instance AttrInfo PipelineAudioFilterPropertyInfo where
    type AttrAllowedOps PipelineAudioFilterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PipelineAudioFilterPropertyInfo = IsPipeline
    type AttrSetTypeConstraint PipelineAudioFilterPropertyInfo = Gst.Element.IsElement
    type AttrTransferTypeConstraint PipelineAudioFilterPropertyInfo = Gst.Element.IsElement
    type AttrTransferType PipelineAudioFilterPropertyInfo = Gst.Element.Element
    type AttrGetType PipelineAudioFilterPropertyInfo = (Maybe Gst.Element.Element)
    type AttrLabel PipelineAudioFilterPropertyInfo = "audio-filter"
    type AttrOrigin PipelineAudioFilterPropertyInfo = Pipeline
    attrGet = getPipelineAudioFilter
    attrSet = setPipelineAudioFilter
    attrTransfer _ v = do
        unsafeCastTo Gst.Element.Element v
    attrConstruct = constructPipelineAudioFilter
    attrClear = clearPipelineAudioFilter
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.audioFilter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#g:attr:audioFilter"
        })
#endif

-- VVV Prop "audio-sink"
   -- Type: TInterface (Name {namespace = "Gst", name = "Element"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@audio-sink@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pipeline #audioSink
-- @
getPipelineAudioSink :: (MonadIO m, IsPipeline o) => o -> m (Maybe Gst.Element.Element)
getPipelineAudioSink :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> m (Maybe Element)
getPipelineAudioSink o
obj = IO (Maybe Element) -> m (Maybe Element)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Element) -> m (Maybe Element))
-> IO (Maybe Element) -> m (Maybe Element)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Element -> Element) -> IO (Maybe Element)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"audio-sink" ManagedPtr Element -> Element
Gst.Element.Element

-- | Set the value of the “@audio-sink@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pipeline [ #audioSink 'Data.GI.Base.Attributes.:=' value ]
-- @
setPipelineAudioSink :: (MonadIO m, IsPipeline o, Gst.Element.IsElement a) => o -> a -> m ()
setPipelineAudioSink :: forall (m :: * -> *) o a.
(MonadIO m, IsPipeline o, IsElement a) =>
o -> a -> m ()
setPipelineAudioSink o
obj a
val = IO () -> m ()
forall a. IO a -> m a
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
"audio-sink" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@audio-sink@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPipelineAudioSink :: (IsPipeline o, MIO.MonadIO m, Gst.Element.IsElement a) => a -> m (GValueConstruct o)
constructPipelineAudioSink :: forall o (m :: * -> *) a.
(IsPipeline o, MonadIO m, IsElement a) =>
a -> m (GValueConstruct o)
constructPipelineAudioSink a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"audio-sink" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@audio-sink@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #audioSink
-- @
clearPipelineAudioSink :: (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineAudioSink :: forall (m :: * -> *) o. (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineAudioSink o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Element -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"audio-sink" (Maybe Element
forall a. Maybe a
Nothing :: Maybe Gst.Element.Element)

#if defined(ENABLE_OVERLOADING)
data PipelineAudioSinkPropertyInfo
instance AttrInfo PipelineAudioSinkPropertyInfo where
    type AttrAllowedOps PipelineAudioSinkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PipelineAudioSinkPropertyInfo = IsPipeline
    type AttrSetTypeConstraint PipelineAudioSinkPropertyInfo = Gst.Element.IsElement
    type AttrTransferTypeConstraint PipelineAudioSinkPropertyInfo = Gst.Element.IsElement
    type AttrTransferType PipelineAudioSinkPropertyInfo = Gst.Element.Element
    type AttrGetType PipelineAudioSinkPropertyInfo = (Maybe Gst.Element.Element)
    type AttrLabel PipelineAudioSinkPropertyInfo = "audio-sink"
    type AttrOrigin PipelineAudioSinkPropertyInfo = Pipeline
    attrGet = getPipelineAudioSink
    attrSet = setPipelineAudioSink
    attrTransfer _ v = do
        unsafeCastTo Gst.Element.Element v
    attrConstruct = constructPipelineAudioSink
    attrClear = clearPipelineAudioSink
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.audioSink"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#g:attr:audioSink"
        })
#endif

-- VVV Prop "mode"
   -- Type: TInterface (Name {namespace = "GES", name = "PipelineFlags"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pipeline #mode
-- @
getPipelineMode :: (MonadIO m, IsPipeline o) => o -> m [GES.Flags.PipelineFlags]
getPipelineMode :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> m [PipelineFlags]
getPipelineMode o
obj = IO [PipelineFlags] -> m [PipelineFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [PipelineFlags] -> m [PipelineFlags])
-> IO [PipelineFlags] -> m [PipelineFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [PipelineFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"mode"

-- | Set the value of the “@mode@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pipeline [ #mode 'Data.GI.Base.Attributes.:=' value ]
-- @
setPipelineMode :: (MonadIO m, IsPipeline o) => o -> [GES.Flags.PipelineFlags] -> m ()
setPipelineMode :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> [PipelineFlags] -> m ()
setPipelineMode o
obj [PipelineFlags]
val = IO () -> m ()
forall a. IO a -> m a
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 -> [PipelineFlags] -> IO ()
forall a b.
(IsGFlag b, BoxedFlags b, GObject a) =>
a -> String -> [b] -> IO ()
B.Properties.setObjectPropertyFlags o
obj String
"mode" [PipelineFlags]
val

-- | Construct a `GValueConstruct` with valid value for the “@mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPipelineMode :: (IsPipeline o, MIO.MonadIO m) => [GES.Flags.PipelineFlags] -> m (GValueConstruct o)
constructPipelineMode :: forall o (m :: * -> *).
(IsPipeline o, MonadIO m) =>
[PipelineFlags] -> m (GValueConstruct o)
constructPipelineMode [PipelineFlags]
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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 -> [PipelineFlags] -> IO (GValueConstruct o)
forall a o.
(IsGFlag a, BoxedFlags a) =>
String -> [a] -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyFlags String
"mode" [PipelineFlags]
val

#if defined(ENABLE_OVERLOADING)
data PipelineModePropertyInfo
instance AttrInfo PipelineModePropertyInfo where
    type AttrAllowedOps PipelineModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint PipelineModePropertyInfo = IsPipeline
    type AttrSetTypeConstraint PipelineModePropertyInfo = (~) [GES.Flags.PipelineFlags]
    type AttrTransferTypeConstraint PipelineModePropertyInfo = (~) [GES.Flags.PipelineFlags]
    type AttrTransferType PipelineModePropertyInfo = [GES.Flags.PipelineFlags]
    type AttrGetType PipelineModePropertyInfo = [GES.Flags.PipelineFlags]
    type AttrLabel PipelineModePropertyInfo = "mode"
    type AttrOrigin PipelineModePropertyInfo = Pipeline
    attrGet = getPipelineMode
    attrSet = setPipelineMode
    attrTransfer _ v = do
        return v
    attrConstruct = constructPipelineMode
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.mode"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#g:attr:mode"
        })
#endif

-- VVV Prop "timeline"
   -- Type: TInterface (Name {namespace = "GES", name = "Timeline"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@timeline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pipeline #timeline
-- @
getPipelineTimeline :: (MonadIO m, IsPipeline o) => o -> m (Maybe GES.Timeline.Timeline)
getPipelineTimeline :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> m (Maybe Timeline)
getPipelineTimeline o
obj = IO (Maybe Timeline) -> m (Maybe Timeline)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Timeline) -> m (Maybe Timeline))
-> IO (Maybe Timeline) -> m (Maybe Timeline)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Timeline -> Timeline)
-> IO (Maybe Timeline)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"timeline" ManagedPtr Timeline -> Timeline
GES.Timeline.Timeline

-- | Set the value of the “@timeline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pipeline [ #timeline 'Data.GI.Base.Attributes.:=' value ]
-- @
setPipelineTimeline :: (MonadIO m, IsPipeline o, GES.Timeline.IsTimeline a) => o -> a -> m ()
setPipelineTimeline :: forall (m :: * -> *) o a.
(MonadIO m, IsPipeline o, IsTimeline a) =>
o -> a -> m ()
setPipelineTimeline o
obj a
val = IO () -> m ()
forall a. IO a -> m a
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
"timeline" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@timeline@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPipelineTimeline :: (IsPipeline o, MIO.MonadIO m, GES.Timeline.IsTimeline a) => a -> m (GValueConstruct o)
constructPipelineTimeline :: forall o (m :: * -> *) a.
(IsPipeline o, MonadIO m, IsTimeline a) =>
a -> m (GValueConstruct o)
constructPipelineTimeline a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"timeline" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@timeline@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #timeline
-- @
clearPipelineTimeline :: (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineTimeline :: forall (m :: * -> *) o. (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineTimeline o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Timeline -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"timeline" (Maybe Timeline
forall a. Maybe a
Nothing :: Maybe GES.Timeline.Timeline)

#if defined(ENABLE_OVERLOADING)
data PipelineTimelinePropertyInfo
instance AttrInfo PipelineTimelinePropertyInfo where
    type AttrAllowedOps PipelineTimelinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PipelineTimelinePropertyInfo = IsPipeline
    type AttrSetTypeConstraint PipelineTimelinePropertyInfo = GES.Timeline.IsTimeline
    type AttrTransferTypeConstraint PipelineTimelinePropertyInfo = GES.Timeline.IsTimeline
    type AttrTransferType PipelineTimelinePropertyInfo = GES.Timeline.Timeline
    type AttrGetType PipelineTimelinePropertyInfo = (Maybe GES.Timeline.Timeline)
    type AttrLabel PipelineTimelinePropertyInfo = "timeline"
    type AttrOrigin PipelineTimelinePropertyInfo = Pipeline
    attrGet = getPipelineTimeline
    attrSet = setPipelineTimeline
    attrTransfer _ v = do
        unsafeCastTo GES.Timeline.Timeline v
    attrConstruct = constructPipelineTimeline
    attrClear = clearPipelineTimeline
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.timeline"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#g:attr:timeline"
        })
#endif

-- VVV Prop "video-filter"
   -- Type: TInterface (Name {namespace = "Gst", name = "Element"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@video-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pipeline #videoFilter
-- @
getPipelineVideoFilter :: (MonadIO m, IsPipeline o) => o -> m (Maybe Gst.Element.Element)
getPipelineVideoFilter :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> m (Maybe Element)
getPipelineVideoFilter o
obj = IO (Maybe Element) -> m (Maybe Element)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Element) -> m (Maybe Element))
-> IO (Maybe Element) -> m (Maybe Element)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Element -> Element) -> IO (Maybe Element)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"video-filter" ManagedPtr Element -> Element
Gst.Element.Element

-- | Set the value of the “@video-filter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pipeline [ #videoFilter 'Data.GI.Base.Attributes.:=' value ]
-- @
setPipelineVideoFilter :: (MonadIO m, IsPipeline o, Gst.Element.IsElement a) => o -> a -> m ()
setPipelineVideoFilter :: forall (m :: * -> *) o a.
(MonadIO m, IsPipeline o, IsElement a) =>
o -> a -> m ()
setPipelineVideoFilter o
obj a
val = IO () -> m ()
forall a. IO a -> m a
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
"video-filter" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@video-filter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPipelineVideoFilter :: (IsPipeline o, MIO.MonadIO m, Gst.Element.IsElement a) => a -> m (GValueConstruct o)
constructPipelineVideoFilter :: forall o (m :: * -> *) a.
(IsPipeline o, MonadIO m, IsElement a) =>
a -> m (GValueConstruct o)
constructPipelineVideoFilter a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"video-filter" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@video-filter@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #videoFilter
-- @
clearPipelineVideoFilter :: (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineVideoFilter :: forall (m :: * -> *) o. (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineVideoFilter o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Element -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"video-filter" (Maybe Element
forall a. Maybe a
Nothing :: Maybe Gst.Element.Element)

#if defined(ENABLE_OVERLOADING)
data PipelineVideoFilterPropertyInfo
instance AttrInfo PipelineVideoFilterPropertyInfo where
    type AttrAllowedOps PipelineVideoFilterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PipelineVideoFilterPropertyInfo = IsPipeline
    type AttrSetTypeConstraint PipelineVideoFilterPropertyInfo = Gst.Element.IsElement
    type AttrTransferTypeConstraint PipelineVideoFilterPropertyInfo = Gst.Element.IsElement
    type AttrTransferType PipelineVideoFilterPropertyInfo = Gst.Element.Element
    type AttrGetType PipelineVideoFilterPropertyInfo = (Maybe Gst.Element.Element)
    type AttrLabel PipelineVideoFilterPropertyInfo = "video-filter"
    type AttrOrigin PipelineVideoFilterPropertyInfo = Pipeline
    attrGet = getPipelineVideoFilter
    attrSet = setPipelineVideoFilter
    attrTransfer _ v = do
        unsafeCastTo Gst.Element.Element v
    attrConstruct = constructPipelineVideoFilter
    attrClear = clearPipelineVideoFilter
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.videoFilter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#g:attr:videoFilter"
        })
#endif

-- VVV Prop "video-sink"
   -- Type: TInterface (Name {namespace = "Gst", name = "Element"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@video-sink@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' pipeline #videoSink
-- @
getPipelineVideoSink :: (MonadIO m, IsPipeline o) => o -> m (Maybe Gst.Element.Element)
getPipelineVideoSink :: forall (m :: * -> *) o.
(MonadIO m, IsPipeline o) =>
o -> m (Maybe Element)
getPipelineVideoSink o
obj = IO (Maybe Element) -> m (Maybe Element)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Element) -> m (Maybe Element))
-> IO (Maybe Element) -> m (Maybe Element)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Element -> Element) -> IO (Maybe Element)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"video-sink" ManagedPtr Element -> Element
Gst.Element.Element

-- | Set the value of the “@video-sink@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' pipeline [ #videoSink 'Data.GI.Base.Attributes.:=' value ]
-- @
setPipelineVideoSink :: (MonadIO m, IsPipeline o, Gst.Element.IsElement a) => o -> a -> m ()
setPipelineVideoSink :: forall (m :: * -> *) o a.
(MonadIO m, IsPipeline o, IsElement a) =>
o -> a -> m ()
setPipelineVideoSink o
obj a
val = IO () -> m ()
forall a. IO a -> m a
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
"video-sink" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@video-sink@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructPipelineVideoSink :: (IsPipeline o, MIO.MonadIO m, Gst.Element.IsElement a) => a -> m (GValueConstruct o)
constructPipelineVideoSink :: forall o (m :: * -> *) a.
(IsPipeline o, MonadIO m, IsElement a) =>
a -> m (GValueConstruct o)
constructPipelineVideoSink a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
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 a. IO a -> IO a
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
"video-sink" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@video-sink@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #videoSink
-- @
clearPipelineVideoSink :: (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineVideoSink :: forall (m :: * -> *) o. (MonadIO m, IsPipeline o) => o -> m ()
clearPipelineVideoSink o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Element -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"video-sink" (Maybe Element
forall a. Maybe a
Nothing :: Maybe Gst.Element.Element)

#if defined(ENABLE_OVERLOADING)
data PipelineVideoSinkPropertyInfo
instance AttrInfo PipelineVideoSinkPropertyInfo where
    type AttrAllowedOps PipelineVideoSinkPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint PipelineVideoSinkPropertyInfo = IsPipeline
    type AttrSetTypeConstraint PipelineVideoSinkPropertyInfo = Gst.Element.IsElement
    type AttrTransferTypeConstraint PipelineVideoSinkPropertyInfo = Gst.Element.IsElement
    type AttrTransferType PipelineVideoSinkPropertyInfo = Gst.Element.Element
    type AttrGetType PipelineVideoSinkPropertyInfo = (Maybe Gst.Element.Element)
    type AttrLabel PipelineVideoSinkPropertyInfo = "video-sink"
    type AttrOrigin PipelineVideoSinkPropertyInfo = Pipeline
    attrGet = getPipelineVideoSink
    attrSet = setPipelineVideoSink
    attrTransfer _ v = do
        unsafeCastTo Gst.Element.Element v
    attrConstruct = constructPipelineVideoSink
    attrClear = clearPipelineVideoSink
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.videoSink"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#g:attr:videoSink"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Pipeline
type instance O.AttributeList Pipeline = PipelineAttributeList
type PipelineAttributeList = ('[ '("asyncHandling", Gst.Bin.BinAsyncHandlingPropertyInfo), '("audioFilter", PipelineAudioFilterPropertyInfo), '("audioSink", PipelineAudioSinkPropertyInfo), '("autoFlushBus", Gst.Pipeline.PipelineAutoFlushBusPropertyInfo), '("delay", Gst.Pipeline.PipelineDelayPropertyInfo), '("latency", Gst.Pipeline.PipelineLatencyPropertyInfo), '("messageForward", Gst.Bin.BinMessageForwardPropertyInfo), '("mode", PipelineModePropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("timeline", PipelineTimelinePropertyInfo), '("videoFilter", PipelineVideoFilterPropertyInfo), '("videoSink", PipelineVideoSinkPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
pipelineAudioFilter :: AttrLabelProxy "audioFilter"
pipelineAudioFilter = AttrLabelProxy

pipelineAudioSink :: AttrLabelProxy "audioSink"
pipelineAudioSink = AttrLabelProxy

pipelineMode :: AttrLabelProxy "mode"
pipelineMode = AttrLabelProxy

pipelineTimeline :: AttrLabelProxy "timeline"
pipelineTimeline = AttrLabelProxy

pipelineVideoFilter :: AttrLabelProxy "videoFilter"
pipelineVideoFilter = AttrLabelProxy

pipelineVideoSink :: AttrLabelProxy "videoSink"
pipelineVideoSink = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Pipeline = PipelineSignalList
type PipelineSignalList = ('[ '("childAdded", Gst.ChildProxy.ChildProxyChildAddedSignalInfo), '("childRemoved", Gst.ChildProxy.ChildProxyChildRemovedSignalInfo), '("deepElementAdded", Gst.Bin.BinDeepElementAddedSignalInfo), '("deepElementRemoved", Gst.Bin.BinDeepElementRemovedSignalInfo), '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("doLatency", Gst.Bin.BinDoLatencySignalInfo), '("elementAdded", Gst.Bin.BinElementAddedSignalInfo), '("elementRemoved", Gst.Bin.BinElementRemovedSignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method Pipeline::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "Pipeline" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_new" ges_pipeline_new :: 
    IO (Ptr Pipeline)

-- | Creates a new pipeline.
pipelineNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Pipeline
    -- ^ __Returns:__ The newly created pipeline.
pipelineNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Pipeline
pipelineNew  = IO Pipeline -> m Pipeline
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Pipeline -> m Pipeline) -> IO Pipeline -> m Pipeline
forall a b. (a -> b) -> a -> b
$ do
    Ptr Pipeline
result <- IO (Ptr Pipeline)
ges_pipeline_new
    Text -> Ptr Pipeline -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"pipelineNew" Ptr Pipeline
result
    Pipeline
result' <- ((ManagedPtr Pipeline -> Pipeline) -> Ptr Pipeline -> IO Pipeline
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Pipeline -> Pipeline
Pipeline) Ptr Pipeline
result
    Pipeline -> IO Pipeline
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Pipeline
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Pipeline::get_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pipeline"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "PipelineFlags" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_get_mode" ges_pipeline_get_mode :: 
    Ptr Pipeline ->                         -- pipeline : TInterface (Name {namespace = "GES", name = "Pipeline"})
    IO CUInt

-- | Gets the [Pipeline:mode]("GI.GES.Objects.Pipeline#g:attr:mode") of the pipeline.
pipelineGetMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a) =>
    a
    -- ^ /@pipeline@/: A t'GI.GES.Objects.Pipeline.Pipeline'
    -> m [GES.Flags.PipelineFlags]
    -- ^ __Returns:__ The current mode of /@pipeline@/.
pipelineGetMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPipeline a) =>
a -> m [PipelineFlags]
pipelineGetMode a
pipeline = IO [PipelineFlags] -> m [PipelineFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [PipelineFlags] -> m [PipelineFlags])
-> IO [PipelineFlags] -> m [PipelineFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Pipeline
pipeline' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pipeline
    CUInt
result <- Ptr Pipeline -> IO CUInt
ges_pipeline_get_mode Ptr Pipeline
pipeline'
    let result' :: [PipelineFlags]
result' = CUInt -> [PipelineFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
pipeline
    [PipelineFlags] -> IO [PipelineFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [PipelineFlags]
result'

#if defined(ENABLE_OVERLOADING)
data PipelineGetModeMethodInfo
instance (signature ~ (m [GES.Flags.PipelineFlags]), MonadIO m, IsPipeline a) => O.OverloadedMethod PipelineGetModeMethodInfo a signature where
    overloadedMethod = pipelineGetMode

instance O.OverloadedMethodInfo PipelineGetModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelineGetMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelineGetMode"
        })


#endif

-- method Pipeline::get_thumbnail
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A #GESPipeline in #GST_STATE_PLAYING or #GST_STATE_PAUSED"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "caps"
--           , argType = TInterface Name { namespace = "Gst" , name = "Caps" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "Some caps to specifying the desired format, or\n#GST_CAPS_ANY to use the native format"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Sample" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_get_thumbnail" ges_pipeline_get_thumbnail :: 
    Ptr Pipeline ->                         -- self : TInterface (Name {namespace = "GES", name = "Pipeline"})
    Ptr Gst.Caps.Caps ->                    -- caps : TInterface (Name {namespace = "Gst", name = "Caps"})
    IO (Ptr Gst.Sample.Sample)

-- | Gets a sample from the pipeline of the currently displayed image in
-- preview, in the specified format.
-- 
-- Note that if you use \"ANY\" caps for /@caps@/, then the current format of
-- the image is used. You can retrieve these caps from the returned sample
-- with 'GI.Gst.Structs.Sample.sampleGetCaps'.
pipelineGetThumbnail ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.Pipeline.Pipeline' in @/GST_STATE_PLAYING/@ or @/GST_STATE_PAUSED/@
    -> Gst.Caps.Caps
    -- ^ /@caps@/: Some caps to specifying the desired format, or
    -- @/GST_CAPS_ANY/@ to use the native format
    -> m (Maybe Gst.Sample.Sample)
    -- ^ __Returns:__ A sample of /@self@/\'s current image preview in
    -- the format given by /@caps@/, or 'P.Nothing' if an error prevented fetching the
    -- sample.
pipelineGetThumbnail :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPipeline a) =>
a -> Caps -> m (Maybe Sample)
pipelineGetThumbnail a
self Caps
caps = IO (Maybe Sample) -> m (Maybe Sample)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Sample) -> m (Maybe Sample))
-> IO (Maybe Sample) -> m (Maybe Sample)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Pipeline
self' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Caps
caps' <- Caps -> IO (Ptr Caps)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Caps
caps
    Ptr Sample
result <- Ptr Pipeline -> Ptr Caps -> IO (Ptr Sample)
ges_pipeline_get_thumbnail Ptr Pipeline
self' Ptr Caps
caps'
    Maybe Sample
maybeResult <- Ptr Sample -> (Ptr Sample -> IO Sample) -> IO (Maybe Sample)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Sample
result ((Ptr Sample -> IO Sample) -> IO (Maybe Sample))
-> (Ptr Sample -> IO Sample) -> IO (Maybe Sample)
forall a b. (a -> b) -> a -> b
$ \Ptr Sample
result' -> do
        Sample
result'' <- ((ManagedPtr Sample -> Sample) -> Ptr Sample -> IO Sample
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Sample -> Sample
Gst.Sample.Sample) Ptr Sample
result'
        Sample -> IO Sample
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Sample
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Caps -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Caps
caps
    Maybe Sample -> IO (Maybe Sample)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Sample
maybeResult

#if defined(ENABLE_OVERLOADING)
data PipelineGetThumbnailMethodInfo
instance (signature ~ (Gst.Caps.Caps -> m (Maybe Gst.Sample.Sample)), MonadIO m, IsPipeline a) => O.OverloadedMethod PipelineGetThumbnailMethodInfo a signature where
    overloadedMethod = pipelineGetThumbnail

instance O.OverloadedMethodInfo PipelineGetThumbnailMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelineGetThumbnail",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelineGetThumbnail"
        })


#endif

-- method Pipeline::get_thumbnail_rgb24
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A #GESPipeline in %GST_STATE_PLAYING or %GST_STATE_PAUSED"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The requested pixel width of the image, or -1 to use the native\nsize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The requested pixel height of the image, or -1 to use the\nnative size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Sample" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_get_thumbnail_rgb24" ges_pipeline_get_thumbnail_rgb24 :: 
    Ptr Pipeline ->                         -- self : TInterface (Name {namespace = "GES", name = "Pipeline"})
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    IO (Ptr Gst.Sample.Sample)

-- | Gets a sample from the pipeline of the currently displayed image in
-- preview, in the 24-bit \"RGB\" format and of the desired width and
-- height.
-- 
-- See 'GI.GES.Objects.Pipeline.pipelineGetThumbnail'.
pipelineGetThumbnailRgb24 ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.Pipeline.Pipeline' in 'GI.Gst.Enums.StatePlaying' or 'GI.Gst.Enums.StatePaused'
    -> Int32
    -- ^ /@width@/: The requested pixel width of the image, or -1 to use the native
    -- size
    -> Int32
    -- ^ /@height@/: The requested pixel height of the image, or -1 to use the
    -- native size
    -> m (Maybe Gst.Sample.Sample)
    -- ^ __Returns:__ A sample of /@self@/\'s current image preview in
    -- the \"RGB\" format, scaled to /@width@/ and /@height@/, or 'P.Nothing' if an error
    -- prevented fetching the sample.
pipelineGetThumbnailRgb24 :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPipeline a) =>
a -> Int32 -> Int32 -> m (Maybe Sample)
pipelineGetThumbnailRgb24 a
self Int32
width Int32
height = IO (Maybe Sample) -> m (Maybe Sample)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Sample) -> m (Maybe Sample))
-> IO (Maybe Sample) -> m (Maybe Sample)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Pipeline
self' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Sample
result <- Ptr Pipeline -> Int32 -> Int32 -> IO (Ptr Sample)
ges_pipeline_get_thumbnail_rgb24 Ptr Pipeline
self' Int32
width Int32
height
    Maybe Sample
maybeResult <- Ptr Sample -> (Ptr Sample -> IO Sample) -> IO (Maybe Sample)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Sample
result ((Ptr Sample -> IO Sample) -> IO (Maybe Sample))
-> (Ptr Sample -> IO Sample) -> IO (Maybe Sample)
forall a b. (a -> b) -> a -> b
$ \Ptr Sample
result' -> do
        Sample
result'' <- ((ManagedPtr Sample -> Sample) -> Ptr Sample -> IO Sample
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Sample -> Sample
Gst.Sample.Sample) Ptr Sample
result'
        Sample -> IO Sample
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Sample
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Sample -> IO (Maybe Sample)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Sample
maybeResult

#if defined(ENABLE_OVERLOADING)
data PipelineGetThumbnailRgb24MethodInfo
instance (signature ~ (Int32 -> Int32 -> m (Maybe Gst.Sample.Sample)), MonadIO m, IsPipeline a) => O.OverloadedMethod PipelineGetThumbnailRgb24MethodInfo a signature where
    overloadedMethod = pipelineGetThumbnailRgb24

instance O.OverloadedMethodInfo PipelineGetThumbnailRgb24MethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelineGetThumbnailRgb24",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelineGetThumbnailRgb24"
        })


#endif

-- method Pipeline::preview_get_audio_sink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Element" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_preview_get_audio_sink" ges_pipeline_preview_get_audio_sink :: 
    Ptr Pipeline ->                         -- self : TInterface (Name {namespace = "GES", name = "Pipeline"})
    IO (Ptr Gst.Element.Element)

-- | Gets the [Pipeline:audioSink]("GI.GES.Objects.Pipeline#g:attr:audioSink") of the pipeline.
pipelinePreviewGetAudioSink ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.Pipeline.Pipeline'
    -> m (Maybe Gst.Element.Element)
    -- ^ __Returns:__ The audio sink used by /@self@/ for preview.
pipelinePreviewGetAudioSink :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPipeline a) =>
a -> m (Maybe Element)
pipelinePreviewGetAudioSink a
self = IO (Maybe Element) -> m (Maybe Element)
forall a. IO a -> m a
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 Pipeline
self' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Element
result <- Ptr Pipeline -> IO (Ptr Element)
ges_pipeline_preview_get_audio_sink Ptr Pipeline
self'
    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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Element
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Element -> IO (Maybe Element)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Element
maybeResult

#if defined(ENABLE_OVERLOADING)
data PipelinePreviewGetAudioSinkMethodInfo
instance (signature ~ (m (Maybe Gst.Element.Element)), MonadIO m, IsPipeline a) => O.OverloadedMethod PipelinePreviewGetAudioSinkMethodInfo a signature where
    overloadedMethod = pipelinePreviewGetAudioSink

instance O.OverloadedMethodInfo PipelinePreviewGetAudioSinkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelinePreviewGetAudioSink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelinePreviewGetAudioSink"
        })


#endif

-- method Pipeline::preview_get_video_sink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Element" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_preview_get_video_sink" ges_pipeline_preview_get_video_sink :: 
    Ptr Pipeline ->                         -- self : TInterface (Name {namespace = "GES", name = "Pipeline"})
    IO (Ptr Gst.Element.Element)

-- | Gets the [Pipeline:videoSink]("GI.GES.Objects.Pipeline#g:attr:videoSink") of the pipeline.
pipelinePreviewGetVideoSink ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.Pipeline.Pipeline'
    -> m (Maybe Gst.Element.Element)
    -- ^ __Returns:__ The video sink used by /@self@/ for preview.
pipelinePreviewGetVideoSink :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPipeline a) =>
a -> m (Maybe Element)
pipelinePreviewGetVideoSink a
self = IO (Maybe Element) -> m (Maybe Element)
forall a. IO a -> m a
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 Pipeline
self' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Element
result <- Ptr Pipeline -> IO (Ptr Element)
ges_pipeline_preview_get_video_sink Ptr Pipeline
self'
    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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Element
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Element -> IO (Maybe Element)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Element
maybeResult

#if defined(ENABLE_OVERLOADING)
data PipelinePreviewGetVideoSinkMethodInfo
instance (signature ~ (m (Maybe Gst.Element.Element)), MonadIO m, IsPipeline a) => O.OverloadedMethod PipelinePreviewGetVideoSinkMethodInfo a signature where
    overloadedMethod = pipelinePreviewGetVideoSink

instance O.OverloadedMethodInfo PipelinePreviewGetVideoSinkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelinePreviewGetVideoSink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelinePreviewGetVideoSink"
        })


#endif

-- method Pipeline::preview_set_audio_sink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline in #GST_STATE_NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sink"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "Element" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A audio sink for @self to use for preview"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_preview_set_audio_sink" ges_pipeline_preview_set_audio_sink :: 
    Ptr Pipeline ->                         -- self : TInterface (Name {namespace = "GES", name = "Pipeline"})
    Ptr Gst.Element.Element ->              -- sink : TInterface (Name {namespace = "Gst", name = "Element"})
    IO ()

-- | Sets the [Pipeline:audioSink]("GI.GES.Objects.Pipeline#g:attr:audioSink") of the pipeline.
pipelinePreviewSetAudioSink ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a, Gst.Element.IsElement b) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.Pipeline.Pipeline' in @/GST_STATE_NULL/@
    -> Maybe (b)
    -- ^ /@sink@/: A audio sink for /@self@/ to use for preview
    -> m ()
pipelinePreviewSetAudioSink :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPipeline a, IsElement b) =>
a -> Maybe b -> m ()
pipelinePreviewSetAudioSink a
self Maybe b
sink = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Pipeline
self' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Element
maybeSink <- case Maybe b
sink of
        Maybe b
Nothing -> Ptr Element -> IO (Ptr Element)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Element
forall a. Ptr a
nullPtr
        Just b
jSink -> do
            Ptr Element
jSink' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSink
            Ptr Element -> IO (Ptr Element)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Element
jSink'
    Ptr Pipeline -> Ptr Element -> IO ()
ges_pipeline_preview_set_audio_sink Ptr Pipeline
self' Ptr Element
maybeSink
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sink b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PipelinePreviewSetAudioSinkMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsPipeline a, Gst.Element.IsElement b) => O.OverloadedMethod PipelinePreviewSetAudioSinkMethodInfo a signature where
    overloadedMethod = pipelinePreviewSetAudioSink

instance O.OverloadedMethodInfo PipelinePreviewSetAudioSinkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelinePreviewSetAudioSink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelinePreviewSetAudioSink"
        })


#endif

-- method Pipeline::preview_set_video_sink
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline in #GST_STATE_NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "sink"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "Element" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A video sink for @self to use for preview"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_preview_set_video_sink" ges_pipeline_preview_set_video_sink :: 
    Ptr Pipeline ->                         -- self : TInterface (Name {namespace = "GES", name = "Pipeline"})
    Ptr Gst.Element.Element ->              -- sink : TInterface (Name {namespace = "Gst", name = "Element"})
    IO ()

-- | Sets the [Pipeline:videoSink]("GI.GES.Objects.Pipeline#g:attr:videoSink") of the pipeline.
pipelinePreviewSetVideoSink ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a, Gst.Element.IsElement b) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.Pipeline.Pipeline' in @/GST_STATE_NULL/@
    -> Maybe (b)
    -- ^ /@sink@/: A video sink for /@self@/ to use for preview
    -> m ()
pipelinePreviewSetVideoSink :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPipeline a, IsElement b) =>
a -> Maybe b -> m ()
pipelinePreviewSetVideoSink a
self Maybe b
sink = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Pipeline
self' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr Element
maybeSink <- case Maybe b
sink of
        Maybe b
Nothing -> Ptr Element -> IO (Ptr Element)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Element
forall a. Ptr a
nullPtr
        Just b
jSink -> do
            Ptr Element
jSink' <- b -> IO (Ptr Element)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jSink
            Ptr Element -> IO (Ptr Element)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Element
jSink'
    Ptr Pipeline -> Ptr Element -> IO ()
ges_pipeline_preview_set_video_sink Ptr Pipeline
self' Ptr Element
maybeSink
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
sink b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data PipelinePreviewSetVideoSinkMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsPipeline a, Gst.Element.IsElement b) => O.OverloadedMethod PipelinePreviewSetVideoSinkMethodInfo a signature where
    overloadedMethod = pipelinePreviewSetVideoSink

instance O.OverloadedMethodInfo PipelinePreviewSetVideoSinkMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelinePreviewSetVideoSink",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelinePreviewSetVideoSink"
        })


#endif

-- method Pipeline::save_thumbnail
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "A #GESPipeline in %GST_STATE_PLAYING or %GST_STATE_PAUSED"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The requested pixel width of the image, or -1 to use the native\nsize"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "height"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The requested pixel height of the image, or -1 to use the\nnative size"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "format"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The desired mime type (for example, \"image/jpeg\")"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "location"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The path to save the thumbnail to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "ges_pipeline_save_thumbnail" ges_pipeline_save_thumbnail :: 
    Ptr Pipeline ->                         -- self : TInterface (Name {namespace = "GES", name = "Pipeline"})
    Int32 ->                                -- width : TBasicType TInt
    Int32 ->                                -- height : TBasicType TInt
    CString ->                              -- format : TBasicType TUTF8
    CString ->                              -- location : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Saves the currently displayed image of the pipeline in preview to the
-- given location, in the specified dimensions and format.
pipelineSaveThumbnail ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.Pipeline.Pipeline' in 'GI.Gst.Enums.StatePlaying' or 'GI.Gst.Enums.StatePaused'
    -> Int32
    -- ^ /@width@/: The requested pixel width of the image, or -1 to use the native
    -- size
    -> Int32
    -- ^ /@height@/: The requested pixel height of the image, or -1 to use the
    -- native size
    -> T.Text
    -- ^ /@format@/: The desired mime type (for example, \"image\/jpeg\")
    -> T.Text
    -- ^ /@location@/: The path to save the thumbnail to
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
pipelineSaveThumbnail :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPipeline a) =>
a -> Int32 -> Int32 -> Text -> Text -> m ()
pipelineSaveThumbnail a
self Int32
width Int32
height Text
format Text
location = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Pipeline
self' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
format' <- Text -> IO CString
textToCString Text
format
    CString
location' <- Text -> IO CString
textToCString Text
location
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Pipeline
-> Int32
-> Int32
-> CString
-> CString
-> Ptr (Ptr GError)
-> IO CInt
ges_pipeline_save_thumbnail Ptr Pipeline
self' Int32
width Int32
height CString
format' CString
location'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
format'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
location'
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
format'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
location'
     )

#if defined(ENABLE_OVERLOADING)
data PipelineSaveThumbnailMethodInfo
instance (signature ~ (Int32 -> Int32 -> T.Text -> T.Text -> m ()), MonadIO m, IsPipeline a) => O.OverloadedMethod PipelineSaveThumbnailMethodInfo a signature where
    overloadedMethod = pipelineSaveThumbnail

instance O.OverloadedMethodInfo PipelineSaveThumbnailMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelineSaveThumbnail",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelineSaveThumbnail"
        })


#endif

-- method Pipeline::set_mode
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pipeline"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mode"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "PipelineFlags" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The mode to set for @pipeline"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_set_mode" ges_pipeline_set_mode :: 
    Ptr Pipeline ->                         -- pipeline : TInterface (Name {namespace = "GES", name = "Pipeline"})
    CUInt ->                                -- mode : TInterface (Name {namespace = "GES", name = "PipelineFlags"})
    IO CInt

-- | Sets the [Pipeline:mode]("GI.GES.Objects.Pipeline#g:attr:mode") of the pipeline.
-- 
-- Note that the pipeline will be set to @/GST_STATE_NULL/@ during this call to
-- perform the necessary changes. You will need to set the state again yourself
-- after calling this.
-- 
-- > **NOTE**: <http://developer.gnome.org/ges/stable/ges_pipeline_set_render_settings Rendering settings> need to be
-- > set before setting /@mode@/ to @/GES_PIPELINE_MODE_RENDER/@ or
-- > @/GES_PIPELINE_MODE_SMART_RENDER/@, the call to this method will fail
-- > otherwise.
pipelineSetMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a) =>
    a
    -- ^ /@pipeline@/: A t'GI.GES.Objects.Pipeline.Pipeline'
    -> [GES.Flags.PipelineFlags]
    -- ^ /@mode@/: The mode to set for /@pipeline@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the mode of /@pipeline@/ was successfully set to /@mode@/.
pipelineSetMode :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsPipeline a) =>
a -> [PipelineFlags] -> m Bool
pipelineSetMode a
pipeline [PipelineFlags]
mode = IO Bool -> m Bool
forall a. IO a -> m a
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 Pipeline
pipeline' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pipeline
    let mode' :: CUInt
mode' = [PipelineFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [PipelineFlags]
mode
    CInt
result <- Ptr Pipeline -> CUInt -> IO CInt
ges_pipeline_set_mode Ptr Pipeline
pipeline' CUInt
mode'
    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
pipeline
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PipelineSetModeMethodInfo
instance (signature ~ ([GES.Flags.PipelineFlags] -> m Bool), MonadIO m, IsPipeline a) => O.OverloadedMethod PipelineSetModeMethodInfo a signature where
    overloadedMethod = pipelineSetMode

instance O.OverloadedMethodInfo PipelineSetModeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelineSetMode",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelineSetMode"
        })


#endif

-- method Pipeline::set_render_settings
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pipeline"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "output_uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The URI to save the #GESPipeline:timeline rendering\nresult to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "profile"
--           , argType =
--               TInterface
--                 Name { namespace = "GstPbutils" , name = "EncodingProfile" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The encoding to use for rendering the #GESPipeline:timeline"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_set_render_settings" ges_pipeline_set_render_settings :: 
    Ptr Pipeline ->                         -- pipeline : TInterface (Name {namespace = "GES", name = "Pipeline"})
    CString ->                              -- output_uri : TBasicType TUTF8
    Ptr GstPbutils.EncodingProfile.EncodingProfile -> -- profile : TInterface (Name {namespace = "GstPbutils", name = "EncodingProfile"})
    IO CInt

-- | Specifies encoding setting to be used by the pipeline to render its
-- [Pipeline:timeline]("GI.GES.Objects.Pipeline#g:attr:timeline"), and where the result should be written to.
-- 
-- This method **must** be called before setting the pipeline mode to
-- @/GES_PIPELINE_MODE_RENDER/@.
pipelineSetRenderSettings ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a, GstPbutils.EncodingProfile.IsEncodingProfile b) =>
    a
    -- ^ /@pipeline@/: A t'GI.GES.Objects.Pipeline.Pipeline'
    -> T.Text
    -- ^ /@outputUri@/: The URI to save the [Pipeline:timeline]("GI.GES.Objects.Pipeline#g:attr:timeline") rendering
    -- result to
    -> b
    -- ^ /@profile@/: The encoding to use for rendering the [Pipeline:timeline]("GI.GES.Objects.Pipeline#g:attr:timeline")
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the settings were successfully set on /@pipeline@/.
pipelineSetRenderSettings :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPipeline a, IsEncodingProfile b) =>
a -> Text -> b -> m Bool
pipelineSetRenderSettings a
pipeline Text
outputUri b
profile = IO Bool -> m Bool
forall a. IO a -> m a
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 Pipeline
pipeline' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pipeline
    CString
outputUri' <- Text -> IO CString
textToCString Text
outputUri
    Ptr EncodingProfile
profile' <- b -> IO (Ptr EncodingProfile)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
profile
    CInt
result <- Ptr Pipeline -> CString -> Ptr EncodingProfile -> IO CInt
ges_pipeline_set_render_settings Ptr Pipeline
pipeline' CString
outputUri' Ptr EncodingProfile
profile'
    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
pipeline
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
profile
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
outputUri'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PipelineSetRenderSettingsMethodInfo
instance (signature ~ (T.Text -> b -> m Bool), MonadIO m, IsPipeline a, GstPbutils.EncodingProfile.IsEncodingProfile b) => O.OverloadedMethod PipelineSetRenderSettingsMethodInfo a signature where
    overloadedMethod = pipelineSetRenderSettings

instance O.OverloadedMethodInfo PipelineSetRenderSettingsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelineSetRenderSettings",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelineSetRenderSettings"
        })


#endif

-- method Pipeline::set_timeline
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pipeline"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Pipeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESPipeline" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "timeline"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "Timeline" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The timeline to set for @pipeline"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_pipeline_set_timeline" ges_pipeline_set_timeline :: 
    Ptr Pipeline ->                         -- pipeline : TInterface (Name {namespace = "GES", name = "Pipeline"})
    Ptr GES.Timeline.Timeline ->            -- timeline : TInterface (Name {namespace = "GES", name = "Timeline"})
    IO CInt

-- | Takes the given timeline and sets it as the [Pipeline:timeline]("GI.GES.Objects.Pipeline#g:attr:timeline") for
-- the pipeline.
-- 
-- Note that you should only call this method once on a given pipeline
-- because a pipeline can not have its [Pipeline:timeline]("GI.GES.Objects.Pipeline#g:attr:timeline") changed after
-- it has been set.
pipelineSetTimeline ::
    (B.CallStack.HasCallStack, MonadIO m, IsPipeline a, GES.Timeline.IsTimeline b) =>
    a
    -- ^ /@pipeline@/: A t'GI.GES.Objects.Pipeline.Pipeline'
    -> b
    -- ^ /@timeline@/: The timeline to set for /@pipeline@/
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@timeline@/ was successfully given to /@pipeline@/.
pipelineSetTimeline :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsPipeline a, IsTimeline b) =>
a -> b -> m Bool
pipelineSetTimeline a
pipeline b
timeline = IO Bool -> m Bool
forall a. IO a -> m a
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 Pipeline
pipeline' <- a -> IO (Ptr Pipeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
pipeline
    Ptr Timeline
timeline' <- b -> IO (Ptr Timeline)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
timeline
    CInt
result <- Ptr Pipeline -> Ptr Timeline -> IO CInt
ges_pipeline_set_timeline Ptr Pipeline
pipeline' Ptr Timeline
timeline'
    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
pipeline
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
timeline
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data PipelineSetTimelineMethodInfo
instance (signature ~ (b -> m Bool), MonadIO m, IsPipeline a, GES.Timeline.IsTimeline b) => O.OverloadedMethod PipelineSetTimelineMethodInfo a signature where
    overloadedMethod = pipelineSetTimeline

instance O.OverloadedMethodInfo PipelineSetTimelineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.Pipeline.pipelineSetTimeline",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-Pipeline.html#v:pipelineSetTimeline"
        })


#endif