{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Renders the given text in the specified font, at specified position, and
-- with the specified background pattern.

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

module GI.GES.Objects.TitleClip
    ( 

-- * Exported types
    TitleClip(..)                           ,
    IsTitleClip                             ,
    toTitleClip                             ,


 -- * 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"), [getBackgroundColor]("GI.GES.Objects.TitleClip#g:method:getBackgroundColor"), [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"), [getFontDesc]("GI.GES.Objects.TitleClip#g:method:getFontDesc"), [getHalignment]("GI.GES.Objects.TitleClip#g:method:getHalignment"), [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"), [getText]("GI.GES.Objects.TitleClip#g:method:getText"), [getTextColor]("GI.GES.Objects.TitleClip#g:method:getTextColor"), [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"), [getValignment]("GI.GES.Objects.TitleClip#g:method:getValignment"), [getXpos]("GI.GES.Objects.TitleClip#g:method:getXpos"), [getYpos]("GI.GES.Objects.TitleClip#g:method:getYpos").
-- 
-- ==== Setters
-- [setAsset]("GI.GES.Interfaces.Extractable#g:method:setAsset"), [setBackground]("GI.GES.Objects.TitleClip#g:method:setBackground"), [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"), [setColor]("GI.GES.Objects.TitleClip#g:method:setColor"), [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"), [setFontDesc]("GI.GES.Objects.TitleClip#g:method:setFontDesc"), [setHalignment]("GI.GES.Objects.TitleClip#g:method:setHalignment"), [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"), [setText]("GI.GES.Objects.TitleClip#g:method:setText"), [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"), [setValignment]("GI.GES.Objects.TitleClip#g:method:setValignment"), [setXpos]("GI.GES.Objects.TitleClip#g:method:setXpos"), [setYpos]("GI.GES.Objects.TitleClip#g:method:setYpos").

#if defined(ENABLE_OVERLOADING)
    ResolveTitleClipMethod                  ,
#endif

-- ** getBackgroundColor #method:getBackgroundColor#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetBackgroundColorMethodInfo   ,
#endif
    titleClipGetBackgroundColor             ,


-- ** getFontDesc #method:getFontDesc#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetFontDescMethodInfo          ,
#endif
    titleClipGetFontDesc                    ,


-- ** getHalignment #method:getHalignment#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetHalignmentMethodInfo        ,
#endif
    titleClipGetHalignment                  ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetTextMethodInfo              ,
#endif
    titleClipGetText                        ,


-- ** getTextColor #method:getTextColor#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetTextColorMethodInfo         ,
#endif
    titleClipGetTextColor                   ,


-- ** getValignment #method:getValignment#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetValignmentMethodInfo        ,
#endif
    titleClipGetValignment                  ,


-- ** getXpos #method:getXpos#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetXposMethodInfo              ,
#endif
    titleClipGetXpos                        ,


-- ** getYpos #method:getYpos#

#if defined(ENABLE_OVERLOADING)
    TitleClipGetYposMethodInfo              ,
#endif
    titleClipGetYpos                        ,


-- ** new #method:new#

    titleClipNew                            ,


-- ** setBackground #method:setBackground#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetBackgroundMethodInfo        ,
#endif
    titleClipSetBackground                  ,


-- ** setColor #method:setColor#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetColorMethodInfo             ,
#endif
    titleClipSetColor                       ,


-- ** setFontDesc #method:setFontDesc#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetFontDescMethodInfo          ,
#endif
    titleClipSetFontDesc                    ,


-- ** setHalignment #method:setHalignment#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetHalignmentMethodInfo        ,
#endif
    titleClipSetHalignment                  ,


-- ** setText #method:setText#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetTextMethodInfo              ,
#endif
    titleClipSetText                        ,


-- ** setValignment #method:setValignment#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetValignmentMethodInfo        ,
#endif
    titleClipSetValignment                  ,


-- ** setXpos #method:setXpos#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetXposMethodInfo              ,
#endif
    titleClipSetXpos                        ,


-- ** setYpos #method:setYpos#

#if defined(ENABLE_OVERLOADING)
    TitleClipSetYposMethodInfo              ,
#endif
    titleClipSetYpos                        ,




 -- * Properties


-- ** background #attr:background#
-- | The background of the text

#if defined(ENABLE_OVERLOADING)
    TitleClipBackgroundPropertyInfo         ,
#endif
    constructTitleClipBackground            ,
    getTitleClipBackground                  ,
    setTitleClipBackground                  ,
#if defined(ENABLE_OVERLOADING)
    titleClipBackground                     ,
#endif


-- ** color #attr:color#
-- | The color of the text

#if defined(ENABLE_OVERLOADING)
    TitleClipColorPropertyInfo              ,
#endif
    constructTitleClipColor                 ,
    getTitleClipColor                       ,
    setTitleClipColor                       ,
#if defined(ENABLE_OVERLOADING)
    titleClipColor                          ,
#endif


-- ** fontDesc #attr:fontDesc#
-- | Pango font description string

#if defined(ENABLE_OVERLOADING)
    TitleClipFontDescPropertyInfo           ,
#endif
    constructTitleClipFontDesc              ,
    getTitleClipFontDesc                    ,
    setTitleClipFontDesc                    ,
#if defined(ENABLE_OVERLOADING)
    titleClipFontDesc                       ,
#endif


-- ** halignment #attr:halignment#
-- | Horizontal alignment of the text

#if defined(ENABLE_OVERLOADING)
    TitleClipHalignmentPropertyInfo         ,
#endif
    constructTitleClipHalignment            ,
    getTitleClipHalignment                  ,
    setTitleClipHalignment                  ,
#if defined(ENABLE_OVERLOADING)
    titleClipHalignment                     ,
#endif


-- ** text #attr:text#
-- | The text to diplay

#if defined(ENABLE_OVERLOADING)
    TitleClipTextPropertyInfo               ,
#endif
    constructTitleClipText                  ,
    getTitleClipText                        ,
    setTitleClipText                        ,
#if defined(ENABLE_OVERLOADING)
    titleClipText                           ,
#endif


-- ** valignment #attr:valignment#
-- | Vertical alignent of the text

#if defined(ENABLE_OVERLOADING)
    TitleClipValignmentPropertyInfo         ,
#endif
    constructTitleClipValignment            ,
    getTitleClipValignment                  ,
    setTitleClipValignment                  ,
#if defined(ENABLE_OVERLOADING)
    titleClipValignment                     ,
#endif


-- ** xpos #attr:xpos#
-- | The horizontal position of the text

#if defined(ENABLE_OVERLOADING)
    TitleClipXposPropertyInfo               ,
#endif
    constructTitleClipXpos                  ,
    getTitleClipXpos                        ,
    setTitleClipXpos                        ,
#if defined(ENABLE_OVERLOADING)
    titleClipXpos                           ,
#endif


-- ** ypos #attr:ypos#
-- | The vertical position of the text

#if defined(ENABLE_OVERLOADING)
    TitleClipYposPropertyInfo               ,
#endif
    constructTitleClipYpos                  ,
    getTitleClipYpos                        ,
    setTitleClipYpos                        ,
#if defined(ENABLE_OVERLOADING)
    titleClipYpos                           ,
#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.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.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

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

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

foreign import ccall "ges_title_clip_get_type"
    c_ges_title_clip_get_type :: IO B.Types.GType

instance B.Types.TypedObject TitleClip where
    glibType :: IO GType
glibType = IO GType
c_ges_title_clip_get_type

instance B.Types.GObject TitleClip

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

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

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

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

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

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

#endif

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

#endif

-- VVV Prop "background"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

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

-- | Set the value of the “@background@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #background 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipBackground :: (MonadIO m, IsTitleClip o) => o -> Word32 -> m ()
setTitleClipBackground :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> Word32 -> m ()
setTitleClipBackground o
obj Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"background" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@background@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipBackground :: (IsTitleClip o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructTitleClipBackground :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructTitleClipBackground Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"background" Word32
val

#if defined(ENABLE_OVERLOADING)
data TitleClipBackgroundPropertyInfo
instance AttrInfo TitleClipBackgroundPropertyInfo where
    type AttrAllowedOps TitleClipBackgroundPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TitleClipBackgroundPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipBackgroundPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint TitleClipBackgroundPropertyInfo = (~) Word32
    type AttrTransferType TitleClipBackgroundPropertyInfo = Word32
    type AttrGetType TitleClipBackgroundPropertyInfo = Word32
    type AttrLabel TitleClipBackgroundPropertyInfo = "background"
    type AttrOrigin TitleClipBackgroundPropertyInfo = TitleClip
    attrGet = getTitleClipBackground
    attrSet = setTitleClipBackground
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipBackground
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.background"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TitleClip.html#g:attr:background"
        })
#endif

-- VVV Prop "color"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Nothing,Nothing)

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

-- | Set the value of the “@color@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #color 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipColor :: (MonadIO m, IsTitleClip o) => o -> Word32 -> m ()
setTitleClipColor :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> Word32 -> m ()
setTitleClipColor o
obj Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"color" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@color@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipColor :: (IsTitleClip o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructTitleClipColor :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructTitleClipColor Word32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"color" Word32
val

#if defined(ENABLE_OVERLOADING)
data TitleClipColorPropertyInfo
instance AttrInfo TitleClipColorPropertyInfo where
    type AttrAllowedOps TitleClipColorPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TitleClipColorPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipColorPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint TitleClipColorPropertyInfo = (~) Word32
    type AttrTransferType TitleClipColorPropertyInfo = Word32
    type AttrGetType TitleClipColorPropertyInfo = Word32
    type AttrLabel TitleClipColorPropertyInfo = "color"
    type AttrOrigin TitleClipColorPropertyInfo = TitleClip
    attrGet = getTitleClipColor
    attrSet = setTitleClipColor
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipColor
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.color"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TitleClip.html#g:attr:color"
        })
