{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Creates an object that mixes together the two underlying objects, A and B.
-- The A object is assumed to have a higher prioirity (lower number) than the
-- B object. At the transition in point, only A will be visible, and by the
-- end only B will be visible.
-- 
-- The shape of the video transition depends on the value of the \"vtype\"
-- property. The default value is \"crossfade\". For audio, only \"crossfade\" is
-- supported.
-- 
-- The ID of the ExtractableType is the nickname of the vtype property value. Note
-- that this value can be changed after creation and the GESExtractable.asset value
-- will be updated when needed.

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

module GI.GES.Objects.TransitionClip
    ( 

-- * Exported types
    TransitionClip(..)                      ,
    IsTransitionClip                        ,
    toTransitionClip                        ,


 -- * 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"), [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").
-- 
-- ==== 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"), [setMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:setMarkerList"), [setMaxDuration]("GI.GES.Objects.TimelineElement#g:method:setMaxDuration"), [setMeta]("GI.GES.Interfaces.MetaContainer#g:method:setMeta"), [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)
    ResolveTransitionClipMethod             ,
#endif

-- ** new #method:new#

    transitionClipNew                       ,


-- ** newForNick #method:newForNick#

    transitionClipNewForNick                ,




 -- * Properties


-- ** vtype #attr:vtype#
-- | a t'GI.GES.Enums.VideoStandardTransitionType' representing the wipe to use

#if defined(ENABLE_OVERLOADING)
    TransitionClipVtypePropertyInfo         ,
#endif
    constructTransitionClipVtype            ,
    getTransitionClipVtype                  ,
    setTransitionClipVtype                  ,
#if defined(ENABLE_OVERLOADING)
    transitionClipVtype                     ,
#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 {-# SOURCE #-} qualified GI.GES.Enums as GES.Enums
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.BaseTransitionClip as GES.BaseTransitionClip
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.OperationClip as GES.OperationClip
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "ges_transition_clip_get_type"
    c_ges_transition_clip_get_type :: IO B.Types.GType

instance B.Types.TypedObject TransitionClip where
    glibType :: IO GType
glibType = IO GType
c_ges_transition_clip_get_type

instance B.Types.GObject TransitionClip

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

instance O.HasParentTypes TransitionClip
type instance O.ParentTypes TransitionClip = '[GES.BaseTransitionClip.BaseTransitionClip, GES.OperationClip.OperationClip, GES.Clip.Clip, GES.Container.Container, GES.TimelineElement.TimelineElement, GObject.Object.Object, GES.Extractable.Extractable, GES.MetaContainer.MetaContainer]

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

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

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

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

#endif

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

#endif

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

-- | Get the value of the “@vtype@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' transitionClip #vtype
-- @
getTransitionClipVtype :: (MonadIO m, IsTransitionClip o) => o -> m GES.Enums.VideoStandardTransitionType
getTransitionClipVtype :: forall (m :: * -> *) o.
(MonadIO m, IsTransitionClip o) =>
o -> m VideoStandardTransitionType
getTransitionClipVtype o
obj = IO VideoStandardTransitionType -> m VideoStandardTransitionType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO VideoStandardTransitionType -> m VideoStandardTransitionType)
-> IO VideoStandardTransitionType -> m VideoStandardTransitionType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO VideoStandardTransitionType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"vtype"

-- | Set the value of the “@vtype@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' transitionClip [ #vtype 'Data.GI.Base.Attributes.:=' value ]
-- @
setTransitionClipVtype :: (MonadIO m, IsTransitionClip o) => o -> GES.Enums.VideoStandardTransitionType -> m ()
setTransitionClipVtype :: forall (m :: * -> *) o.
(MonadIO m, IsTransitionClip o) =>
o -> VideoStandardTransitionType -> m ()
setTransitionClipVtype o
obj VideoStandardTransitionType
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 -> VideoStandardTransitionType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"vtype" VideoStandardTransitionType
val

