{-# 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
    clearTitleClipFontDesc                  ,
    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
    clearTitleClipText                      ,
    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.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.GES.Enums as GES.Enums
import {-# SOURCE #-} qualified GI.GES.Interfaces.Extractable as GES.Extractable
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.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
(TitleClip -> TitleClip -> Bool)
-> (TitleClip -> TitleClip -> Bool) -> Eq TitleClip
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TitleClip -> TitleClip -> Bool
== :: TitleClip -> TitleClip -> Bool
$c/= :: TitleClip -> TitleClip -> Bool
/= :: 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 = IO TitleClip -> m TitleClip
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TitleClip -> m TitleClip)
-> (o -> IO TitleClip) -> o -> m TitleClip
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TitleClip -> TitleClip) -> o -> IO TitleClip
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 = Ptr GValue -> Ptr TitleClip -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr TitleClip
forall a. Ptr a
FP.nullPtr :: FP.Ptr TitleClip)
    gvalueSet_ Ptr GValue
gv (P.Just TitleClip
obj) = TitleClip -> (Ptr TitleClip -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TitleClip
obj (Ptr GValue -> Ptr TitleClip -> IO ()
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 <- Ptr GValue -> IO (Ptr TitleClip)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr TitleClip)
        if Ptr TitleClip
ptr Ptr TitleClip -> Ptr TitleClip -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr TitleClip
forall a. Ptr a
FP.nullPtr
        then TitleClip -> Maybe TitleClip
forall a. a -> Maybe a
P.Just (TitleClip -> Maybe TitleClip)
-> IO TitleClip -> IO (Maybe TitleClip)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr TitleClip -> TitleClip)
-> Ptr TitleClip -> IO TitleClip
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 Maybe TitleClip -> IO (Maybe TitleClip)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TitleClip
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveTitleClipMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
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.4/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 = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
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.4/docs/GI-GES-Objects-TitleClip.html#g:attr:color"
        })
#endif

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

-- | 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 (Maybe T.Text)
getTitleClipFontDesc :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> m (Maybe Text)
getTitleClipFontDesc o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"font-desc" (Text -> Maybe Text
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"font-desc" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

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

#if defined(ENABLE_OVERLOADING)
data TitleClipFontDescPropertyInfo
instance AttrInfo TitleClipFontDescPropertyInfo where
    type AttrAllowedOps TitleClipFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TitleClipFontDescPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipFontDescPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TitleClipFontDescPropertyInfo = (~) T.Text
    type AttrTransferType TitleClipFontDescPropertyInfo = T.Text
    type AttrGetType TitleClipFontDescPropertyInfo = (Maybe T.Text)
    type AttrLabel TitleClipFontDescPropertyInfo = "font-desc"
    type AttrOrigin TitleClipFontDescPropertyInfo = TitleClip
    attrGet = getTitleClipFontDesc
    attrSet = setTitleClipFontDesc
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipFontDesc
    attrClear = clearTitleClipFontDesc
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.fontDesc"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/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 = IO TextHAlign -> m TextHAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TextHAlign -> m TextHAlign) -> IO TextHAlign -> m TextHAlign
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TextHAlign
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> TextHAlign -> IO ()
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> TextHAlign -> IO (GValueConstruct o)
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.4/docs/GI-GES-Objects-TitleClip.html#g:attr:halignment"
        })
#endif

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

-- | 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 (Maybe T.Text)
getTitleClipText :: forall (m :: * -> *) o.
(MonadIO m, IsTitleClip o) =>
o -> m (Maybe Text)
getTitleClipText o
obj = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ o -> String -> IO (Maybe Text)
forall a. GObject a => a -> String -> IO (Maybe Text)
B.Properties.getObjectPropertyString o
obj String
"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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe Text -> IO ()
forall a. GObject a => a -> String -> Maybe Text -> IO ()
B.Properties.setObjectPropertyString o
obj String
"text" (Text -> Maybe 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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe Text -> IO (GValueConstruct o)
forall o. String -> Maybe Text -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyString String
"text" (Text -> Maybe Text
forall a. a -> Maybe a
P.Just Text
val)

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

#if defined(ENABLE_OVERLOADING)
data TitleClipTextPropertyInfo
instance AttrInfo TitleClipTextPropertyInfo where
    type AttrAllowedOps TitleClipTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TitleClipTextPropertyInfo = IsTitleClip
    type AttrSetTypeConstraint TitleClipTextPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TitleClipTextPropertyInfo = (~) T.Text
    type AttrTransferType TitleClipTextPropertyInfo = T.Text
    type AttrGetType TitleClipTextPropertyInfo = (Maybe T.Text)
    type AttrLabel TitleClipTextPropertyInfo = "text"
    type AttrOrigin TitleClipTextPropertyInfo = TitleClip
    attrGet = getTitleClipText
    attrSet = setTitleClipText
    attrTransfer _ v = do
        return v
    attrConstruct = constructTitleClipText
    attrClear = clearTitleClipText
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TitleClip.text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/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 = IO TextVAlign -> m TextVAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TextVAlign -> m TextVAlign) -> IO TextVAlign -> m TextVAlign
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TextVAlign
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> TextVAlign -> IO ()
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> TextVAlign -> IO (GValueConstruct o)
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.4/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 = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
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.4/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 = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Double -> IO ()
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Double -> IO (GValueConstruct o)
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.4/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, DK.Type)])
#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, DK.Type)])