#endif

-- VVV Prop "font-desc"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@font-desc@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #fontDesc 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipFontDesc :: (MonadIO m, IsTitleClip o) => o -> T.Text -> m ()
setTitleClipFontDesc :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> Text -> m ()
setTitleClipFontDesc o
obj Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"font-desc" (forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@font-desc@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipFontDesc :: (IsTitleClip o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructTitleClipFontDesc :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructTitleClipFontDesc Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"font-desc" (forall a. a -> Maybe a
P.Just Text
val)

#if defined(ENABLE_OVERLOADING)
data TitleClipFontDescPropertyInfo
instance AttrInfo TitleClipFontDescPropertyInfo where
    type AttrAllowedOps TitleClipFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TitleClipFontDescPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipFontDescPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TitleClipFontDescPropertyInfo = (~) T.Text
    type AttrTransferType TitleClipFontDescPropertyInfo = T.Text
    type AttrGetType TitleClipFontDescPropertyInfo = T.Text
    type AttrLabel TitleClipFontDescPropertyInfo = "font-desc"
    type AttrOrigin TitleClipFontDescPropertyInfo = TitleClip
    attrGet = getTitleClipFontDesc
    attrSet = setTitleClipFontDesc
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipFontDesc
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.fontDesc"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TitleClip.html#g:attr:fontDesc"
        })