-- | Construct a `GValueConstruct` with valid value for the “@vtype@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTransitionClipVtype :: (IsTransitionClip o, MIO.MonadIO m) => GES.Enums.VideoStandardTransitionType -> m (GValueConstruct o)
constructTransitionClipVtype :: forall o (m :: * -> *).
(IsTransitionClip o, MonadIO m) =>
VideoStandardTransitionType -> m (GValueConstruct o)
constructTransitionClipVtype VideoStandardTransitionType
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 -> VideoStandardTransitionType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"vtype" VideoStandardTransitionType
val

#if defined(ENABLE_OVERLOADING)
data TransitionClipVtypePropertyInfo
instance AttrInfo TransitionClipVtypePropertyInfo where
    type AttrAllowedOps TransitionClipVtypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TransitionClipVtypePropertyInfo = IsTransitionClip
    type AttrSetTypeConstraint TransitionClipVtypePropertyInfo = (~) GES.Enums.VideoStandardTransitionType
    type AttrTransferTypeConstraint TransitionClipVtypePropertyInfo = (~) GES.Enums.VideoStandardTransitionType
    type AttrTransferType TransitionClipVtypePropertyInfo = GES.Enums.VideoStandardTransitionType
    type AttrGetType TransitionClipVtypePropertyInfo = GES.Enums.VideoStandardTransitionType
    type AttrLabel TransitionClipVtypePropertyInfo = "vtype"
    type AttrOrigin TransitionClipVtypePropertyInfo = TransitionClip
    attrGet = getTransitionClipVtype
    attrSet = setTransitionClipVtype
    attrTransfer _ v = do
        return v
    attrConstruct = constructTransitionClipVtype
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TransitionClip.vtype"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/docs/GI-GES-Objects-TransitionClip.html#g:attr:vtype"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TransitionClip
type instance O.AttributeList TransitionClip = TransitionClipAttributeList
type TransitionClipAttributeList = ('[ '("duration", GES.TimelineElement.TimelineElementDurationPropertyInfo), '("durationLimit", GES.Clip.ClipDurationLimitPropertyInfo), '("height", GES.Container.ContainerHeightPropertyInfo), '("inPoint", GES.TimelineElement.TimelineElementInPointPropertyInfo), '("layer", GES.Clip.ClipLayerPropertyInfo), '("maxDuration", GES.TimelineElement.TimelineElementMaxDurationPropertyInfo), '("name", GES.TimelineElement.TimelineElementNamePropertyInfo), '("parent", GES.TimelineElement.TimelineElementParentPropertyInfo), '("priority", GES.TimelineElement.TimelineElementPriorityPropertyInfo), '("serialize", GES.TimelineElement.TimelineElementSerializePropertyInfo), '("start", GES.TimelineElement.TimelineElementStartPropertyInfo), '("supportedFormats", GES.Clip.ClipSupportedFormatsPropertyInfo), '("timeline", GES.TimelineElement.TimelineElementTimelinePropertyInfo), '("vtype", TransitionClipVtypePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
transitionClipVtype :: AttrLabelProxy "vtype"
transitionClipVtype = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TransitionClip = TransitionClipSignalList
type TransitionClipSignalList = ('[ '("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 TransitionClip::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "vtype"
--           , argType =
--               TInterface
--                 Name { namespace = "GES" , name = "VideoStandardTransitionType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the type of transition to create"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TransitionClip" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_transition_clip_new" ges_transition_clip_new :: 
    CUInt ->                                -- vtype : TInterface (Name {namespace = "GES", name = "VideoStandardTransitionType"})
    IO (Ptr TransitionClip)

-- | Creates a new t'GI.GES.Objects.TransitionClip.TransitionClip'.
transitionClipNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GES.Enums.VideoStandardTransitionType
    -- ^ /@vtype@/: the type of transition to create
    -> m (Maybe TransitionClip)
    -- ^ __Returns:__ a newly created t'GI.GES.Objects.TransitionClip.TransitionClip',
    -- or 'P.Nothing' if something went wrong.
transitionClipNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoStandardTransitionType -> m (Maybe TransitionClip)
transitionClipNew VideoStandardTransitionType
vtype = IO (Maybe TransitionClip) -> m (Maybe TransitionClip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TransitionClip) -> m (Maybe TransitionClip))
-> IO (Maybe TransitionClip) -> m (Maybe TransitionClip)
forall a b. (a -> b) -> a -> b
$ do
    let vtype' :: CUInt
vtype' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (VideoStandardTransitionType -> Int)
-> VideoStandardTransitionType
-> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VideoStandardTransitionType -> Int
forall a. Enum a => a -> Int
fromEnum) VideoStandardTransitionType
vtype
    Ptr TransitionClip
result <- CUInt -> IO (Ptr TransitionClip)
ges_transition_clip_new CUInt
vtype'
    Maybe TransitionClip
maybeResult <- Ptr TransitionClip
-> (Ptr TransitionClip -> IO TransitionClip)
-> IO (Maybe TransitionClip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TransitionClip
result ((Ptr TransitionClip -> IO TransitionClip)
 -> IO (Maybe TransitionClip))
-> (Ptr TransitionClip -> IO TransitionClip)
-> IO (Maybe TransitionClip)
forall a b. (a -> b) -> a -> b
$ \Ptr TransitionClip
result' -> do
        TransitionClip
result'' <- ((ManagedPtr TransitionClip -> TransitionClip)
-> Ptr TransitionClip -> IO TransitionClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TransitionClip -> TransitionClip
TransitionClip) Ptr TransitionClip
result'
        TransitionClip -> IO TransitionClip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TransitionClip
result''
    Maybe TransitionClip -> IO (Maybe TransitionClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TransitionClip
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method TransitionClip::new_for_nick
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "nick"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a string representing the type of transition to create"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "TransitionClip" })
-- throws : False
-- Skip return : False

foreign import ccall "ges_transition_clip_new_for_nick" ges_transition_clip_new_for_nick :: 
    CString ->                              -- nick : TBasicType TUTF8
    IO (Ptr TransitionClip)

-- | Creates a new t'GI.GES.Objects.TransitionClip.TransitionClip' for the provided /@nick@/.
transitionClipNewForNick ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@nick@/: a string representing the type of transition to create
    -> m (Maybe TransitionClip)
    -- ^ __Returns:__ The newly created t'GI.GES.Objects.TransitionClip.TransitionClip',
    -- or 'P.Nothing' if something went wrong
transitionClipNewForNick :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe TransitionClip)
transitionClipNewForNick Text
nick = IO (Maybe TransitionClip) -> m (Maybe TransitionClip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TransitionClip) -> m (Maybe TransitionClip))
-> IO (Maybe TransitionClip) -> m (Maybe TransitionClip)
forall a b. (a -> b) -> a -> b
$ do
    CString
nick' <- Text -> IO CString
textToCString Text
nick
    Ptr TransitionClip
result <- CString -> IO (Ptr TransitionClip)
ges_transition_clip_new_for_nick CString
nick'
    Maybe TransitionClip
maybeResult <- Ptr TransitionClip
-> (Ptr TransitionClip -> IO TransitionClip)
-> IO (Maybe TransitionClip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TransitionClip
result ((Ptr TransitionClip -> IO TransitionClip)
 -> IO (Maybe TransitionClip))
-> (Ptr TransitionClip -> IO TransitionClip)
-> IO (Maybe TransitionClip)
forall a b. (a -> b) -> a -> b
$ \Ptr TransitionClip
result' -> do
        TransitionClip
result'' <- ((ManagedPtr TransitionClip -> TransitionClip)
-> Ptr TransitionClip -> IO TransitionClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TransitionClip -> TransitionClip
TransitionClip) Ptr TransitionClip
result'
        TransitionClip -> IO TransitionClip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TransitionClip
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
nick'
    Maybe TransitionClip -> IO (Maybe TransitionClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TransitionClip
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif