{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Renders text onto the next lower priority stream using textrender.

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

module GI.GES.Objects.TextOverlayClip
    ( 

-- * Exported types
    TextOverlayClip(..)                     ,
    IsTextOverlayClip                       ,
    toTextOverlayClip                       ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [add]("GI.GES.Objects.Container#g:method:add"), [addAsset]("GI.GES.Objects.Clip#g:method:addAsset"), [addChildProperty]("GI.GES.Objects.TimelineElement#g:method:addChildProperty"), [addChildToTrack]("GI.GES.Objects.Clip#g:method:addChildToTrack"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [addTopEffect]("GI.GES.Objects.Clip#g:method:addTopEffect"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [copy]("GI.GES.Objects.TimelineElement#g:method:copy"), [edit]("GI.GES.Objects.Container#g:method:edit"), [editFull]("GI.GES.Objects.TimelineElement#g:method:editFull"), [findTrackElement]("GI.GES.Objects.Clip#g:method:findTrackElement"), [findTrackElements]("GI.GES.Objects.Clip#g:method:findTrackElements"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.GES.Interfaces.MetaContainer#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [listChildrenProperties]("GI.GES.Objects.TimelineElement#g:method:listChildrenProperties"), [lookupChild]("GI.GES.Objects.TimelineElement#g:method:lookupChild"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [moveToLayer]("GI.GES.Objects.Clip#g:method:moveToLayer"), [moveToLayerFull]("GI.GES.Objects.Clip#g:method:moveToLayerFull"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [paste]("GI.GES.Objects.TimelineElement#g:method:paste"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerMeta"), [registerMetaBoolean]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaBoolean"), [registerMetaDate]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDate"), [registerMetaDateTime]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDateTime"), [registerMetaDouble]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDouble"), [registerMetaFloat]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaFloat"), [registerMetaInt]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt"), [registerMetaInt64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt64"), [registerMetaString]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaString"), [registerMetaUint]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint"), [registerMetaUint64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint64"), [registerStaticMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerStaticMeta"), [remove]("GI.GES.Objects.Container#g:method:remove"), [removeChildProperty]("GI.GES.Objects.TimelineElement#g:method:removeChildProperty"), [removeTopEffect]("GI.GES.Objects.Clip#g:method:removeTopEffect"), [ripple]("GI.GES.Objects.TimelineElement#g:method:ripple"), [rippleEnd]("GI.GES.Objects.TimelineElement#g:method:rippleEnd"), [rollEnd]("GI.GES.Objects.TimelineElement#g:method:rollEnd"), [rollStart]("GI.GES.Objects.TimelineElement#g:method:rollStart"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [split]("GI.GES.Objects.Clip#g:method:split"), [splitFull]("GI.GES.Objects.Clip#g:method:splitFull"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [trim]("GI.GES.Objects.TimelineElement#g:method:trim"), [ungroup]("GI.GES.Objects.Container#g:method:ungroup"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAsset]("GI.GES.Interfaces.Extractable#g:method:getAsset"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getChildProperty]("GI.GES.Objects.TimelineElement#g:method:getChildProperty"), [getChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:getChildPropertyByPspec"), [getChildren]("GI.GES.Objects.Container#g:method:getChildren"), [getColor]("GI.GES.Objects.TextOverlayClip#g:method:getColor"), [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.TextOverlayClip#g:method:getFontDesc"), [getHalignment]("GI.GES.Objects.TextOverlayClip#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.TextOverlayClip#g:method:getText"), [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.TextOverlayClip#g:method:getValignment"), [getXpos]("GI.GES.Objects.TextOverlayClip#g:method:getXpos"), [getYpos]("GI.GES.Objects.TextOverlayClip#g:method:getYpos").
-- 
-- ==== Setters
-- [setAsset]("GI.GES.Interfaces.Extractable#g:method:setAsset"), [setBoolean]("GI.GES.Interfaces.MetaContainer#g:method:setBoolean"), [setChildProperty]("GI.GES.Objects.TimelineElement#g:method:setChildProperty"), [setChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyByPspec"), [setChildPropertyFull]("GI.GES.Objects.TimelineElement#g:method:setChildPropertyFull"), [setColor]("GI.GES.Objects.TextOverlayClip#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.TextOverlayClip#g:method:setFontDesc"), [setHalign]("GI.GES.Objects.TextOverlayClip#g:method:setHalign"), [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.TextOverlayClip#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"), [setValign]("GI.GES.Objects.TextOverlayClip#g:method:setValign"), [setXpos]("GI.GES.Objects.TextOverlayClip#g:method:setXpos"), [setYpos]("GI.GES.Objects.TextOverlayClip#g:method:setYpos").

#if defined(ENABLE_OVERLOADING)
    ResolveTextOverlayClipMethod            ,
#endif

-- ** getColor #method:getColor#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipGetColorMethodInfo       ,
#endif
    textOverlayClipGetColor                 ,


-- ** getFontDesc #method:getFontDesc#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipGetFontDescMethodInfo    ,
#endif
    textOverlayClipGetFontDesc              ,


-- ** getHalignment #method:getHalignment#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipGetHalignmentMethodInfo  ,
#endif
    textOverlayClipGetHalignment            ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipGetTextMethodInfo        ,
#endif
    textOverlayClipGetText                  ,


-- ** getValignment #method:getValignment#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipGetValignmentMethodInfo  ,
#endif
    textOverlayClipGetValignment            ,


-- ** getXpos #method:getXpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipGetXposMethodInfo        ,
#endif
    textOverlayClipGetXpos                  ,


-- ** getYpos #method:getYpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipGetYposMethodInfo        ,
#endif
    textOverlayClipGetYpos                  ,


-- ** new #method:new#

    textOverlayClipNew                      ,


-- ** setColor #method:setColor#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipSetColorMethodInfo       ,
#endif
    textOverlayClipSetColor                 ,


-- ** setFontDesc #method:setFontDesc#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipSetFontDescMethodInfo    ,
#endif
    textOverlayClipSetFontDesc              ,


-- ** setHalign #method:setHalign#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipSetHalignMethodInfo      ,
#endif
    textOverlayClipSetHalign                ,


-- ** setText #method:setText#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipSetTextMethodInfo        ,
#endif
    textOverlayClipSetText                  ,


-- ** setValign #method:setValign#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipSetValignMethodInfo      ,
#endif
    textOverlayClipSetValign                ,


-- ** setXpos #method:setXpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipSetXposMethodInfo        ,
#endif
    textOverlayClipSetXpos                  ,


-- ** setYpos #method:setYpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipSetYposMethodInfo        ,
#endif
    textOverlayClipSetYpos                  ,




 -- * Properties


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

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipColorPropertyInfo        ,
#endif
    constructTextOverlayClipColor           ,
    getTextOverlayClipColor                 ,
    setTextOverlayClipColor                 ,
#if defined(ENABLE_OVERLOADING)
    textOverlayClipColor                    ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipFontDescPropertyInfo     ,
#endif
    constructTextOverlayClipFontDesc        ,
    getTextOverlayClipFontDesc              ,
    setTextOverlayClipFontDesc              ,
#if defined(ENABLE_OVERLOADING)
    textOverlayClipFontDesc                 ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipHalignmentPropertyInfo   ,
#endif
    constructTextOverlayClipHalignment      ,
    getTextOverlayClipHalignment            ,
    setTextOverlayClipHalignment            ,
#if defined(ENABLE_OVERLOADING)
    textOverlayClipHalignment               ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipTextPropertyInfo         ,
#endif
    constructTextOverlayClipText            ,
    getTextOverlayClipText                  ,
    setTextOverlayClipText                  ,
#if defined(ENABLE_OVERLOADING)
    textOverlayClipText                     ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipValignmentPropertyInfo   ,
#endif
    constructTextOverlayClipValignment      ,
    getTextOverlayClipValignment            ,
    setTextOverlayClipValignment            ,
#if defined(ENABLE_OVERLOADING)
    textOverlayClipValignment               ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipXposPropertyInfo         ,
#endif
    constructTextOverlayClipXpos            ,
    getTextOverlayClipXpos                  ,
    setTextOverlayClipXpos                  ,
#if defined(ENABLE_OVERLOADING)
    textOverlayClipXpos                     ,
#endif


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

#if defined(ENABLE_OVERLOADING)
    TextOverlayClipYposPropertyInfo         ,
#endif
    constructTextOverlayClipYpos            ,
    getTextOverlayClipYpos                  ,
    setTextOverlayClipYpos                  ,
#if defined(ENABLE_OVERLOADING)
    textOverlayClipYpos                     ,
#endif




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.GES.Enums as GES.Enums
import {-# SOURCE #-} qualified GI.GES.Interfaces.Extractable as GES.Extractable
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Clip as GES.Clip
import {-# SOURCE #-} qualified GI.GES.Objects.Container as GES.Container
import {-# SOURCE #-} qualified GI.GES.Objects.OperationClip as GES.OperationClip
import {-# SOURCE #-} qualified GI.GES.Objects.OverlayClip as GES.OverlayClip
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "ges_text_overlay_clip_get_type"
    c_ges_text_overlay_clip_get_type :: IO B.Types.GType

instance B.Types.TypedObject TextOverlayClip where
    glibType :: IO GType
glibType = IO GType
c_ges_text_overlay_clip_get_type

instance B.Types.GObject TextOverlayClip

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

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

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

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

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

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

#endif

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

#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' textOverlayClip #color
-- @
getTextOverlayClipColor :: (MonadIO m, IsTextOverlayClip o) => o -> m Word32
getTextOverlayClipColor :: forall (m :: * -> *) o.
(MonadIO m, IsTextOverlayClip o) =>
o -> m Word32
getTextOverlayClipColor o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"color"

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

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

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

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

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

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

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

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

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

-- | 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' textOverlayClip #halignment
-- @
getTextOverlayClipHalignment :: (MonadIO m, IsTextOverlayClip o) => o -> m GES.Enums.TextHAlign
getTextOverlayClipHalignment :: forall (m :: * -> *) o.
(MonadIO m, IsTextOverlayClip o) =>
o -> m TextHAlign
getTextOverlayClipHalignment o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"halignment"

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

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

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

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

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

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

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

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

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

-- | 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' textOverlayClip #valignment
-- @
getTextOverlayClipValignment :: (MonadIO m, IsTextOverlayClip o) => o -> m GES.Enums.TextVAlign
getTextOverlayClipValignment :: forall (m :: * -> *) o.
(MonadIO m, IsTextOverlayClip o) =>
o -> m TextVAlign
getTextOverlayClipValignment o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"valignment"

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

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

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipValignmentPropertyInfo
instance AttrInfo TextOverlayClipValignmentPropertyInfo where
    type AttrAllowedOps TextOverlayClipValignmentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextOverlayClipValignmentPropertyInfo = IsTextOverlayClip
    type AttrSetTypeConstraint TextOverlayClipValignmentPropertyInfo = (~) GES.Enums.TextVAlign
    type AttrTransferTypeConstraint TextOverlayClipValignmentPropertyInfo = (~) GES.Enums.TextVAlign
    type AttrTransferType TextOverlayClipValignmentPropertyInfo = GES.Enums.TextVAlign
    type AttrGetType TextOverlayClipValignmentPropertyInfo = GES.Enums.TextVAlign
    type AttrLabel TextOverlayClipValignmentPropertyInfo = "valignment"
    type AttrOrigin TextOverlayClipValignmentPropertyInfo = TextOverlayClip
    attrGet = getTextOverlayClipValignment
    attrSet = setTextOverlayClipValignment
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextOverlayClipValignment
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TextOverlayClip.valignment"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TextOverlayClip.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' textOverlayClip #xpos
-- @
getTextOverlayClipXpos :: (MonadIO m, IsTextOverlayClip o) => o -> m Double
getTextOverlayClipXpos :: forall (m :: * -> *) o.
(MonadIO m, IsTextOverlayClip o) =>
o -> m Double
getTextOverlayClipXpos o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"xpos"

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

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

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipXposPropertyInfo
instance AttrInfo TextOverlayClipXposPropertyInfo where
    type AttrAllowedOps TextOverlayClipXposPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint TextOverlayClipXposPropertyInfo = IsTextOverlayClip
    type AttrSetTypeConstraint TextOverlayClipXposPropertyInfo = (~) Double
    type AttrTransferTypeConstraint TextOverlayClipXposPropertyInfo = (~) Double
    type AttrTransferType TextOverlayClipXposPropertyInfo = Double
    type AttrGetType TextOverlayClipXposPropertyInfo = Double
    type AttrLabel TextOverlayClipXposPropertyInfo = "xpos"
    type AttrOrigin TextOverlayClipXposPropertyInfo = TextOverlayClip
    attrGet = getTextOverlayClipXpos
    attrSet = setTextOverlayClipXpos
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextOverlayClipXpos
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TextOverlayClip.xpos"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-TextOverlayClip.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' textOverlayClip #ypos
-- @
getTextOverlayClipYpos :: (MonadIO m, IsTextOverlayClip o) => o -> m Double
getTextOverlayClipYpos :: forall (m :: * -> *) o.
(MonadIO m, IsTextOverlayClip o) =>
o -> m Double
getTextOverlayClipYpos o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"ypos"

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

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

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

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TextOverlayClip
type instance O.AttributeList TextOverlayClip = TextOverlayClipAttributeList
type TextOverlayClipAttributeList = ('[ '("color", TextOverlayClipColorPropertyInfo), '("duration", GES.TimelineElement.TimelineElementDurationPropertyInfo), '("durationLimit", GES.Clip.ClipDurationLimitPropertyInfo), '("fontDesc", TextOverlayClipFontDescPropertyInfo), '("halignment", TextOverlayClipHalignmentPropertyInfo), '("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", TextOverlayClipTextPropertyInfo), '("timeline", GES.TimelineElement.TimelineElementTimelinePropertyInfo), '("valignment", TextOverlayClipValignmentPropertyInfo), '("xpos", TextOverlayClipXposPropertyInfo), '("ypos", TextOverlayClipYposPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
textOverlayClipColor :: AttrLabelProxy "color"
textOverlayClipColor = AttrLabelProxy

textOverlayClipFontDesc :: AttrLabelProxy "fontDesc"
textOverlayClipFontDesc = AttrLabelProxy

textOverlayClipHalignment :: AttrLabelProxy "halignment"
textOverlayClipHalignment = AttrLabelProxy

textOverlayClipText :: AttrLabelProxy "text"
textOverlayClipText = AttrLabelProxy

textOverlayClipValignment :: AttrLabelProxy "valignment"
textOverlayClipValignment = AttrLabelProxy

textOverlayClipXpos :: AttrLabelProxy "xpos"
textOverlayClipXpos = AttrLabelProxy

textOverlayClipYpos :: AttrLabelProxy "ypos"
textOverlayClipYpos = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "ges_text_overlay_clip_new" ges_text_overlay_clip_new :: 
    IO (Ptr TextOverlayClip)

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

#if defined(ENABLE_OVERLOADING)
#endif

-- method TextOverlayClip::get_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTextOverlayClip"
--                 , 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_text_overlay_clip_get_color" ges_text_overlay_clip_get_color :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    IO Word32

-- | Get the color used by /@source@/.
textOverlayClipGetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'
    -> m Word32
    -- ^ __Returns:__ The color used by /@source@/.
textOverlayClipGetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m Word32
textOverlayClipGetColor a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr TextOverlayClip -> IO Word32
ges_text_overlay_clip_get_color Ptr TextOverlayClip
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipGetColorMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipGetColorMethodInfo a signature where
    overloadedMethod = textOverlayClipGetColor

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


#endif

-- method TextOverlayClip::get_font_desc
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTextOverlayClip"
--                 , 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_text_overlay_clip_get_font_desc" ges_text_overlay_clip_get_font_desc :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    IO CString

-- | Get the pango font description used by /@self@/.
textOverlayClipGetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'
    -> m T.Text
    -- ^ __Returns:__ The pango font description used by /@self@/.
textOverlayClipGetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m Text
textOverlayClipGetFontDesc a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr TextOverlayClip -> IO CString
ges_text_overlay_clip_get_font_desc Ptr TextOverlayClip
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textOverlayClipGetFontDesc" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipGetFontDescMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipGetFontDescMethodInfo a signature where
    overloadedMethod = textOverlayClipGetFontDesc

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


#endif

-- method TextOverlayClip::get_halignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTextOverlayClip"
--                 , 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_text_overlay_clip_get_halignment" ges_text_overlay_clip_get_halignment :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    IO CUInt

-- | Get the horizontal aligment used by /@self@/.
textOverlayClipGetHalignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'
    -> m GES.Enums.TextHAlign
    -- ^ __Returns:__ The horizontal aligment used by /@self@/.
textOverlayClipGetHalignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m TextHAlign
textOverlayClipGetHalignment a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr TextOverlayClip -> IO CUInt
ges_text_overlay_clip_get_halignment Ptr TextOverlayClip
self'
    let result' :: TextHAlign
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return TextHAlign
result'

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

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


#endif

-- method TextOverlayClip::get_text
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTextOverlayClip"
--                 , 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_text_overlay_clip_get_text" ges_text_overlay_clip_get_text :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    IO CString

-- | Get the text currently set on /@self@/.
textOverlayClipGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'
    -> m T.Text
    -- ^ __Returns:__ The text currently set on /@self@/.
textOverlayClipGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m Text
textOverlayClipGetText a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr TextOverlayClip -> IO CString
ges_text_overlay_clip_get_text Ptr TextOverlayClip
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"textOverlayClipGetText" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
cstringToText CString
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipGetTextMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipGetTextMethodInfo a signature where
    overloadedMethod = textOverlayClipGetText

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


#endif

-- method TextOverlayClip::get_valignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTextOverlayClip"
--                 , 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_text_overlay_clip_get_valignment" ges_text_overlay_clip_get_valignment :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    IO CUInt

-- | Get the vertical aligment used by /@self@/.
textOverlayClipGetValignment ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'
    -> m GES.Enums.TextVAlign
    -- ^ __Returns:__ The vertical aligment used by /@self@/.
textOverlayClipGetValignment :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m TextVAlign
textOverlayClipGetValignment a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CUInt
result <- Ptr TextOverlayClip -> IO CUInt
ges_text_overlay_clip_get_valignment Ptr TextOverlayClip
self'
    let result' :: TextVAlign
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return TextVAlign
result'

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

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


#endif

-- method TextOverlayClip::get_xpos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTextOverlayClip"
--                 , 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_text_overlay_clip_get_xpos" ges_text_overlay_clip_get_xpos :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    IO CDouble

-- | Get the horizontal position used by /@source@/.
textOverlayClipGetXpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'
    -> m Double
    -- ^ __Returns:__ The horizontal position used by /@source@/.
textOverlayClipGetXpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m Double
textOverlayClipGetXpos a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TextOverlayClip -> IO CDouble
ges_text_overlay_clip_get_xpos Ptr TextOverlayClip
self'
    let result' :: Double
result' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipGetXposMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipGetXposMethodInfo a signature where
    overloadedMethod = textOverlayClipGetXpos

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


#endif

-- method TextOverlayClip::get_ypos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESTextOverlayClip"
--                 , 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_text_overlay_clip_get_ypos" ges_text_overlay_clip_get_ypos :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    IO CDouble

-- | Get the vertical position used by /@source@/.
textOverlayClipGetYpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'
    -> m Double
    -- ^ __Returns:__ The vertical position used by /@source@/.
textOverlayClipGetYpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m Double
textOverlayClipGetYpos a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TextOverlayClip -> IO CDouble
ges_text_overlay_clip_get_ypos Ptr TextOverlayClip
self'
    let result' :: Double
result' = forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipGetYposMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipGetYposMethodInfo a signature where
    overloadedMethod = textOverlayClipGetYpos

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


#endif

-- method TextOverlayClip::set_color
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTextOverlayClip* 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_text_overlay_clip_set_color" ges_text_overlay_clip_set_color :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    Word32 ->                               -- color : TBasicType TUInt32
    IO ()

-- | Sets the color of the text.
textOverlayClipSetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'* to set
    -> Word32
    -- ^ /@color@/: The color /@self@/ is being set to
    -> m ()
textOverlayClipSetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> Word32 -> m ()
textOverlayClipSetColor a
self Word32
color = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr TextOverlayClip -> Word32 -> IO ()
ges_text_overlay_clip_set_color Ptr TextOverlayClip
self' Word32
color
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipSetColorMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipSetColorMethodInfo a signature where
    overloadedMethod = textOverlayClipSetColor

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


#endif

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

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

-- | Sets the pango font description of the text
textOverlayClipSetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'*
    -> T.Text
    -- ^ /@fontDesc@/: the pango font description
    -> m ()
textOverlayClipSetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> Text -> m ()
textOverlayClipSetFontDesc a
self Text
fontDesc = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
fontDesc' <- Text -> IO CString
textToCString Text
fontDesc
    Ptr TextOverlayClip -> CString -> IO ()
ges_text_overlay_clip_set_font_desc Ptr TextOverlayClip
self' CString
fontDesc'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
fontDesc'
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method TextOverlayClip::set_halign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GESTextOverlayClip* 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_text_overlay_clip_set_halign" ges_text_overlay_clip_set_halign :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    CUInt ->                                -- halign : TInterface (Name {namespace = "GES", name = "TextHAlign"})
    IO ()

-- | Sets the horizontal aligment of the text.
textOverlayClipSetHalign ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'* to set horizontal alignement of text on
    -> GES.Enums.TextHAlign
    -- ^ /@halign@/: t'GI.GES.Enums.TextHAlign'
    -> m ()
textOverlayClipSetHalign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> TextHAlign -> m ()
textOverlayClipSetHalign a
self TextHAlign
halign = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let halign' :: CUInt
halign' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) TextHAlign
halign
    Ptr TextOverlayClip -> CUInt -> IO ()
ges_text_overlay_clip_set_halign Ptr TextOverlayClip
self' CUInt
halign'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

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

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

-- | Sets the text this clip will render.
textOverlayClipSetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'* to set text on
    -> T.Text
    -- ^ /@text@/: the text to render. an internal copy of this text will be
    -- made.
    -> m ()
textOverlayClipSetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> Text -> m ()
textOverlayClipSetText a
self Text
text = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
text' <- Text -> IO CString
textToCString Text
text
    Ptr TextOverlayClip -> CString -> IO ()
ges_text_overlay_clip_set_text Ptr TextOverlayClip
self' CString
text'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall a. Ptr a -> IO ()
freeMem CString
text'
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method TextOverlayClip::set_valign
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the #GESTextOverlayClip* 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_text_overlay_clip_set_valign" ges_text_overlay_clip_set_valign :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    CUInt ->                                -- valign : TInterface (Name {namespace = "GES", name = "TextVAlign"})
    IO ()

-- | Sets the vertical aligment of the text.
textOverlayClipSetValign ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'* to set vertical alignement of text on
    -> GES.Enums.TextVAlign
    -- ^ /@valign@/: t'GI.GES.Enums.TextVAlign'
    -> m ()
textOverlayClipSetValign :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> TextVAlign -> m ()
textOverlayClipSetValign a
self TextVAlign
valign = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let valign' :: CUInt
valign' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) TextVAlign
valign
    Ptr TextOverlayClip -> CUInt -> IO ()
ges_text_overlay_clip_set_valign Ptr TextOverlayClip
self' CUInt
valign'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

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

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


#endif

-- method TextOverlayClip::set_xpos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTextOverlayClip* 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_text_overlay_clip_set_xpos" ges_text_overlay_clip_set_xpos :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    CDouble ->                              -- position : TBasicType TDouble
    IO ()

-- | Sets the horizontal position of the text.
textOverlayClipSetXpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'* to set
    -> Double
    -- ^ /@position@/: The horizontal position /@self@/ is being set to
    -> m ()
textOverlayClipSetXpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> Double -> m ()
textOverlayClipSetXpos a
self Double
position = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CDouble
position' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
position
    Ptr TextOverlayClip -> CDouble -> IO ()
ges_text_overlay_clip_set_xpos Ptr TextOverlayClip
self' CDouble
position'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipSetXposMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipSetXposMethodInfo a signature where
    overloadedMethod = textOverlayClipSetXpos

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


#endif

-- method TextOverlayClip::set_ypos
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlayClip" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTextOverlayClip* 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_text_overlay_clip_set_ypos" ges_text_overlay_clip_set_ypos :: 
    Ptr TextOverlayClip ->                  -- self : TInterface (Name {namespace = "GES", name = "TextOverlayClip"})
    CDouble ->                              -- position : TBasicType TDouble
    IO ()

-- | Sets the vertical position of the text.
textOverlayClipSetYpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlayClip a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlayClip.TextOverlayClip'* to set
    -> Double
    -- ^ /@position@/: The vertical position /@self@/ is being set to
    -> m ()
textOverlayClipSetYpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> Double -> m ()
textOverlayClipSetYpos a
self Double
position = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    let position' :: CDouble
position' = forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
position
    Ptr TextOverlayClip -> CDouble -> IO ()
ges_text_overlay_clip_set_ypos Ptr TextOverlayClip
self' CDouble
position'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipSetYposMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTextOverlayClip a) => O.OverloadedMethod TextOverlayClipSetYposMethodInfo a signature where
    overloadedMethod = textOverlayClipSetYpos

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


#endif