#endif

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

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

-- | Set the value of the “@halignment@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #halignment 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipHalignment :: (MonadIO m, IsTitleClip o) => o -> GES.Enums.TextHAlign -> m ()
setTitleClipHalignment :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> TextHAlign -> m ()
setTitleClipHalignment o
obj TextHAlign
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"halignment" TextHAlign
val

-- | Construct a `GValueConstruct` with valid value for the “@halignment@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipHalignment :: (IsTitleClip o, MIO.MonadIO m) => GES.Enums.TextHAlign -> m (GValueConstruct o)
constructTitleClipHalignment :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
TextHAlign -> m (GValueConstruct o)
constructTitleClipHalignment TextHAlign
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"halignment" TextHAlign
val

#if defined(ENABLE_OVERLOADING)
data TitleClipHalignmentPropertyInfo
instance AttrInfo TitleClipHalignmentPropertyInfo where
    type AttrAllowedOps TitleClipHalignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TitleClipHalignmentPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipHalignmentPropertyInfo = (~) GES.Enums.TextHAlign
    type AttrTransferTypeConstraint TitleClipHalignmentPropertyInfo = (~) GES.Enums.TextHAlign
    type AttrTransferType TitleClipHalignmentPropertyInfo = GES.Enums.TextHAlign
    type AttrGetType TitleClipHalignmentPropertyInfo = GES.Enums.TextHAlign
    type AttrLabel TitleClipHalignmentPropertyInfo = "halignment"
    type AttrOrigin TitleClipHalignmentPropertyInfo = TitleClip
    attrGet = getTitleClipHalignment
    attrSet = setTitleClipHalignment
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipHalignment
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.halignment"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TitleClip.html#g:attr:halignment"
        })