#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  = IO (Maybe TitleClip) -> m (Maybe TitleClip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TitleClip) -> m (Maybe TitleClip))
-> IO (Maybe TitleClip) -> m (Maybe TitleClip)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
result <- IO (Ptr TitleClip)
ges_title_clip_new
    Maybe TitleClip
maybeResult <- Ptr TitleClip
-> (Ptr TitleClip -> IO TitleClip) -> IO (Maybe TitleClip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TitleClip
result ((Ptr TitleClip -> IO TitleClip) -> IO (Maybe TitleClip))
-> (Ptr TitleClip -> IO TitleClip) -> IO (Maybe TitleClip)
forall a b. (a -> b) -> a -> b
$ \Ptr TitleClip
result' -> do
        TitleClip
result'' <- ((ManagedPtr TitleClip -> TitleClip)
-> Ptr TitleClip -> IO TitleClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TitleClip -> TitleClip
TitleClip) Ptr TitleClip
result'
        TitleClip -> IO TitleClip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TitleClip
result''
    Maybe TitleClip -> IO (Maybe TitleClip)
forall a. a -> IO a
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 = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
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.4/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 (Maybe T.Text)
    -- ^ __Returns:__ The pango font description used by /@self@/.
titleClipGetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m (Maybe Text)
titleClipGetFontDesc a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TitleClipGetFontDescMethodInfo
instance (signature ~ (m (Maybe 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.4/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 = IO TextHAlign -> m TextHAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextHAlign -> m TextHAlign) -> IO TextHAlign -> m TextHAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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' = (Int -> TextHAlign
forall a. Enum a => Int -> a
toEnum (Int -> TextHAlign) -> (CUInt -> Int) -> CUInt -> TextHAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    TextHAlign -> IO TextHAlign
forall a. a -> IO a
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.4/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 (Maybe T.Text)
    -- ^ __Returns:__ The text currently set on /@self@/.
titleClipGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> m (Maybe Text)
titleClipGetText a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TitleClipGetTextMethodInfo
instance (signature ~ (m (Maybe 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.4/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 = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
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.4/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 = IO TextVAlign -> m TextVAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TextVAlign -> m TextVAlign) -> IO TextVAlign -> m TextVAlign
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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' = (Int -> TextVAlign
forall a. Enum a => Int -> a
toEnum (Int -> TextVAlign) -> (CUInt -> Int) -> CUInt -> TextVAlign
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    TextVAlign -> IO TextVAlign
forall a. a -> IO a
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.4/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 = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
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.4/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 = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
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.4/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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.4/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
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
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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.4/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 = True
--           , 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'*
    -> Maybe (T.Text)
    -- ^ /@fontDesc@/: the pango font description
    -> m ()
titleClipSetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTitleClip a) =>
a -> Maybe Text -> m ()
titleClipSetFontDesc a
self Maybe Text
fontDesc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeFontDesc <- case Maybe Text
fontDesc of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontDesc -> do
            CString
jFontDesc' <- Text -> IO CString
textToCString Text
jFontDesc
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontDesc'
    Ptr TitleClip -> CString -> IO ()
ges_title_clip_set_font_desc Ptr TitleClip
self' CString
maybeFontDesc
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontDesc
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetFontDescMethodInfo
instance (signature ~ (Maybe (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.4/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let halign' :: CUInt
halign' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextHAlign -> Int) -> TextHAlign -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextHAlign -> Int
forall a. Enum a => a -> Int
fromEnum) TextHAlign
halign
    Ptr TitleClip -> CUInt -> IO ()
ges_title_clip_set_halignment Ptr TitleClip
self' CUInt
halign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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.4/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 = True
--           , 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
    -> Maybe (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 -> Maybe Text -> m ()
titleClipSetText a
self Maybe Text
text = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeText <- case Maybe Text
text of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jText -> do
            CString
jText' <- Text -> IO CString
textToCString Text
jText
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jText'
    Ptr TitleClip -> CString -> IO ()
ges_title_clip_set_text Ptr TitleClip
self' CString
maybeText
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeText
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TitleClipSetTextMethodInfo
instance (signature ~ (Maybe (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.4/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let valign' :: CUInt
valign' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TextVAlign -> Int) -> TextVAlign -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextVAlign -> Int
forall a. Enum a => a -> Int
fromEnum) TextVAlign
valign
    Ptr TitleClip -> CUInt -> IO ()
ges_title_clip_set_valignment Ptr TitleClip
self' CUInt
valign'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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.4/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CDouble
position' = Double -> CDouble
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'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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.4/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TitleClip
self' <- a -> IO (Ptr TitleClip)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CDouble
position' = Double -> CDouble
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'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data 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.4/docs/GI-GES-Objects-TitleClip.html#v:titleClipSetYpos"
        })


#endif