{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Represents all the output streams from a particular uri. It is assumed that
-- the URI points to a file of some type.

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

module GI.GES.Objects.UriClip
    ( 

-- * Exported types
    UriClip(..)                             ,
    IsUriClip                               ,
    toUriClip                               ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [add]("GI.GES.Objects.Container#g:method:add"), [addAsset]("GI.GES.Objects.Clip#g:method:addAsset"), [addChildProperty]("GI.GES.Objects.TimelineElement#g:method:addChildProperty"), [addChildToTrack]("GI.GES.Objects.Clip#g:method:addChildToTrack"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [addTopEffect]("GI.GES.Objects.Clip#g:method:addTopEffect"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [copy]("GI.GES.Objects.TimelineElement#g:method:copy"), [edit]("GI.GES.Objects.Container#g:method:edit"), [editFull]("GI.GES.Objects.TimelineElement#g:method:editFull"), [findTrackElement]("GI.GES.Objects.Clip#g:method:findTrackElement"), [findTrackElements]("GI.GES.Objects.Clip#g:method:findTrackElements"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.GES.Interfaces.MetaContainer#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isImage]("GI.GES.Objects.UriClip#g:method:isImage"), [isMuted]("GI.GES.Objects.UriClip#g:method:isMuted"), [listChildrenProperties]("GI.GES.Objects.TimelineElement#g:method:listChildrenProperties"), [lookupChild]("GI.GES.Objects.TimelineElement#g:method:lookupChild"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [moveToLayer]("GI.GES.Objects.Clip#g:method:moveToLayer"), [moveToLayerFull]("GI.GES.Objects.Clip#g:method:moveToLayerFull"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paste]("GI.GES.Objects.TimelineElement#g:method:paste"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerMeta"), [registerMetaBoolean]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaBoolean"), [registerMetaDate]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDate"), [registerMetaDateTime]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDateTime"), [registerMetaDouble]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDouble"), [registerMetaFloat]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaFloat"), [registerMetaInt]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt"), [registerMetaInt64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt64"), [registerMetaString]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaString"), [registerMetaUint]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint"), [registerMetaUint64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint64"), [registerStaticMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerStaticMeta"), [remove]("GI.GES.Objects.Container#g:method:remove"), [removeChildProperty]("GI.GES.Objects.TimelineElement#g:method:removeChildProperty"), [removeTopEffect]("GI.GES.Objects.Clip#g:method:removeTopEffect"), [ripple]("GI.GES.Objects.TimelineElement#g:method:ripple"), [rippleEnd]("GI.GES.Objects.TimelineElement#g:method:rippleEnd"), [rollEnd]("GI.GES.Objects.TimelineElement#g:method:rollEnd"), [rollStart]("GI.GES.Objects.TimelineElement#g:method:rollStart"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [split]("GI.GES.Objects.Clip#g:method:split"), [splitFull]("GI.GES.Objects.Clip#g:method:splitFull"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [trim]("GI.GES.Objects.TimelineElement#g:method:trim"), [ungroup]("GI.GES.Objects.Container#g:method:ungroup"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAsset]("GI.GES.Interfaces.Extractable#g:method:getAsset"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getChildProperty]("GI.GES.Objects.TimelineElement#g:method:getChildProperty"), [getChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:getChildPropertyByPspec"), [getChildren]("GI.GES.Objects.Container#g:method:getChildren"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDate]("GI.GES.Interfaces.MetaContainer#g:method:getDate"), [getDateTime]("GI.GES.Interfaces.MetaContainer#g:method:getDateTime"), [getDouble]("GI.GES.Interfaces.MetaContainer#g:method:getDouble"), [getDuration]("GI.GES.Objects.TimelineElement#g:method:getDuration"), [getDurationLimit]("GI.GES.Objects.Clip#g:method:getDurationLimit"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getId]("GI.GES.Interfaces.Extractable#g:method:getId"), [getInpoint]("GI.GES.Objects.TimelineElement#g:method:getInpoint"), [getInt]("GI.GES.Interfaces.MetaContainer#g:method:getInt"), [getInt64]("GI.GES.Interfaces.MetaContainer#g:method:getInt64"), [getInternalTimeFromTimelineTime]("GI.GES.Objects.Clip#g:method:getInternalTimeFromTimelineTime"), [getLayer]("GI.GES.Objects.Clip#g:method:getLayer"), [getLayerPriority]("GI.GES.Objects.TimelineElement#g:method:getLayerPriority"), [getMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:getMarkerList"), [getMaxDuration]("GI.GES.Objects.TimelineElement#g:method:getMaxDuration"), [getMeta]("GI.GES.Interfaces.MetaContainer#g:method:getMeta"), [getName]("GI.GES.Objects.TimelineElement#g:method:getName"), [getNaturalFramerate]("GI.GES.Objects.TimelineElement#g:method:getNaturalFramerate"), [getParent]("GI.GES.Objects.TimelineElement#g:method:getParent"), [getPriority]("GI.GES.Objects.TimelineElement#g:method:getPriority"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getStart]("GI.GES.Objects.TimelineElement#g:method:getStart"), [getString]("GI.GES.Interfaces.MetaContainer#g:method:getString"), [getSupportedFormats]("GI.GES.Objects.Clip#g:method:getSupportedFormats"), [getTimeline]("GI.GES.Objects.TimelineElement#g:method:getTimeline"), [getTimelineTimeFromInternalTime]("GI.GES.Objects.Clip#g:method:getTimelineTimeFromInternalTime"), [getTimelineTimeFromSourceFrame]("GI.GES.Objects.Clip#g:method:getTimelineTimeFromSourceFrame"), [getTopEffectIndex]("GI.GES.Objects.Clip#g:method:getTopEffectIndex"), [getTopEffectPosition]("GI.GES.Objects.Clip#g:method:getTopEffectPosition"), [getTopEffects]("GI.GES.Objects.Clip#g:method:getTopEffects"), [getToplevelParent]("GI.GES.Objects.TimelineElement#g:method:getToplevelParent"), [getTrackTypes]("GI.GES.Objects.TimelineElement#g:method:getTrackTypes"), [getUint]("GI.GES.Interfaces.MetaContainer#g:method:getUint"), [getUint64]("GI.GES.Interfaces.MetaContainer#g:method:getUint64"), [getUri]("GI.GES.Objects.UriClip#g:method:getUri").
-- 
-- ==== Setters
-- [setAsset]("GI.GES.Interfaces.Extractable#g:method:setAsset"), [setBoolean]("GI.GES.Interfaces.MetaContainer#g:method:setBoolean"), [setChildProperty]("GI.GES.Objects.TimelineElement#g:method:setChildProperty"), [setChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyByPspec"), [setChildPropertyFull]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyFull"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDate]("GI.GES.Interfaces.MetaContainer#g:method:setDate"), [setDateTime]("GI.GES.Interfaces.MetaContainer#g:method:setDateTime"), [setDouble]("GI.GES.Interfaces.MetaContainer#g:method:setDouble"), [setDuration]("GI.GES.Objects.TimelineElement#g:method:setDuration"), [setFloat]("GI.GES.Interfaces.MetaContainer#g:method:setFloat"), [setInpoint]("GI.GES.Objects.TimelineElement#g:method:setInpoint"), [setInt]("GI.GES.Interfaces.MetaContainer#g:method:setInt"), [setInt64]("GI.GES.Interfaces.MetaContainer#g:method:setInt64"), [setIsImage]("GI.GES.Objects.UriClip#g:method:setIsImage"), [setMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:setMarkerList"), [setMaxDuration]("GI.GES.Objects.TimelineElement#g:method:setMaxDuration"), [setMeta]("GI.GES.Interfaces.MetaContainer#g:method:setMeta"), [setMute]("GI.GES.Objects.UriClip#g:method:setMute"), [setName]("GI.GES.Objects.TimelineElement#g:method:setName"), [setParent]("GI.GES.Objects.TimelineElement#g:method:setParent"), [setPriority]("GI.GES.Objects.TimelineElement#g:method:setPriority"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setStart]("GI.GES.Objects.TimelineElement#g:method:setStart"), [setString]("GI.GES.Interfaces.MetaContainer#g:method:setString"), [setSupportedFormats]("GI.GES.Objects.Clip#g:method:setSupportedFormats"), [setTimeline]("GI.GES.Objects.TimelineElement#g:method:setTimeline"), [setTopEffectIndex]("GI.GES.Objects.Clip#g:method:setTopEffectIndex"), [setTopEffectIndexFull]("GI.GES.Objects.Clip#g:method:setTopEffectIndexFull"), [setTopEffectPriority]("GI.GES.Objects.Clip#g:method:setTopEffectPriority"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64").

#if defined(ENABLE_OVERLOADING)
    ResolveUriClipMethod                    ,
#endif

-- ** getUri #method:getUri#

#if defined(ENABLE_OVERLOADING)
    UriClipGetUriMethodInfo                 ,
#endif
    uriClipGetUri                           ,


-- ** isImage #method:isImage#

#if defined(ENABLE_OVERLOADING)
    UriClipIsImageMethodInfo                ,
#endif
    uriClipIsImage                          ,


-- ** isMuted #method:isMuted#

#if defined(ENABLE_OVERLOADING)
    UriClipIsMutedMethodInfo                ,
#endif
    uriClipIsMuted                          ,


-- ** new #method:new#

    uriClipNew                              ,


-- ** setIsImage #method:setIsImage#

#if defined(ENABLE_OVERLOADING)
    UriClipSetIsImageMethodInfo             ,
#endif
    uriClipSetIsImage                       ,


-- ** setMute #method:setMute#

#if defined(ENABLE_OVERLOADING)
    UriClipSetMuteMethodInfo                ,
#endif
    uriClipSetMute                          ,




 -- * Properties


-- ** isImage #attr:isImage#
-- | Whether this uri clip represents a still image or not. This must be set
-- before create_track_elements is called.

#if defined(ENABLE_OVERLOADING)
    UriClipIsImagePropertyInfo              ,
#endif
    constructUriClipIsImage                 ,
    getUriClipIsImage                       ,
    setUriClipIsImage                       ,


-- ** mute #attr:mute#
-- | Whether the sound will be played or not.

#if defined(ENABLE_OVERLOADING)
    UriClipMutePropertyInfo                 ,
#endif
    constructUriClipMute                    ,
    getUriClipMute                          ,
    setUriClipMute                          ,
#if defined(ENABLE_OVERLOADING)
    uriClipMute                             ,
#endif


-- ** supportedFormats #attr:supportedFormats#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    UriClipSupportedFormatsPropertyInfo     ,
#endif
    constructUriClipSupportedFormats        ,
    getUriClipSupportedFormats              ,
    setUriClipSupportedFormats              ,
#if defined(ENABLE_OVERLOADING)
    uriClipSupportedFormats                 ,
#endif


-- ** uri #attr:uri#
-- | The location of the file\/resource to use.

#if defined(ENABLE_OVERLOADING)
    UriClipUriPropertyInfo                  ,
#endif
    constructUriClipUri                     ,
    getUriClipUri                           ,
#if defined(ENABLE_OVERLOADING)
    uriClipUri                              ,
#endif




    ) 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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GES.Callbacks as GES.Callbacks
import {-# SOURCE #-} qualified GI.GES.Enums as GES.Enums
import {-# SOURCE #-} qualified GI.GES.Flags as GES.Flags
import {-# SOURCE #-} qualified GI.GES.Interfaces.Extractable as GES.Extractable
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Asset as GES.Asset
import {-# SOURCE #-} qualified GI.GES.Objects.BaseEffect as GES.BaseEffect
import {-# SOURCE #-} qualified GI.GES.Objects.Clip as GES.Clip
import {-# SOURCE #-} qualified GI.GES.Objects.Container as GES.Container
import {-# SOURCE #-} qualified GI.GES.Objects.Group as GES.Group
import {-# SOURCE #-} qualified GI.GES.Objects.Layer as GES.Layer
import {-# SOURCE #-} qualified GI.GES.Objects.Marker as GES.Marker
import {-# SOURCE #-} qualified GI.GES.Objects.MarkerList as GES.MarkerList
import {-# SOURCE #-} qualified GI.GES.Objects.Operation as GES.Operation
import {-# SOURCE #-} qualified GI.GES.Objects.SourceClip as GES.SourceClip
import {-# SOURCE #-} qualified GI.GES.Objects.Timeline as GES.Timeline
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import {-# SOURCE #-} qualified GI.GES.Objects.Track as GES.Track
import {-# SOURCE #-} qualified GI.GES.Objects.TrackElement as GES.TrackElement
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Date as GLib.Date
import qualified GI.GObject.Objects.InitiallyUnowned as GObject.InitiallyUnowned
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gst.Interfaces.ChildProxy as Gst.ChildProxy
import qualified GI.Gst.Objects.Bin as Gst.Bin
import qualified GI.Gst.Objects.ControlBinding as Gst.ControlBinding
import qualified GI.Gst.Objects.ControlSource as Gst.ControlSource
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.Gst.Objects.Pad as Gst.Pad
import qualified GI.Gst.Structs.Caps as Gst.Caps
import qualified GI.Gst.Structs.DateTime as Gst.DateTime

#else
import {-# SOURCE #-} qualified GI.GES.Flags as GES.Flags
import {-# SOURCE #-} qualified GI.GES.Interfaces.Extractable as GES.Extractable
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Clip as GES.Clip
import {-# SOURCE #-} qualified GI.GES.Objects.Container as GES.Container
import {-# SOURCE #-} qualified GI.GES.Objects.SourceClip as GES.SourceClip
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import qualified GI.GObject.Objects.Object as GObject.Object

#endif

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

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

foreign import ccall "ges_uri_clip_get_type"
    c_ges_uri_clip_get_type :: IO B.Types.GType

instance B.Types.TypedObject UriClip where
    glibType :: IO GType
glibType = IO GType
c_ges_uri_clip_get_type

instance B.Types.GObject UriClip

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

instance O.HasParentTypes UriClip
type instance O.ParentTypes UriClip = '[GES.SourceClip.SourceClip, GES.Clip.Clip, GES.Container.Container, GES.TimelineElement.TimelineElement, GObject.Object.Object, GES.Extractable.Extractable, GES.MetaContainer.MetaContainer]

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

-- | Convert 'UriClip' 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 UriClip) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ges_uri_clip_get_type
    gvalueSet_ :: Ptr GValue -> Maybe UriClip -> IO ()
gvalueSet_ Ptr GValue
gv Maybe UriClip
P.Nothing = Ptr GValue -> Ptr UriClip -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr UriClip
forall a. Ptr a
FP.nullPtr :: FP.Ptr UriClip)
    gvalueSet_ Ptr GValue
gv (P.Just UriClip
obj) = UriClip -> (Ptr UriClip -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UriClip
obj (Ptr GValue -> Ptr UriClip -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe UriClip)
gvalueGet_ Ptr GValue
gv = do
        Ptr UriClip
ptr <- Ptr GValue -> IO (Ptr UriClip)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr UriClip)
        if Ptr UriClip
ptr Ptr UriClip -> Ptr UriClip -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr UriClip
forall a. Ptr a
FP.nullPtr
        then UriClip -> Maybe UriClip
forall a. a -> Maybe a
P.Just (UriClip -> Maybe UriClip) -> IO UriClip -> IO (Maybe UriClip)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr UriClip -> UriClip) -> Ptr UriClip -> IO UriClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr UriClip -> UriClip
UriClip Ptr UriClip
ptr
        else Maybe UriClip -> IO (Maybe UriClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UriClip
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveUriClipMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveUriClipMethod "add" o = GES.Container.ContainerAddMethodInfo
    ResolveUriClipMethod "addAsset" o = GES.Clip.ClipAddAssetMethodInfo
    ResolveUriClipMethod "addChildProperty" o = GES.TimelineElement.TimelineElementAddChildPropertyMethodInfo
    ResolveUriClipMethod "addChildToTrack" o = GES.Clip.ClipAddChildToTrackMethodInfo
    ResolveUriClipMethod "addMetasFromString" o = GES.MetaContainer.MetaContainerAddMetasFromStringMethodInfo
    ResolveUriClipMethod "addTopEffect" o = GES.Clip.ClipAddTopEffectMethodInfo
    ResolveUriClipMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveUriClipMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveUriClipMethod "checkMetaRegistered" o = GES.MetaContainer.MetaContainerCheckMetaRegisteredMethodInfo
    ResolveUriClipMethod "copy" o = GES.TimelineElement.TimelineElementCopyMethodInfo
    ResolveUriClipMethod "edit" o = GES.Container.ContainerEditMethodInfo
    ResolveUriClipMethod "editFull" o = GES.TimelineElement.TimelineElementEditFullMethodInfo
    ResolveUriClipMethod "findTrackElement" o = GES.Clip.ClipFindTrackElementMethodInfo
    ResolveUriClipMethod "findTrackElements" o = GES.Clip.ClipFindTrackElementsMethodInfo
    ResolveUriClipMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveUriClipMethod "foreach" o = GES.MetaContainer.MetaContainerForeachMethodInfo
    ResolveUriClipMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveUriClipMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveUriClipMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveUriClipMethod "isImage" o = UriClipIsImageMethodInfo
    ResolveUriClipMethod "isMuted" o = UriClipIsMutedMethodInfo
    ResolveUriClipMethod "listChildrenProperties" o = GES.TimelineElement.TimelineElementListChildrenPropertiesMethodInfo
    ResolveUriClipMethod "lookupChild" o = GES.TimelineElement.TimelineElementLookupChildMethodInfo
    ResolveUriClipMethod "metasToString" o = GES.MetaContainer.MetaContainerMetasToStringMethodInfo
    ResolveUriClipMethod "moveToLayer" o = GES.Clip.ClipMoveToLayerMethodInfo
    ResolveUriClipMethod "moveToLayerFull" o = GES.Clip.ClipMoveToLayerFullMethodInfo
    ResolveUriClipMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveUriClipMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveUriClipMethod "paste" o = GES.TimelineElement.TimelineElementPasteMethodInfo
    ResolveUriClipMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveUriClipMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveUriClipMethod "registerMeta" o = GES.MetaContainer.MetaContainerRegisterMetaMethodInfo
    ResolveUriClipMethod "registerMetaBoolean" o = GES.MetaContainer.MetaContainerRegisterMetaBooleanMethodInfo
    ResolveUriClipMethod "registerMetaDate" o = GES.MetaContainer.MetaContainerRegisterMetaDateMethodInfo
    ResolveUriClipMethod "registerMetaDateTime" o = GES.MetaContainer.MetaContainerRegisterMetaDateTimeMethodInfo
    ResolveUriClipMethod "registerMetaDouble" o = GES.MetaContainer.MetaContainerRegisterMetaDoubleMethodInfo
    ResolveUriClipMethod "registerMetaFloat" o = GES.MetaContainer.MetaContainerRegisterMetaFloatMethodInfo
    ResolveUriClipMethod "registerMetaInt" o = GES.MetaContainer.MetaContainerRegisterMetaIntMethodInfo
    ResolveUriClipMethod "registerMetaInt64" o = GES.MetaContainer.MetaContainerRegisterMetaInt64MethodInfo
    ResolveUriClipMethod "registerMetaString" o = GES.MetaContainer.MetaContainerRegisterMetaStringMethodInfo
    ResolveUriClipMethod "registerMetaUint" o = GES.MetaContainer.MetaContainerRegisterMetaUintMethodInfo
    ResolveUriClipMethod "registerMetaUint64" o = GES.MetaContainer.MetaContainerRegisterMetaUint64MethodInfo
    ResolveUriClipMethod "registerStaticMeta" o = GES.MetaContainer.MetaContainerRegisterStaticMetaMethodInfo
    ResolveUriClipMethod "remove" o = GES.Container.ContainerRemoveMethodInfo
    ResolveUriClipMethod "removeChildProperty" o = GES.TimelineElement.TimelineElementRemoveChildPropertyMethodInfo
    ResolveUriClipMethod "removeTopEffect" o = GES.Clip.ClipRemoveTopEffectMethodInfo
    ResolveUriClipMethod "ripple" o = GES.TimelineElement.TimelineElementRippleMethodInfo
    ResolveUriClipMethod "rippleEnd" o = GES.TimelineElement.TimelineElementRippleEndMethodInfo
    ResolveUriClipMethod "rollEnd" o = GES.TimelineElement.TimelineElementRollEndMethodInfo
    ResolveUriClipMethod "rollStart" o = GES.TimelineElement.TimelineElementRollStartMethodInfo
    ResolveUriClipMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveUriClipMethod "split" o = GES.Clip.ClipSplitMethodInfo
    ResolveUriClipMethod "splitFull" o = GES.Clip.ClipSplitFullMethodInfo
    ResolveUriClipMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveUriClipMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveUriClipMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveUriClipMethod "trim" o = GES.TimelineElement.TimelineElementTrimMethodInfo
    ResolveUriClipMethod "ungroup" o = GES.Container.ContainerUngroupMethodInfo
    ResolveUriClipMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveUriClipMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveUriClipMethod "getAsset" o = GES.Extractable.ExtractableGetAssetMethodInfo
    ResolveUriClipMethod "getBoolean" o = GES.MetaContainer.MetaContainerGetBooleanMethodInfo
    ResolveUriClipMethod "getChildProperty" o = GES.TimelineElement.TimelineElementGetChildPropertyMethodInfo
    ResolveUriClipMethod "getChildPropertyByPspec" o = GES.TimelineElement.TimelineElementGetChildPropertyByPspecMethodInfo
    ResolveUriClipMethod "getChildren" o = GES.Container.ContainerGetChildrenMethodInfo
    ResolveUriClipMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveUriClipMethod "getDate" o = GES.MetaContainer.MetaContainerGetDateMethodInfo
    ResolveUriClipMethod "getDateTime" o = GES.MetaContainer.MetaContainerGetDateTimeMethodInfo
    ResolveUriClipMethod "getDouble" o = GES.MetaContainer.MetaContainerGetDoubleMethodInfo
    ResolveUriClipMethod "getDuration" o = GES.TimelineElement.TimelineElementGetDurationMethodInfo
    ResolveUriClipMethod "getDurationLimit" o = GES.Clip.ClipGetDurationLimitMethodInfo
    ResolveUriClipMethod "getFloat" o = GES.MetaContainer.MetaContainerGetFloatMethodInfo
    ResolveUriClipMethod "getId" o = GES.Extractable.ExtractableGetIdMethodInfo
    ResolveUriClipMethod "getInpoint" o = GES.TimelineElement.TimelineElementGetInpointMethodInfo
    ResolveUriClipMethod "getInt" o = GES.MetaContainer.MetaContainerGetIntMethodInfo
    ResolveUriClipMethod "getInt64" o = GES.MetaContainer.MetaContainerGetInt64MethodInfo
    ResolveUriClipMethod "getInternalTimeFromTimelineTime" o = GES.Clip.ClipGetInternalTimeFromTimelineTimeMethodInfo
    ResolveUriClipMethod "getLayer" o = GES.Clip.ClipGetLayerMethodInfo
    ResolveUriClipMethod "getLayerPriority" o = GES.TimelineElement.TimelineElementGetLayerPriorityMethodInfo
    ResolveUriClipMethod "getMarkerList" o = GES.MetaContainer.MetaContainerGetMarkerListMethodInfo
    ResolveUriClipMethod "getMaxDuration" o = GES.TimelineElement.TimelineElementGetMaxDurationMethodInfo
    ResolveUriClipMethod "getMeta" o = GES.MetaContainer.MetaContainerGetMetaMethodInfo
    ResolveUriClipMethod "getName" o = GES.TimelineElement.TimelineElementGetNameMethodInfo
    ResolveUriClipMethod "getNaturalFramerate" o = GES.TimelineElement.TimelineElementGetNaturalFramerateMethodInfo
    ResolveUriClipMethod "getParent" o = GES.TimelineElement.TimelineElementGetParentMethodInfo
    ResolveUriClipMethod "getPriority" o = GES.TimelineElement.TimelineElementGetPriorityMethodInfo
    ResolveUriClipMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveUriClipMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveUriClipMethod "getStart" o = GES.TimelineElement.TimelineElementGetStartMethodInfo
    ResolveUriClipMethod "getString" o = GES.MetaContainer.MetaContainerGetStringMethodInfo
    ResolveUriClipMethod "getSupportedFormats" o = GES.Clip.ClipGetSupportedFormatsMethodInfo
    ResolveUriClipMethod "getTimeline" o = GES.TimelineElement.TimelineElementGetTimelineMethodInfo
    ResolveUriClipMethod "getTimelineTimeFromInternalTime" o = GES.Clip.ClipGetTimelineTimeFromInternalTimeMethodInfo
    ResolveUriClipMethod "getTimelineTimeFromSourceFrame" o = GES.Clip.ClipGetTimelineTimeFromSourceFrameMethodInfo
    ResolveUriClipMethod "getTopEffectIndex" o = GES.Clip.ClipGetTopEffectIndexMethodInfo
    ResolveUriClipMethod "getTopEffectPosition" o = GES.Clip.ClipGetTopEffectPositionMethodInfo
    ResolveUriClipMethod "getTopEffects" o = GES.Clip.ClipGetTopEffectsMethodInfo
    ResolveUriClipMethod "getToplevelParent" o = GES.TimelineElement.TimelineElementGetToplevelParentMethodInfo
    ResolveUriClipMethod "getTrackTypes" o = GES.TimelineElement.TimelineElementGetTrackTypesMethodInfo
    ResolveUriClipMethod "getUint" o = GES.MetaContainer.MetaContainerGetUintMethodInfo
    ResolveUriClipMethod "getUint64" o = GES.MetaContainer.MetaContainerGetUint64MethodInfo
    ResolveUriClipMethod "getUri" o = UriClipGetUriMethodInfo
    ResolveUriClipMethod "setAsset" o = GES.Extractable.ExtractableSetAssetMethodInfo
    ResolveUriClipMethod "setBoolean" o = GES.MetaContainer.MetaContainerSetBooleanMethodInfo
    ResolveUriClipMethod "setChildProperty" o = GES.TimelineElement.TimelineElementSetChildPropertyMethodInfo
    ResolveUriClipMethod "setChildPropertyByPspec" o = GES.TimelineElement.TimelineElementSetChildPropertyByPspecMethodInfo
    ResolveUriClipMethod "setChildPropertyFull" o = GES.TimelineElement.TimelineElementSetChildPropertyFullMethodInfo
    ResolveUriClipMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveUriClipMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveUriClipMethod "setDate" o = GES.MetaContainer.MetaContainerSetDateMethodInfo
    ResolveUriClipMethod "setDateTime" o = GES.MetaContainer.MetaContainerSetDateTimeMethodInfo
    ResolveUriClipMethod "setDouble" o = GES.MetaContainer.MetaContainerSetDoubleMethodInfo
    ResolveUriClipMethod "setDuration" o = GES.TimelineElement.TimelineElementSetDurationMethodInfo
    ResolveUriClipMethod "setFloat" o = GES.MetaContainer.MetaContainerSetFloatMethodInfo
    ResolveUriClipMethod "setInpoint" o = GES.TimelineElement.TimelineElementSetInpointMethodInfo
    ResolveUriClipMethod "setInt" o = GES.MetaContainer.MetaContainerSetIntMethodInfo
    ResolveUriClipMethod "setInt64" o = GES.MetaContainer.MetaContainerSetInt64MethodInfo
    ResolveUriClipMethod "setIsImage" o = UriClipSetIsImageMethodInfo
    ResolveUriClipMethod "setMarkerList" o = GES.MetaContainer.MetaContainerSetMarkerListMethodInfo
    ResolveUriClipMethod "setMaxDuration" o = GES.TimelineElement.TimelineElementSetMaxDurationMethodInfo
    ResolveUriClipMethod "setMeta" o = GES.MetaContainer.MetaContainerSetMetaMethodInfo
    ResolveUriClipMethod "setMute" o = UriClipSetMuteMethodInfo
    ResolveUriClipMethod "setName" o = GES.TimelineElement.TimelineElementSetNameMethodInfo
    ResolveUriClipMethod "setParent" o = GES.TimelineElement.TimelineElementSetParentMethodInfo
    ResolveUriClipMethod "setPriority" o = GES.TimelineElement.TimelineElementSetPriorityMethodInfo
    ResolveUriClipMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveUriClipMethod "setStart" o = GES.TimelineElement.TimelineElementSetStartMethodInfo
    ResolveUriClipMethod "setString" o = GES.MetaContainer.MetaContainerSetStringMethodInfo
    ResolveUriClipMethod "setSupportedFormats" o = GES.Clip.ClipSetSupportedFormatsMethodInfo
    ResolveUriClipMethod "setTimeline" o = GES.TimelineElement.TimelineElementSetTimelineMethodInfo
    ResolveUriClipMethod "setTopEffectIndex" o = GES.Clip.ClipSetTopEffectIndexMethodInfo
    ResolveUriClipMethod "setTopEffectIndexFull" o = GES.Clip.ClipSetTopEffectIndexFullMethodInfo
    ResolveUriClipMethod "setTopEffectPriority" o = GES.Clip.ClipSetTopEffectPriorityMethodInfo
    ResolveUriClipMethod "setUint" o = GES.MetaContainer.MetaContainerSetUintMethodInfo
    ResolveUriClipMethod "setUint64" o = GES.MetaContainer.MetaContainerSetUint64MethodInfo
    ResolveUriClipMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

--- XXX Duplicated object with different types:
  --- Name {namespace = "GES", name = "UriClip"} -> Property {propName = "supported-formats", propType = TInterface (Name {namespace = "GES", name = "TrackType"}), propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, propDeprecated = Nothing}
  --- Name {namespace = "GES", name = "Clip"} -> Property {propName = "supported-formats", propType = TInterface (Name {namespace = "GES", name = "TrackType"}), propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propReadNullable = Just False, propWriteNullable = Just False, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The #GESTrackType-s that the clip supports, which it can create\n#GESTrackElement-s for. Note that this can be a combination of\n#GESTrackType flags to indicate support for several\n#GESTrackElement:track-type elements.", sinceVersion = Nothing}, propDeprecated = Nothing}
-- VVV Prop "is-image"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@is-image@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' uriClip #isImage
-- @
getUriClipIsImage :: (MonadIO m, IsUriClip o) => o -> m Bool
getUriClipIsImage :: forall (m :: * -> *) o. (MonadIO m, IsUriClip o) => o -> m Bool
getUriClipIsImage o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"is-image"

-- | Set the value of the “@is-image@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' uriClip [ #isImage 'Data.GI.Base.Attributes.:=' value ]
-- @
setUriClipIsImage :: (MonadIO m, IsUriClip o) => o -> Bool -> m ()
setUriClipIsImage :: forall (m :: * -> *) o.
(MonadIO m, IsUriClip o) =>
o -> Bool -> m ()
setUriClipIsImage o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"is-image" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@is-image@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUriClipIsImage :: (IsUriClip o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructUriClipIsImage :: forall o (m :: * -> *).
(IsUriClip o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructUriClipIsImage Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"is-image" Bool
val

#if defined(ENABLE_OVERLOADING)
data UriClipIsImagePropertyInfo
instance AttrInfo UriClipIsImagePropertyInfo where
    type AttrAllowedOps UriClipIsImagePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint UriClipIsImagePropertyInfo = IsUriClip
    type AttrSetTypeConstraint UriClipIsImagePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint UriClipIsImagePropertyInfo = (~) Bool
    type AttrTransferType UriClipIsImagePropertyInfo = Bool
    type AttrGetType UriClipIsImagePropertyInfo = Bool
    type AttrLabel UriClipIsImagePropertyInfo = "is-image"
    type AttrOrigin UriClipIsImagePropertyInfo = UriClip
    attrGet = getUriClipIsImage
    attrSet = setUriClipIsImage
    attrTransfer _ v = do
        return v
    attrConstruct = constructUriClipIsImage
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClip.isImage"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-UriClip.html#g:attr:isImage"
        })
#endif

-- VVV Prop "mute"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Just False)

-- | Get the value of the “@mute@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' uriClip #mute
-- @
getUriClipMute :: (MonadIO m, IsUriClip o) => o -> m Bool
getUriClipMute :: forall (m :: * -> *) o. (MonadIO m, IsUriClip o) => o -> m Bool
getUriClipMute o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"mute"

-- | Set the value of the “@mute@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' uriClip [ #mute 'Data.GI.Base.Attributes.:=' value ]
-- @
setUriClipMute :: (MonadIO m, IsUriClip o) => o -> Bool -> m ()
setUriClipMute :: forall (m :: * -> *) o.
(MonadIO m, IsUriClip o) =>
o -> Bool -> m ()
setUriClipMute o
obj Bool
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 -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"mute" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@mute@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUriClipMute :: (IsUriClip o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructUriClipMute :: forall o (m :: * -> *).
(IsUriClip o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructUriClipMute Bool
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 -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"mute" Bool
val

#if defined(ENABLE_OVERLOADING)
data UriClipMutePropertyInfo
instance AttrInfo UriClipMutePropertyInfo where
    type AttrAllowedOps UriClipMutePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint UriClipMutePropertyInfo = IsUriClip
    type AttrSetTypeConstraint UriClipMutePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint UriClipMutePropertyInfo = (~) Bool
    type AttrTransferType UriClipMutePropertyInfo = Bool
    type AttrGetType UriClipMutePropertyInfo = Bool
    type AttrLabel UriClipMutePropertyInfo = "mute"
    type AttrOrigin UriClipMutePropertyInfo = UriClip
    attrGet = getUriClipMute
    attrSet = setUriClipMute
    attrTransfer _ v = do
        return v
    attrConstruct = constructUriClipMute
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClip.mute"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-UriClip.html#g:attr:mute"
        })
#endif

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data UriClipSupportedFormatsPropertyInfo
instance AttrInfo UriClipSupportedFormatsPropertyInfo where
    type AttrAllowedOps UriClipSupportedFormatsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint UriClipSupportedFormatsPropertyInfo = IsUriClip
    type AttrSetTypeConstraint UriClipSupportedFormatsPropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferTypeConstraint UriClipSupportedFormatsPropertyInfo = (~) [GES.Flags.TrackType]
    type AttrTransferType UriClipSupportedFormatsPropertyInfo = [GES.Flags.TrackType]
    type AttrGetType UriClipSupportedFormatsPropertyInfo = [GES.Flags.TrackType]
    type AttrLabel UriClipSupportedFormatsPropertyInfo = "supported-formats"
    type AttrOrigin UriClipSupportedFormatsPropertyInfo = UriClip
    attrGet = getUriClipSupportedFormats
    attrSet = setUriClipSupportedFormats
    attrTransfer _ v = do
        return v
    attrConstruct = constructUriClipSupportedFormats
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClip.supportedFormats"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-UriClip.html#g:attr:supportedFormats"
        })
#endif

-- VVV Prop "uri"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@uri@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' uriClip #uri
-- @
getUriClipUri :: (MonadIO m, IsUriClip o) => o -> m T.Text
getUriClipUri :: forall (m :: * -> *) o. (MonadIO m, IsUriClip o) => o -> m Text
getUriClipUri o
obj = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Text) -> IO Text
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getUriClipUri" (IO (Maybe Text) -> IO Text) -> IO (Maybe Text) -> IO Text
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"uri"

-- | Construct a `GValueConstruct` with valid value for the “@uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUriClipUri :: (IsUriClip o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructUriClipUri :: forall o (m :: * -> *).
(IsUriClip o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructUriClipUri Text
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 Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"uri" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data UriClipUriPropertyInfo
instance AttrInfo UriClipUriPropertyInfo where
    type AttrAllowedOps UriClipUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint UriClipUriPropertyInfo = IsUriClip
    type AttrSetTypeConstraint UriClipUriPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint UriClipUriPropertyInfo = (~) T.Text
    type AttrTransferType UriClipUriPropertyInfo = T.Text
    type AttrGetType UriClipUriPropertyInfo = T.Text
    type AttrLabel UriClipUriPropertyInfo = "uri"
    type AttrOrigin UriClipUriPropertyInfo = UriClip
    attrGet = getUriClipUri
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructUriClipUri
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClip.uri"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Objects-UriClip.html#g:attr:uri"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UriClip
type instance O.AttributeList UriClip = UriClipAttributeList
type UriClipAttributeList = ('[ '("duration", GES.TimelineElement.TimelineElementDurationPropertyInfo), '("durationLimit", GES.Clip.ClipDurationLimitPropertyInfo), '("height", GES.Container.ContainerHeightPropertyInfo), '("inPoint", GES.TimelineElement.TimelineElementInPointPropertyInfo), '("isImage", UriClipIsImagePropertyInfo), '("layer", GES.Clip.ClipLayerPropertyInfo), '("maxDuration", GES.TimelineElement.TimelineElementMaxDurationPropertyInfo), '("mute", UriClipMutePropertyInfo), '("name", GES.TimelineElement.TimelineElementNamePropertyInfo), '("parent", GES.TimelineElement.TimelineElementParentPropertyInfo), '("priority", GES.TimelineElement.TimelineElementPriorityPropertyInfo), '("serialize", GES.TimelineElement.TimelineElementSerializePropertyInfo), '("start", GES.TimelineElement.TimelineElementStartPropertyInfo), '("supportedFormats", UriClipSupportedFormatsPropertyInfo), '("timeline", GES.TimelineElement.TimelineElementTimelinePropertyInfo), '("uri", UriClipUriPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
uriClipMute :: AttrLabelProxy "mute"
uriClipMute = AttrLabelProxy

uriClipSupportedFormats :: AttrLabelProxy "supportedFormats"
uriClipSupportedFormats = AttrLabelProxy

uriClipUri :: AttrLabelProxy "uri"
uriClipUri = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList UriClip = UriClipSignalList
type UriClipSignalList = ('[ '("childAdded", GES.Container.ContainerChildAddedSignalInfo), '("childPropertyAdded", GES.TimelineElement.TimelineElementChildPropertyAddedSignalInfo), '("childPropertyRemoved", GES.TimelineElement.TimelineElementChildPropertyRemovedSignalInfo), '("childRemoved", GES.Container.ContainerChildRemovedSignalInfo), '("deepNotify", GES.TimelineElement.TimelineElementDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("notifyMeta", GES.MetaContainer.MetaContainerNotifyMetaSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method UriClip::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the URI the source should control"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GES" , name = "UriClip" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_new" ges_uri_clip_new :: 
    CString ->                              -- uri : TBasicType TUTF8
    IO (Ptr UriClip)

-- | Creates a new t'GI.GES.Objects.UriClip.UriClip' for the provided /@uri@/.
-- 
-- > **WARNING**: This function might \'discover\` /@uri@/ **synchrounously**, it is
-- > an IO and processing intensive task that you probably don\'t want to run in
-- > an application mainloop. Have a look at @/ges_asset_request_async/@ to see how
-- > to make that operation happen **asynchronously**.
uriClipNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@uri@/: the URI the source should control
    -> m (Maybe UriClip)
    -- ^ __Returns:__ The newly created t'GI.GES.Objects.UriClip.UriClip', or
    -- 'P.Nothing' if there was an error.
uriClipNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe UriClip)
uriClipNew Text
uri = IO (Maybe UriClip) -> m (Maybe UriClip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe UriClip) -> m (Maybe UriClip))
-> IO (Maybe UriClip) -> m (Maybe UriClip)
forall a b. (a -> b) -> a -> b
$ do
    CString
uri' <- Text -> IO CString
textToCString Text
uri
    Ptr UriClip
result <- CString -> IO (Ptr UriClip)
ges_uri_clip_new CString
uri'
    Maybe UriClip
maybeResult <- Ptr UriClip -> (Ptr UriClip -> IO UriClip) -> IO (Maybe UriClip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr UriClip
result ((Ptr UriClip -> IO UriClip) -> IO (Maybe UriClip))
-> (Ptr UriClip -> IO UriClip) -> IO (Maybe UriClip)
forall a b. (a -> b) -> a -> b
$ \Ptr UriClip
result' -> do
        UriClip
result'' <- ((ManagedPtr UriClip -> UriClip) -> Ptr UriClip -> IO UriClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr UriClip -> UriClip
UriClip) Ptr UriClip
result'
        UriClip -> IO UriClip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return UriClip
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
    Maybe UriClip -> IO (Maybe UriClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe UriClip
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method UriClip::get_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESUriClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_get_uri" ges_uri_clip_get_uri :: 
    Ptr UriClip ->                          -- self : TInterface (Name {namespace = "GES", name = "UriClip"})
    IO CString

-- | Get the location of the resource.
uriClipGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.UriClip.UriClip'
    -> m T.Text
    -- ^ __Returns:__ The location of the resource.
uriClipGetUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClip a) =>
a -> m Text
uriClipGetUri a
self = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr UriClip
self' <- a -> IO (Ptr UriClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr UriClip -> IO CString
ges_uri_clip_get_uri Ptr UriClip
self'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriClipGetUri" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data UriClipGetUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsUriClip a) => O.OverloadedMethod UriClipGetUriMethodInfo a signature where
    overloadedMethod = uriClipGetUri

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


#endif

-- method UriClip::is_image
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESUriClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_is_image" ges_uri_clip_is_image :: 
    Ptr UriClip ->                          -- self : TInterface (Name {namespace = "GES", name = "UriClip"})
    IO CInt

-- | Lets you know if /@self@/ is an image or not.
uriClipIsImage ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.UriClip.UriClip'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@self@/ is a still image 'P.False' otherwise.
uriClipIsImage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClip a) =>
a -> m Bool
uriClipIsImage a
self = 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 UriClip
self' <- a -> IO (Ptr UriClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr UriClip -> IO CInt
ges_uri_clip_is_image Ptr UriClip
self'
    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
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UriClipIsImageMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUriClip a) => O.OverloadedMethod UriClipIsImageMethodInfo a signature where
    overloadedMethod = uriClipIsImage

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


#endif

-- method UriClip::is_muted
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESUriClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_is_muted" ges_uri_clip_is_muted :: 
    Ptr UriClip ->                          -- self : TInterface (Name {namespace = "GES", name = "UriClip"})
    IO CInt

-- | Lets you know if the audio track of /@self@/ is muted or not.
uriClipIsMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.UriClip.UriClip'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the audio track of /@self@/ is muted, 'P.False' otherwise.
uriClipIsMuted :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClip a) =>
a -> m Bool
uriClipIsMuted a
self = 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 UriClip
self' <- a -> IO (Ptr UriClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr UriClip -> IO CInt
ges_uri_clip_is_muted Ptr UriClip
self'
    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
self
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UriClipIsMutedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUriClip a) => O.OverloadedMethod UriClipIsMutedMethodInfo a signature where
    overloadedMethod = uriClipIsMuted

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


#endif

-- method UriClip::set_is_image
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESUriClip" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "is_image"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE if @self is a still image, %FALSE otherwise"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_set_is_image" ges_uri_clip_set_is_image :: 
    Ptr UriClip ->                          -- self : TInterface (Name {namespace = "GES", name = "UriClip"})
    CInt ->                                 -- is_image : TBasicType TBoolean
    IO ()

-- | Sets whether the clip is a still image or not.
uriClipSetIsImage ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.UriClip.UriClip'
    -> Bool
    -- ^ /@isImage@/: 'P.True' if /@self@/ is a still image, 'P.False' otherwise
    -> m ()
uriClipSetIsImage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClip a) =>
a -> Bool -> m ()
uriClipSetIsImage a
self Bool
isImage = 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 UriClip
self' <- a -> IO (Ptr UriClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let isImage' :: CInt
isImage' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isImage
    Ptr UriClip -> CInt -> IO ()
ges_uri_clip_set_is_image Ptr UriClip
self' CInt
isImage'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UriClipSetIsImageMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsUriClip a) => O.OverloadedMethod UriClipSetIsImageMethodInfo a signature where
    overloadedMethod = uriClipSetIsImage

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


#endif

-- method UriClip::set_mute
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GESUriClip on which to mute or unmute the audio track"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "mute"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "%TRUE to mute @self audio track, %FALSE to unmute it"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_set_mute" ges_uri_clip_set_mute :: 
    Ptr UriClip ->                          -- self : TInterface (Name {namespace = "GES", name = "UriClip"})
    CInt ->                                 -- mute : TBasicType TBoolean
    IO ()

-- | Sets whether the audio track of this clip is muted or not.
uriClipSetMute ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.UriClip.UriClip' on which to mute or unmute the audio track
    -> Bool
    -- ^ /@mute@/: 'P.True' to mute /@self@/ audio track, 'P.False' to unmute it
    -> m ()
uriClipSetMute :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClip a) =>
a -> Bool -> m ()
uriClipSetMute a
self Bool
mute = 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 UriClip
self' <- a -> IO (Ptr UriClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let mute' :: CInt
mute' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
mute
    Ptr UriClip -> CInt -> IO ()
ges_uri_clip_set_mute Ptr UriClip
self' CInt
mute'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data UriClipSetMuteMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsUriClip a) => O.OverloadedMethod UriClipSetMuteMethodInfo a signature where
    overloadedMethod = uriClipSetMute

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


#endif