#endif

-- VVV Prop "text"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@text@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #text 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipText :: (MonadIO m, IsTitleClip o) => o -> T.Text -> m ()
setTitleClipText :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> Text -> m ()
setTitleClipText o
obj Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"text" (forall a. a -> Maybe a
Just Text
val)

-- | Construct a `GValueConstruct` with valid value for the “@text@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipText :: (IsTitleClip o, MIO.MonadIO m) => T.Text -> m (GValueConstruct o)
constructTitleClipText :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
Text -> m (GValueConstruct o)
constructTitleClipText Text
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"text" (forall a. a -> Maybe a
P.Just Text
val)

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

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

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

-- | Set the value of the “@valignment@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #valignment 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipValignment :: (MonadIO m, IsTitleClip o) => o -> GES.Enums.TextVAlign -> m ()
setTitleClipValignment :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> TextVAlign -> m ()
setTitleClipValignment o
obj TextVAlign
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"valignment" TextVAlign
val

-- | Construct a `GValueConstruct` with valid value for the “@valignment@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipValignment :: (IsTitleClip o, MIO.MonadIO m) => GES.Enums.TextVAlign -> m (GValueConstruct o)
constructTitleClipValignment :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
TextVAlign -> m (GValueConstruct o)
constructTitleClipValignment TextVAlign
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"valignment" TextVAlign
val

#if defined(ENABLE_OVERLOADING)
data TitleClipValignmentPropertyInfo
instance AttrInfo TitleClipValignmentPropertyInfo where
    type AttrAllowedOps TitleClipValignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TitleClipValignmentPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipValignmentPropertyInfo = (~) GES.Enums.TextVAlign
    type AttrTransferTypeConstraint TitleClipValignmentPropertyInfo = (~) GES.Enums.TextVAlign
    type AttrTransferType TitleClipValignmentPropertyInfo = GES.Enums.TextVAlign
    type AttrGetType TitleClipValignmentPropertyInfo = GES.Enums.TextVAlign
    type AttrLabel TitleClipValignmentPropertyInfo = "valignment"
    type AttrOrigin TitleClipValignmentPropertyInfo = TitleClip
    attrGet = getTitleClipValignment
    attrSet = setTitleClipValignment
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipValignment
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.valignment"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TitleClip.html#g:attr:valignment"
        })
#endif

-- VVV Prop "xpos"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@xpos@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #xpos 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipXpos :: (MonadIO m, IsTitleClip o) => o -> Double -> m ()
setTitleClipXpos :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> Double -> m ()
setTitleClipXpos o
obj Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"xpos" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@xpos@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipXpos :: (IsTitleClip o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructTitleClipXpos :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructTitleClipXpos Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"xpos" Double
val

#if defined(ENABLE_OVERLOADING)
data TitleClipXposPropertyInfo
instance AttrInfo TitleClipXposPropertyInfo where
    type AttrAllowedOps TitleClipXposPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TitleClipXposPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipXposPropertyInfo = (~) Double
    type AttrTransferTypeConstraint TitleClipXposPropertyInfo = (~) Double
    type AttrTransferType TitleClipXposPropertyInfo = Double
    type AttrGetType TitleClipXposPropertyInfo = Double
    type AttrLabel TitleClipXposPropertyInfo = "xpos"
    type AttrOrigin TitleClipXposPropertyInfo = TitleClip
    attrGet = getTitleClipXpos
    attrSet = setTitleClipXpos
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipXpos
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.xpos"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TitleClip.html#g:attr:xpos"
        })
#endif

-- VVV Prop "ypos"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
   -- Nullable: (Just False,Just False)

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

-- | Set the value of the “@ypos@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' titleClip [ #ypos 'Data.GI.Base.Attributes.:=' value ]
-- @
setTitleClipYpos :: (MonadIO m, IsTitleClip o) => o -> Double -> m ()
setTitleClipYpos :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> Double -> m ()
setTitleClipYpos o
obj Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a. GObject a => a -> String -> Double -> IO ()
B.Properties.setObjectPropertyDouble o
obj String
"ypos" Double
val

-- | Construct a `GValueConstruct` with valid value for the “@ypos@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTitleClipYpos :: (IsTitleClip o, MIO.MonadIO m) => Double -> m (GValueConstruct o)
constructTitleClipYpos :: forall o (m :: * -> *).
(IsTitleClip o, MonadIO m) =>
Double -> m (GValueConstruct o)
constructTitleClipYpos Double
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Double -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyDouble String
"ypos" Double
val

#if defined(ENABLE_OVERLOADING)
data TitleClipYposPropertyInfo
instance AttrInfo TitleClipYposPropertyInfo where
    type AttrAllowedOps TitleClipYposPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TitleClipYposPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipYposPropertyInfo = (~) Double
    type AttrTransferTypeConstraint TitleClipYposPropertyInfo = (~) Double
    type AttrTransferType TitleClipYposPropertyInfo = Double
    type AttrGetType TitleClipYposPropertyInfo = Double
    type AttrLabel TitleClipYposPropertyInfo = "ypos"
    type AttrOrigin TitleClipYposPropertyInfo = TitleClip
    attrGet = getTitleClipYpos
    attrSet = setTitleClipYpos
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipYpos
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.ypos"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TitleClip.html#g:attr:ypos"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TitleClip
type instance O.AttributeList TitleClip = TitleClipAttributeList
type TitleClipAttributeList = ('[ '("background", TitleClipBackgroundPropertyInfo), '("color", TitleClipColorPropertyInfo), '("duration", GES.TimelineElement.TimelineElementDurationPropertyInfo), '("durationLimit", GES.Clip.ClipDurationLimitPropertyInfo), '("fontDesc", TitleClipFontDescPropertyInfo), '("halignment", TitleClipHalignmentPropertyInfo), '("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), '("text", TitleClipTextPropertyInfo), '("timeline", GES.TimelineElement.TimelineElementTimelinePropertyInfo), '("valignment", TitleClipValignmentPropertyInfo), '("xpos", TitleClipXposPropertyInfo), '("ypos", TitleClipYposPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
titleClipBackground :: AttrLabelProxy "background"
titleClipBackground = AttrLabelProxy

titleClipColor :: AttrLabelProxy "color"
titleClipColor = AttrLabelProxy

titleClipFontDesc :: AttrLabelProxy "fontDesc"
titleClipFontDesc = AttrLabelProxy

titleClipHalignment :: AttrLabelProxy "halignment"
titleClipHalignment = AttrLabelProxy

titleClipText :: AttrLabelProxy "text"
titleClipText = AttrLabelProxy

titleClipValignment :: AttrLabelProxy "valignment"
titleClipValignment = AttrLabelProxy

titleClipXpos :: AttrLabelProxy "xpos"
titleClipXpos = AttrLabelProxy

titleClipYpos :: AttrLabelProxy "ypos"
titleClipYpos = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TitleClip = TitleClipSignalList
type TitleClipSignalList = ('[ '("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, *)])

#endif

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

foreign import ccall "ges_title_clip_new" ges_title_clip_new :: 
    IO (Ptr TitleClip)

-- | Creates a new t'GI.GES.Objects.TitleClip.TitleClip'
titleClipNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe TitleClip)
    -- ^ __Returns:__ The newly created t'GI.GES.Objects.TitleClip.TitleClip',
    -- or 'P.Nothing' if there was an error.
titleClipNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m (Maybe TitleClip)
titleClipNew  = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
result <- IO (Ptr TitleClip)
ges_title_clip_new
    Maybe TitleClip
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TitleClip
result forall a b. (a -> b) -> a -> b
$ \Ptr TitleClip
result' -> do
        TitleClip
result'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TitleClip -> TitleClip
TitleClip) Ptr TitleClip
result'
        forall (m :: * -> *) a. Monad m => a -> m a
return TitleClip
result''
    forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TitleClip
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "ges_title_clip_get_background_color" ges_title_clip_get_background_color :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    IO Word32

{-# DEPRECATED titleClipGetBackgroundColor ["(Since version 1.6)","use @/ges_timeline_element_get_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Get the background used by /@self@/.
titleClipGetBackgroundColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m Word32
    -- ^ __Returns:__ The color used by /@self@/.
titleClipGetBackgroundColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m Word32
titleClipGetBackgroundColor a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr TitleClip -> IO Word32
ges_title_clip_get_background_color Ptr TitleClip
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data TitleClipGetBackgroundColorMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetBackgroundColorMethodInfo a signature where
    overloadedMethod = titleClipGetBackgroundColor

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


#endif

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

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

{-# DEPRECATED titleClipGetFontDesc ["(Since version 1.6)","use @/ges_timeline_element_get_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Get the pango font description used by /@self@/.
titleClipGetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m T.Text
    -- ^ __Returns:__ The pango font description used by /@self@/.
titleClipGetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m Text
titleClipGetFontDesc a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr TitleClip -> IO CString
ges_title_clip_get_font_desc Ptr TitleClip
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"titleClipGetFontDesc" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TitleClipGetFontDescMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetFontDescMethodInfo a signature where
    overloadedMethod = titleClipGetFontDesc

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


#endif

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

foreign import ccall "ges_title_clip_get_halignment" ges_title_clip_get_halignment :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    IO CUInt

{-# DEPRECATED titleClipGetHalignment ["(Since version 1.6)","use @/ges_timeline_element_get_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Get the horizontal aligment used by /@self@/.
titleClipGetHalignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m GES.Enums.TextHAlign
    -- ^ __Returns:__ The horizontal aligment used by /@self@/.
titleClipGetHalignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m TextHAlign
titleClipGetHalignment a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr TitleClip -> IO CUInt
ges_title_clip_get_halignment Ptr TitleClip
self'
    let result' :: TextHAlign
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return TextHAlign
result'

#if defined(ENABLE_OVERLOADING)
data TitleClipGetHalignmentMethodInfo
instance (signature ~ (m GES.Enums.TextHAlign), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetHalignmentMethodInfo a signature where
    overloadedMethod = titleClipGetHalignment

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


#endif

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

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

{-# DEPRECATED titleClipGetText ["(Since version 1.6)","use @/ges_timeline_element_get_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Get the text currently set on /@self@/.
titleClipGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m T.Text
    -- ^ __Returns:__ The text currently set on /@self@/.
titleClipGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m Text
titleClipGetText a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr TitleClip -> IO CString
ges_title_clip_get_text Ptr TitleClip
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"titleClipGetText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TitleClipGetTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetTextMethodInfo a signature where
    overloadedMethod = titleClipGetText

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


#endif

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

foreign import ccall "ges_title_clip_get_text_color" ges_title_clip_get_text_color :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    IO Word32

{-# DEPRECATED titleClipGetTextColor ["(Since version 1.6)","use @/ges_timeline_element_get_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Get the color used by /@self@/.
titleClipGetTextColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m Word32
    -- ^ __Returns:__ The color used by /@self@/.
titleClipGetTextColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m Word32
titleClipGetTextColor a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr TitleClip -> IO Word32
ges_title_clip_get_text_color Ptr TitleClip
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data TitleClipGetTextColorMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetTextColorMethodInfo a signature where
    overloadedMethod = titleClipGetTextColor

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


#endif

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

foreign import ccall "ges_title_clip_get_valignment" ges_title_clip_get_valignment :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    IO CUInt

{-# DEPRECATED titleClipGetValignment ["(Since version 1.6)","use @/ges_timeline_element_get_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Get the vertical aligment used by /@self@/.
titleClipGetValignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m GES.Enums.TextVAlign
    -- ^ __Returns:__ The vertical aligment used by /@self@/.
titleClipGetValignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m TextVAlign
titleClipGetValignment a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr TitleClip -> IO CUInt
ges_title_clip_get_valignment Ptr TitleClip
self'
    let result' :: TextVAlign
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return TextVAlign
result'

#if defined(ENABLE_OVERLOADING)
data TitleClipGetValignmentMethodInfo
instance (signature ~ (m GES.Enums.TextVAlign), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetValignmentMethodInfo a signature where
    overloadedMethod = titleClipGetValignment

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


#endif

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

foreign import ccall "ges_title_clip_get_xpos" ges_title_clip_get_xpos :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    IO CDouble

{-# DEPRECATED titleClipGetXpos ["(Since version 1.6)","use @/ges_timeline_element_get_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Get the horizontal position used by /@self@/.
titleClipGetXpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m Double
    -- ^ __Returns:__ The horizontal position used by /@self@/.
titleClipGetXpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m Double
titleClipGetXpos a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TitleClip -> IO CDouble
ges_title_clip_get_xpos Ptr TitleClip
self'
    let result' :: Double
result' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TitleClipGetXposMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetXposMethodInfo a signature where
    overloadedMethod = titleClipGetXpos

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


#endif

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

foreign import ccall "ges_title_clip_get_ypos" ges_title_clip_get_ypos :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    IO CDouble

{-# DEPRECATED titleClipGetYpos ["(Since version 1.6)","use @/ges_timeline_element_get_children_property/@ instead"] #-}
-- | Get the vertical position used by /@self@/.
titleClipGetYpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TitleClip.TitleClip'
    -> m Double
    -- ^ __Returns:__ The vertical position used by /@self@/.
titleClipGetYpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m Double
titleClipGetYpos a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TitleClip -> IO CDouble
ges_title_clip_get_ypos Ptr TitleClip
self'
    let result' :: Double
result' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TitleClipGetYposMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipGetYposMethodInfo a signature where
    overloadedMethod = titleClipGetYpos

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


#endif

-- method TitleClip::set_background
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTitleClip* to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The color @self is being set to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_background" ges_title_clip_set_background :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    Word32 ->                               -- background : TBasicType TUInt32
    IO ()

{-# DEPRECATED titleClipSetBackground ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the background of the text.
titleClipSetBackground ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'* to set
    -> Word32
    -- ^ /@background@/: The color /@self@/ is being set to
    -> m ()
titleClipSetBackground :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> Word32 -> m ()
titleClipSetBackground a
self Word32
background = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TitleClip -> Word32 -> IO ()
ges_title_clip_set_background Ptr TitleClip
self' Word32
background
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetBackgroundMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetBackgroundMethodInfo a signature where
    overloadedMethod = titleClipSetBackground

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


#endif

-- method TitleClip::set_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTitleClip* to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "color"
--           , argType = TBasicType TUInt32
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The color @self is being set to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_color" ges_title_clip_set_color :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    Word32 ->                               -- color : TBasicType TUInt32
    IO ()

{-# DEPRECATED titleClipSetColor ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the color of the text.
titleClipSetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'* to set
    -> Word32
    -- ^ /@color@/: The color /@self@/ is being set to
    -> m ()
titleClipSetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> Word32 -> m ()
titleClipSetColor a
self Word32
color = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TitleClip -> Word32 -> IO ()
ges_title_clip_set_color Ptr TitleClip
self' Word32
color
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetColorMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetColorMethodInfo a signature where
    overloadedMethod = titleClipSetColor

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


#endif

-- method TitleClip::set_font_desc
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTitleClip*" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "font_desc"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the pango font description"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_font_desc" ges_title_clip_set_font_desc :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    CString ->                              -- font_desc : TBasicType TUTF8
    IO ()

{-# DEPRECATED titleClipSetFontDesc ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the pango font description of the text.
titleClipSetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'*
    -> T.Text
    -- ^ /@fontDesc@/: the pango font description
    -> m ()
titleClipSetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> Text -> m ()
titleClipSetFontDesc a
self Text
fontDesc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
fontDesc' <- Text -> IO CString
textToCString Text
fontDesc
    Ptr TitleClip -> CString -> IO ()
ges_title_clip_set_font_desc Ptr TitleClip
self' CString
fontDesc'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
fontDesc'
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetFontDescMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetFontDescMethodInfo a signature where
    overloadedMethod = titleClipSetFontDesc

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


#endif

-- method TitleClip::set_halignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GESTitleClip* to set horizontal alignement of text on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "halign"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextHAlign" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GESTextHAlign" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_halignment" ges_title_clip_set_halignment :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    CUInt ->                                -- halign : TInterface (Name {namespace = "GES", name = "TextHAlign"})
    IO ()

{-# DEPRECATED titleClipSetHalignment ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the horizontal aligment of the text.
titleClipSetHalignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'* to set horizontal alignement of text on
    -> GES.Enums.TextHAlign
    -- ^ /@halign@/: t'GI.GES.Enums.TextHAlign'
    -> m ()
titleClipSetHalignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> TextHAlign -> m ()
titleClipSetHalignment a
self TextHAlign
halign = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let halign' :: CUInt
halign' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) TextHAlign
halign
    Ptr TitleClip -> CUInt -> IO ()
ges_title_clip_set_halignment Ptr TitleClip
self' CUInt
halign'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetHalignmentMethodInfo
instance (signature ~ (GES.Enums.TextHAlign -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetHalignmentMethodInfo a signature where
    overloadedMethod = titleClipSetHalignment

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


#endif

-- method TitleClip::set_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTitleClip* to set text on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "text"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the text to render. an internal copy of this text will be\nmade."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_text" ges_title_clip_set_text :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    CString ->                              -- text : TBasicType TUTF8
    IO ()

{-# DEPRECATED titleClipSetText ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the text this clip will render.
titleClipSetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'* to set text on
    -> T.Text
    -- ^ /@text@/: the text to render. an internal copy of this text will be
    -- made.
    -> m ()
titleClipSetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> Text -> m ()
titleClipSetText a
self Text
text = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
text' <- Text -> IO CString
textToCString Text
text
    Ptr TitleClip -> CString -> IO ()
ges_title_clip_set_text Ptr TitleClip
self' CString
text'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
text'
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetTextMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetTextMethodInfo a signature where
    overloadedMethod = titleClipSetText

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


#endif

-- method TitleClip::set_valignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GESTitleClip* to set vertical alignement of text on"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "valign"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextVAlign" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GESTextVAlign" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_valignment" ges_title_clip_set_valignment :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    CUInt ->                                -- valign : TInterface (Name {namespace = "GES", name = "TextVAlign"})
    IO ()

{-# DEPRECATED titleClipSetValignment ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the vertical aligment of the text.
titleClipSetValignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'* to set vertical alignement of text on
    -> GES.Enums.TextVAlign
    -- ^ /@valign@/: t'GI.GES.Enums.TextVAlign'
    -> m ()
titleClipSetValignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> TextVAlign -> m ()
titleClipSetValignment a
self TextVAlign
valign = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let valign' :: CUInt
valign' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) TextVAlign
valign
    Ptr TitleClip -> CUInt -> IO ()
ges_title_clip_set_valignment Ptr TitleClip
self' CUInt
valign'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetValignmentMethodInfo
instance (signature ~ (GES.Enums.TextVAlign -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetValignmentMethodInfo a signature where
    overloadedMethod = titleClipSetValignment

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


#endif

-- method TitleClip::set_xpos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTitleClip* to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The horizontal position @self is being set to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_xpos" ges_title_clip_set_xpos :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    CDouble ->                              -- position : TBasicType TDouble
    IO ()

{-# DEPRECATED titleClipSetXpos ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the horizontal position of the text.
titleClipSetXpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'* to set
    -> Double
    -- ^ /@position@/: The horizontal position /@self@/ is being set to
    -> m ()
titleClipSetXpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> Double -> m ()
titleClipSetXpos a
self Double
position = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CDouble
position' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
position
    Ptr TitleClip -> CDouble -> IO ()
ges_title_clip_set_xpos Ptr TitleClip
self' CDouble
position'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetXposMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetXposMethodInfo a signature where
    overloadedMethod = titleClipSetXpos

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


#endif

-- method TitleClip::set_ypos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TitleClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTitleClip* to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "position"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The vertical position @self is being set to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_title_clip_set_ypos" ges_title_clip_set_ypos :: 
    Ptr TitleClip ->                        -- self : TInterface (Name {namespace = "GES", name = "TitleClip"})
    CDouble ->                              -- position : TBasicType TDouble
    IO ()

{-# DEPRECATED titleClipSetYpos ["(Since version 1.6)","use @/ges_timeline_element_set_children_properties/@ instead.","See t'GI.GES.Objects.TitleSource.TitleSource' for more information about exposed properties"] #-}
-- | Sets the vertical position of the text.
titleClipSetYpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTitleClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TitleClip.TitleClip'* to set
    -> Double
    -- ^ /@position@/: The vertical position /@self@/ is being set to
    -> m ()
titleClipSetYpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> Double -> m ()
titleClipSetYpos a
self Double
position = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CDouble
position' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
position
    Ptr TitleClip -> CDouble -> IO ()
ges_title_clip_set_ypos Ptr TitleClip
self' CDouble
position'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetYposMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTitleClip a) => O.OverloadedMethod TitleClipSetYposMethodInfo a signature where
    overloadedMethod = titleClipSetYpos

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


#endif