{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.GES.Objects.TextOverlay
    ( 

-- * Exported types
    TextOverlay(..)                         ,
    IsTextOverlay                           ,
    toTextOverlay                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addChildProperty]("GI.GES.Objects.TimelineElement#g:method:addChildProperty"), [addChildrenProps]("GI.GES.Objects.TrackElement#g:method:addChildrenProps"), [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [clampControlSource]("GI.GES.Objects.TrackElement#g:method:clampControlSource"), [copy]("GI.GES.Objects.TimelineElement#g:method:copy"), [edit]("GI.GES.Objects.TrackElement#g:method:edit"), [editFull]("GI.GES.Objects.TimelineElement#g:method:editFull"), [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"), [hasInternalSource]("GI.GES.Objects.TrackElement#g:method:hasInternalSource"), [isActive]("GI.GES.Objects.TrackElement#g:method:isActive"), [isCore]("GI.GES.Objects.TrackElement#g:method:isCore"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [listChildrenProperties]("GI.GES.Objects.TrackElement#g:method:listChildrenProperties"), [lookupChild]("GI.GES.Objects.TrackElement#g:method:lookupChild"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [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"), [removeChildProperty]("GI.GES.Objects.TimelineElement#g:method:removeChildProperty"), [removeControlBinding]("GI.GES.Objects.TrackElement#g:method:removeControlBinding"), [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"), [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"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getAllControlBindings]("GI.GES.Objects.TrackElement#g:method:getAllControlBindings"), [getAsset]("GI.GES.Interfaces.Extractable#g:method:getAsset"), [getAutoClampControlSources]("GI.GES.Objects.TrackElement#g:method:getAutoClampControlSources"), [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getChildProperty]("GI.GES.Objects.TimelineElement#g:method:getChildProperty"), [getChildPropertyByPspec]("GI.GES.Objects.TimelineElement#g:method:getChildPropertyByPspec"), [getColor]("GI.GES.Objects.TextOverlay#g:method:getColor"), [getControlBinding]("GI.GES.Objects.TrackElement#g:method:getControlBinding"), [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"), [getElement]("GI.GES.Objects.TrackElement#g:method:getElement"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getFontDesc]("GI.GES.Objects.TextOverlay#g:method:getFontDesc"), [getGnlobject]("GI.GES.Objects.TrackElement#g:method:getGnlobject"), [getHalignment]("GI.GES.Objects.TextOverlay#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"), [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"), [getNleobject]("GI.GES.Objects.TrackElement#g:method:getNleobject"), [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"), [getText]("GI.GES.Objects.TextOverlay#g:method:getText"), [getTimeline]("GI.GES.Objects.TimelineElement#g:method:getTimeline"), [getToplevelParent]("GI.GES.Objects.TimelineElement#g:method:getToplevelParent"), [getTrack]("GI.GES.Objects.TrackElement#g:method:getTrack"), [getTrackType]("GI.GES.Objects.TrackElement#g:method:getTrackType"), [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.TextOverlay#g:method:getValignment"), [getXpos]("GI.GES.Objects.TextOverlay#g:method:getXpos"), [getYpos]("GI.GES.Objects.TextOverlay#g:method:getYpos").
-- 
-- ==== Setters
-- [setActive]("GI.GES.Objects.TrackElement#g:method:setActive"), [setAsset]("GI.GES.Interfaces.Extractable#g:method:setAsset"), [setAutoClampControlSources]("GI.GES.Objects.TrackElement#g:method:setAutoClampControlSources"), [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.TextOverlay#g:method:setColor"), [setControlSource]("GI.GES.Objects.TrackElement#g:method:setControlSource"), [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.TextOverlay#g:method:setFontDesc"), [setHalignment]("GI.GES.Objects.TextOverlay#g:method:setHalignment"), [setHasInternalSource]("GI.GES.Objects.TrackElement#g:method:setHasInternalSource"), [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"), [setText]("GI.GES.Objects.TextOverlay#g:method:setText"), [setTimeline]("GI.GES.Objects.TimelineElement#g:method:setTimeline"), [setTrackType]("GI.GES.Objects.TrackElement#g:method:setTrackType"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64"), [setValignment]("GI.GES.Objects.TextOverlay#g:method:setValignment"), [setXpos]("GI.GES.Objects.TextOverlay#g:method:setXpos"), [setYpos]("GI.GES.Objects.TextOverlay#g:method:setYpos").

#if defined(ENABLE_OVERLOADING)
    ResolveTextOverlayMethod                ,
#endif

-- ** getColor #method:getColor#

#if defined(ENABLE_OVERLOADING)
    TextOverlayGetColorMethodInfo           ,
#endif
    textOverlayGetColor                     ,


-- ** getFontDesc #method:getFontDesc#

#if defined(ENABLE_OVERLOADING)
    TextOverlayGetFontDescMethodInfo        ,
#endif
    textOverlayGetFontDesc                  ,


-- ** getHalignment #method:getHalignment#

#if defined(ENABLE_OVERLOADING)
    TextOverlayGetHalignmentMethodInfo      ,
#endif
    textOverlayGetHalignment                ,


-- ** getText #method:getText#

#if defined(ENABLE_OVERLOADING)
    TextOverlayGetTextMethodInfo            ,
#endif
    textOverlayGetText                      ,


-- ** getValignment #method:getValignment#

#if defined(ENABLE_OVERLOADING)
    TextOverlayGetValignmentMethodInfo      ,
#endif
    textOverlayGetValignment                ,


-- ** getXpos #method:getXpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlayGetXposMethodInfo            ,
#endif
    textOverlayGetXpos                      ,


-- ** getYpos #method:getYpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlayGetYposMethodInfo            ,
#endif
    textOverlayGetYpos                      ,


-- ** new #method:new#

    textOverlayNew                          ,


-- ** setColor #method:setColor#

#if defined(ENABLE_OVERLOADING)
    TextOverlaySetColorMethodInfo           ,
#endif
    textOverlaySetColor                     ,


-- ** setFontDesc #method:setFontDesc#

#if defined(ENABLE_OVERLOADING)
    TextOverlaySetFontDescMethodInfo        ,
#endif
    textOverlaySetFontDesc                  ,


-- ** setHalignment #method:setHalignment#

#if defined(ENABLE_OVERLOADING)
    TextOverlaySetHalignmentMethodInfo      ,
#endif
    textOverlaySetHalignment                ,


-- ** setText #method:setText#

#if defined(ENABLE_OVERLOADING)
    TextOverlaySetTextMethodInfo            ,
#endif
    textOverlaySetText                      ,


-- ** setValignment #method:setValignment#

#if defined(ENABLE_OVERLOADING)
    TextOverlaySetValignmentMethodInfo      ,
#endif
    textOverlaySetValignment                ,


-- ** setXpos #method:setXpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlaySetXposMethodInfo            ,
#endif
    textOverlaySetXpos                      ,


-- ** setYpos #method:setYpos#

#if defined(ENABLE_OVERLOADING)
    TextOverlaySetYposMethodInfo            ,
#endif
    textOverlaySetYpos                      ,




    ) where

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

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

import {-# SOURCE #-} qualified GI.GES.Enums as GES.Enums
import {-# SOURCE #-} qualified GI.GES.Interfaces.Extractable as GES.Extractable
import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Operation as GES.Operation
import {-# SOURCE #-} qualified GI.GES.Objects.TimelineElement as GES.TimelineElement
import {-# SOURCE #-} qualified GI.GES.Objects.TrackElement as GES.TrackElement
import qualified GI.GObject.Objects.Object as GObject.Object

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

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

foreign import ccall "ges_text_overlay_get_type"
    c_ges_text_overlay_get_type :: IO B.Types.GType

instance B.Types.TypedObject TextOverlay where
    glibType :: IO GType
glibType = IO GType
c_ges_text_overlay_get_type

instance B.Types.GObject TextOverlay

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

instance O.HasParentTypes TextOverlay
type instance O.ParentTypes TextOverlay = '[GES.Operation.Operation, GES.TrackElement.TrackElement, GES.TimelineElement.TimelineElement, GObject.Object.Object, GES.Extractable.Extractable, GES.MetaContainer.MetaContainer]

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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveTextOverlayMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveTextOverlayMethod "addChildProperty" o = GES.TimelineElement.TimelineElementAddChildPropertyMethodInfo
    ResolveTextOverlayMethod "addChildrenProps" o = GES.TrackElement.TrackElementAddChildrenPropsMethodInfo
    ResolveTextOverlayMethod "addMetasFromString" o = GES.MetaContainer.MetaContainerAddMetasFromStringMethodInfo
    ResolveTextOverlayMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveTextOverlayMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveTextOverlayMethod "checkMetaRegistered" o = GES.MetaContainer.MetaContainerCheckMetaRegisteredMethodInfo
    ResolveTextOverlayMethod "clampControlSource" o = GES.TrackElement.TrackElementClampControlSourceMethodInfo
    ResolveTextOverlayMethod "copy" o = GES.TimelineElement.TimelineElementCopyMethodInfo
    ResolveTextOverlayMethod "edit" o = GES.TrackElement.TrackElementEditMethodInfo
    ResolveTextOverlayMethod "editFull" o = GES.TimelineElement.TimelineElementEditFullMethodInfo
    ResolveTextOverlayMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveTextOverlayMethod "foreach" o = GES.MetaContainer.MetaContainerForeachMethodInfo
    ResolveTextOverlayMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveTextOverlayMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveTextOverlayMethod "hasInternalSource" o = GES.TrackElement.TrackElementHasInternalSourceMethodInfo
    ResolveTextOverlayMethod "isActive" o = GES.TrackElement.TrackElementIsActiveMethodInfo
    ResolveTextOverlayMethod "isCore" o = GES.TrackElement.TrackElementIsCoreMethodInfo
    ResolveTextOverlayMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveTextOverlayMethod "listChildrenProperties" o = GES.TrackElement.TrackElementListChildrenPropertiesMethodInfo
    ResolveTextOverlayMethod "lookupChild" o = GES.TrackElement.TrackElementLookupChildMethodInfo
    ResolveTextOverlayMethod "metasToString" o = GES.MetaContainer.MetaContainerMetasToStringMethodInfo
    ResolveTextOverlayMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveTextOverlayMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveTextOverlayMethod "paste" o = GES.TimelineElement.TimelineElementPasteMethodInfo
    ResolveTextOverlayMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveTextOverlayMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveTextOverlayMethod "registerMeta" o = GES.MetaContainer.MetaContainerRegisterMetaMethodInfo
    ResolveTextOverlayMethod "registerMetaBoolean" o = GES.MetaContainer.MetaContainerRegisterMetaBooleanMethodInfo
    ResolveTextOverlayMethod "registerMetaDate" o = GES.MetaContainer.MetaContainerRegisterMetaDateMethodInfo
    ResolveTextOverlayMethod "registerMetaDateTime" o = GES.MetaContainer.MetaContainerRegisterMetaDateTimeMethodInfo
    ResolveTextOverlayMethod "registerMetaDouble" o = GES.MetaContainer.MetaContainerRegisterMetaDoubleMethodInfo
    ResolveTextOverlayMethod "registerMetaFloat" o = GES.MetaContainer.MetaContainerRegisterMetaFloatMethodInfo
    ResolveTextOverlayMethod "registerMetaInt" o = GES.MetaContainer.MetaContainerRegisterMetaIntMethodInfo
    ResolveTextOverlayMethod "registerMetaInt64" o = GES.MetaContainer.MetaContainerRegisterMetaInt64MethodInfo
    ResolveTextOverlayMethod "registerMetaString" o = GES.MetaContainer.MetaContainerRegisterMetaStringMethodInfo
    ResolveTextOverlayMethod "registerMetaUint" o = GES.MetaContainer.MetaContainerRegisterMetaUintMethodInfo
    ResolveTextOverlayMethod "registerMetaUint64" o = GES.MetaContainer.MetaContainerRegisterMetaUint64MethodInfo
    ResolveTextOverlayMethod "registerStaticMeta" o = GES.MetaContainer.MetaContainerRegisterStaticMetaMethodInfo
    ResolveTextOverlayMethod "removeChildProperty" o = GES.TimelineElement.TimelineElementRemoveChildPropertyMethodInfo
    ResolveTextOverlayMethod "removeControlBinding" o = GES.TrackElement.TrackElementRemoveControlBindingMethodInfo
    ResolveTextOverlayMethod "ripple" o = GES.TimelineElement.TimelineElementRippleMethodInfo
    ResolveTextOverlayMethod "rippleEnd" o = GES.TimelineElement.TimelineElementRippleEndMethodInfo
    ResolveTextOverlayMethod "rollEnd" o = GES.TimelineElement.TimelineElementRollEndMethodInfo
    ResolveTextOverlayMethod "rollStart" o = GES.TimelineElement.TimelineElementRollStartMethodInfo
    ResolveTextOverlayMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveTextOverlayMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveTextOverlayMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveTextOverlayMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveTextOverlayMethod "trim" o = GES.TimelineElement.TimelineElementTrimMethodInfo
    ResolveTextOverlayMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveTextOverlayMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveTextOverlayMethod "getAllControlBindings" o = GES.TrackElement.TrackElementGetAllControlBindingsMethodInfo
    ResolveTextOverlayMethod "getAsset" o = GES.Extractable.ExtractableGetAssetMethodInfo
    ResolveTextOverlayMethod "getAutoClampControlSources" o = GES.TrackElement.TrackElementGetAutoClampControlSourcesMethodInfo
    ResolveTextOverlayMethod "getBoolean" o = GES.MetaContainer.MetaContainerGetBooleanMethodInfo
    ResolveTextOverlayMethod "getChildProperty" o = GES.TimelineElement.TimelineElementGetChildPropertyMethodInfo
    ResolveTextOverlayMethod "getChildPropertyByPspec" o = GES.TimelineElement.TimelineElementGetChildPropertyByPspecMethodInfo
    ResolveTextOverlayMethod "getColor" o = TextOverlayGetColorMethodInfo
    ResolveTextOverlayMethod "getControlBinding" o = GES.TrackElement.TrackElementGetControlBindingMethodInfo
    ResolveTextOverlayMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveTextOverlayMethod "getDate" o = GES.MetaContainer.MetaContainerGetDateMethodInfo
    ResolveTextOverlayMethod "getDateTime" o = GES.MetaContainer.MetaContainerGetDateTimeMethodInfo
    ResolveTextOverlayMethod "getDouble" o = GES.MetaContainer.MetaContainerGetDoubleMethodInfo
    ResolveTextOverlayMethod "getDuration" o = GES.TimelineElement.TimelineElementGetDurationMethodInfo
    ResolveTextOverlayMethod "getElement" o = GES.TrackElement.TrackElementGetElementMethodInfo
    ResolveTextOverlayMethod "getFloat" o = GES.MetaContainer.MetaContainerGetFloatMethodInfo
    ResolveTextOverlayMethod "getFontDesc" o = TextOverlayGetFontDescMethodInfo
    ResolveTextOverlayMethod "getGnlobject" o = GES.TrackElement.TrackElementGetGnlobjectMethodInfo
    ResolveTextOverlayMethod "getHalignment" o = TextOverlayGetHalignmentMethodInfo
    ResolveTextOverlayMethod "getId" o = GES.Extractable.ExtractableGetIdMethodInfo
    ResolveTextOverlayMethod "getInpoint" o = GES.TimelineElement.TimelineElementGetInpointMethodInfo
    ResolveTextOverlayMethod "getInt" o = GES.MetaContainer.MetaContainerGetIntMethodInfo
    ResolveTextOverlayMethod "getInt64" o = GES.MetaContainer.MetaContainerGetInt64MethodInfo
    ResolveTextOverlayMethod "getLayerPriority" o = GES.TimelineElement.TimelineElementGetLayerPriorityMethodInfo
    ResolveTextOverlayMethod "getMarkerList" o = GES.MetaContainer.MetaContainerGetMarkerListMethodInfo
    ResolveTextOverlayMethod "getMaxDuration" o = GES.TimelineElement.TimelineElementGetMaxDurationMethodInfo
    ResolveTextOverlayMethod "getMeta" o = GES.MetaContainer.MetaContainerGetMetaMethodInfo
    ResolveTextOverlayMethod "getName" o = GES.TimelineElement.TimelineElementGetNameMethodInfo
    ResolveTextOverlayMethod "getNaturalFramerate" o = GES.TimelineElement.TimelineElementGetNaturalFramerateMethodInfo
    ResolveTextOverlayMethod "getNleobject" o = GES.TrackElement.TrackElementGetNleobjectMethodInfo
    ResolveTextOverlayMethod "getParent" o = GES.TimelineElement.TimelineElementGetParentMethodInfo
    ResolveTextOverlayMethod "getPriority" o = GES.TimelineElement.TimelineElementGetPriorityMethodInfo
    ResolveTextOverlayMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveTextOverlayMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveTextOverlayMethod "getStart" o = GES.TimelineElement.TimelineElementGetStartMethodInfo
    ResolveTextOverlayMethod "getString" o = GES.MetaContainer.MetaContainerGetStringMethodInfo
    ResolveTextOverlayMethod "getText" o = TextOverlayGetTextMethodInfo
    ResolveTextOverlayMethod "getTimeline" o = GES.TimelineElement.TimelineElementGetTimelineMethodInfo
    ResolveTextOverlayMethod "getToplevelParent" o = GES.TimelineElement.TimelineElementGetToplevelParentMethodInfo
    ResolveTextOverlayMethod "getTrack" o = GES.TrackElement.TrackElementGetTrackMethodInfo
    ResolveTextOverlayMethod "getTrackType" o = GES.TrackElement.TrackElementGetTrackTypeMethodInfo
    ResolveTextOverlayMethod "getTrackTypes" o = GES.TimelineElement.TimelineElementGetTrackTypesMethodInfo
    ResolveTextOverlayMethod "getUint" o = GES.MetaContainer.MetaContainerGetUintMethodInfo
    ResolveTextOverlayMethod "getUint64" o = GES.MetaContainer.MetaContainerGetUint64MethodInfo
    ResolveTextOverlayMethod "getValignment" o = TextOverlayGetValignmentMethodInfo
    ResolveTextOverlayMethod "getXpos" o = TextOverlayGetXposMethodInfo
    ResolveTextOverlayMethod "getYpos" o = TextOverlayGetYposMethodInfo
    ResolveTextOverlayMethod "setActive" o = GES.TrackElement.TrackElementSetActiveMethodInfo
    ResolveTextOverlayMethod "setAsset" o = GES.Extractable.ExtractableSetAssetMethodInfo
    ResolveTextOverlayMethod "setAutoClampControlSources" o = GES.TrackElement.TrackElementSetAutoClampControlSourcesMethodInfo
    ResolveTextOverlayMethod "setBoolean" o = GES.MetaContainer.MetaContainerSetBooleanMethodInfo
    ResolveTextOverlayMethod "setChildProperty" o = GES.TimelineElement.TimelineElementSetChildPropertyMethodInfo
    ResolveTextOverlayMethod "setChildPropertyByPspec" o = GES.TimelineElement.TimelineElementSetChildPropertyByPspecMethodInfo
    ResolveTextOverlayMethod "setChildPropertyFull" o = GES.TimelineElement.TimelineElementSetChildPropertyFullMethodInfo
    ResolveTextOverlayMethod "setColor" o = TextOverlaySetColorMethodInfo
    ResolveTextOverlayMethod "setControlSource" o = GES.TrackElement.TrackElementSetControlSourceMethodInfo
    ResolveTextOverlayMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveTextOverlayMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveTextOverlayMethod "setDate" o = GES.MetaContainer.MetaContainerSetDateMethodInfo
    ResolveTextOverlayMethod "setDateTime" o = GES.MetaContainer.MetaContainerSetDateTimeMethodInfo
    ResolveTextOverlayMethod "setDouble" o = GES.MetaContainer.MetaContainerSetDoubleMethodInfo
    ResolveTextOverlayMethod "setDuration" o = GES.TimelineElement.TimelineElementSetDurationMethodInfo
    ResolveTextOverlayMethod "setFloat" o = GES.MetaContainer.MetaContainerSetFloatMethodInfo
    ResolveTextOverlayMethod "setFontDesc" o = TextOverlaySetFontDescMethodInfo
    ResolveTextOverlayMethod "setHalignment" o = TextOverlaySetHalignmentMethodInfo
    ResolveTextOverlayMethod "setHasInternalSource" o = GES.TrackElement.TrackElementSetHasInternalSourceMethodInfo
    ResolveTextOverlayMethod "setInpoint" o = GES.TimelineElement.TimelineElementSetInpointMethodInfo
    ResolveTextOverlayMethod "setInt" o = GES.MetaContainer.MetaContainerSetIntMethodInfo
    ResolveTextOverlayMethod "setInt64" o = GES.MetaContainer.MetaContainerSetInt64MethodInfo
    ResolveTextOverlayMethod "setMarkerList" o = GES.MetaContainer.MetaContainerSetMarkerListMethodInfo
    ResolveTextOverlayMethod "setMaxDuration" o = GES.TimelineElement.TimelineElementSetMaxDurationMethodInfo
    ResolveTextOverlayMethod "setMeta" o = GES.MetaContainer.MetaContainerSetMetaMethodInfo
    ResolveTextOverlayMethod "setName" o = GES.TimelineElement.TimelineElementSetNameMethodInfo
    ResolveTextOverlayMethod "setParent" o = GES.TimelineElement.TimelineElementSetParentMethodInfo
    ResolveTextOverlayMethod "setPriority" o = GES.TimelineElement.TimelineElementSetPriorityMethodInfo
    ResolveTextOverlayMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveTextOverlayMethod "setStart" o = GES.TimelineElement.TimelineElementSetStartMethodInfo
    ResolveTextOverlayMethod "setString" o = GES.MetaContainer.MetaContainerSetStringMethodInfo
    ResolveTextOverlayMethod "setText" o = TextOverlaySetTextMethodInfo
    ResolveTextOverlayMethod "setTimeline" o = GES.TimelineElement.TimelineElementSetTimelineMethodInfo
    ResolveTextOverlayMethod "setTrackType" o = GES.TrackElement.TrackElementSetTrackTypeMethodInfo
    ResolveTextOverlayMethod "setUint" o = GES.MetaContainer.MetaContainerSetUintMethodInfo
    ResolveTextOverlayMethod "setUint64" o = GES.MetaContainer.MetaContainerSetUint64MethodInfo
    ResolveTextOverlayMethod "setValignment" o = TextOverlaySetValignmentMethodInfo
    ResolveTextOverlayMethod "setXpos" o = TextOverlaySetXposMethodInfo
    ResolveTextOverlayMethod "setYpos" o = TextOverlaySetYposMethodInfo
    ResolveTextOverlayMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TextOverlay
type instance O.AttributeList TextOverlay = TextOverlayAttributeList
type TextOverlayAttributeList = ('[ '("active", GES.TrackElement.TrackElementActivePropertyInfo), '("autoClampControlSources", GES.TrackElement.TrackElementAutoClampControlSourcesPropertyInfo), '("duration", GES.TimelineElement.TimelineElementDurationPropertyInfo), '("hasInternalSource", GES.TrackElement.TrackElementHasInternalSourcePropertyInfo), '("inPoint", GES.TimelineElement.TimelineElementInPointPropertyInfo), '("maxDuration", GES.TimelineElement.TimelineElementMaxDurationPropertyInfo), '("name", GES.TimelineElement.TimelineElementNamePropertyInfo), '("parent", GES.TimelineElement.TimelineElementParentPropertyInfo), '("priority", GES.TimelineElement.TimelineElementPriorityPropertyInfo), '("serialize", GES.TimelineElement.TimelineElementSerializePropertyInfo), '("start", GES.TimelineElement.TimelineElementStartPropertyInfo), '("timeline", GES.TimelineElement.TimelineElementTimelinePropertyInfo), '("track", GES.TrackElement.TrackElementTrackPropertyInfo), '("trackType", GES.TrackElement.TrackElementTrackTypePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList TextOverlay = TextOverlaySignalList
type TextOverlaySignalList = ('[ '("childPropertyAdded", GES.TimelineElement.TimelineElementChildPropertyAddedSignalInfo), '("childPropertyRemoved", GES.TimelineElement.TimelineElementChildPropertyRemovedSignalInfo), '("controlBindingAdded", GES.TrackElement.TrackElementControlBindingAddedSignalInfo), '("controlBindingRemoved", GES.TrackElement.TrackElementControlBindingRemovedSignalInfo), '("deepNotify", GES.TimelineElement.TimelineElementDeepNotifySignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("notifyMeta", GES.MetaContainer.MetaContainerNotifyMetaSignalInfo)] :: [(Symbol, DK.Type)])

#endif

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

foreign import ccall "ges_text_overlay_new" ges_text_overlay_new :: 
    IO (Ptr TextOverlay)

{-# DEPRECATED textOverlayNew ["(Since version 1.18)","This should never be called by applications as this will","be created by clips."] #-}
-- | Creates a new t'GI.GES.Objects.TextOverlay.TextOverlay'.
textOverlayNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m (Maybe TextOverlay)
    -- ^ __Returns:__ The newly created t'GI.GES.Objects.TextOverlay.TextOverlay' or
    -- 'P.Nothing' if something went wrong.
textOverlayNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
m (Maybe TextOverlay)
textOverlayNew  = IO (Maybe TextOverlay) -> m (Maybe TextOverlay)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TextOverlay) -> m (Maybe TextOverlay))
-> IO (Maybe TextOverlay) -> m (Maybe TextOverlay)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
result <- IO (Ptr TextOverlay)
ges_text_overlay_new
    Maybe TextOverlay
maybeResult <- Ptr TextOverlay
-> (Ptr TextOverlay -> IO TextOverlay) -> IO (Maybe TextOverlay)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TextOverlay
result ((Ptr TextOverlay -> IO TextOverlay) -> IO (Maybe TextOverlay))
-> (Ptr TextOverlay -> IO TextOverlay) -> IO (Maybe TextOverlay)
forall a b. (a -> b) -> a -> b
$ \Ptr TextOverlay
result' -> do
        TextOverlay
result'' <- ((ManagedPtr TextOverlay -> TextOverlay)
-> Ptr TextOverlay -> IO TextOverlay
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextOverlay -> TextOverlay
TextOverlay) Ptr TextOverlay
result'
        TextOverlay -> IO TextOverlay
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextOverlay
result''
    Maybe TextOverlay -> IO (Maybe TextOverlay)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TextOverlay
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

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

-- | Get the color used by /@source@/.
textOverlayGetColor ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlay a) =>
    a
    -- ^ /@self@/: a GESTextOverlay
    -> m Word32
    -- ^ __Returns:__ The color used by /@source@/.
textOverlayGetColor :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlay a) =>
a -> m Word32
textOverlayGetColor a
self = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
self' <- a -> IO (Ptr TextOverlay)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word32
result <- Ptr TextOverlay -> IO Word32
ges_text_overlay_get_color Ptr TextOverlay
self'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data TextOverlayGetColorMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlayGetColorMethodInfo a signature where
    overloadedMethod = textOverlayGetColor

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


#endif

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

-- | Get the pango font description currently set on /@source@/.
textOverlayGetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlay a) =>
    a
    -- ^ /@self@/: a GESTextOverlay
    -> m (Maybe T.Text)
    -- ^ __Returns:__ The pango font description currently set on /@source@/.
textOverlayGetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlay a) =>
a -> m (Maybe Text)
textOverlayGetFontDesc a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
self' <- a -> IO (Ptr TextOverlay)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr TextOverlay -> IO CString
ges_text_overlay_get_font_desc Ptr TextOverlay
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TextOverlayGetFontDescMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlayGetFontDescMethodInfo a signature where
    overloadedMethod = textOverlayGetFontDesc

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


#endif

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

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

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

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


#endif

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

-- | Get the text currently set on /@source@/.
textOverlayGetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlay a) =>
    a
    -- ^ /@self@/: a GESTextOverlay
    -> m (Maybe T.Text)
    -- ^ __Returns:__ The text currently set on /@source@/.
textOverlayGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlay a) =>
a -> m (Maybe Text)
textOverlayGetText a
self = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
self' <- a -> IO (Ptr TextOverlay)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
result <- Ptr TextOverlay -> IO CString
ges_text_overlay_get_text Ptr TextOverlay
self'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data TextOverlayGetTextMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlayGetTextMethodInfo a signature where
    overloadedMethod = textOverlayGetText

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


#endif

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

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

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

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


#endif

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

-- | Get the horizontal position used by /@source@/.
textOverlayGetXpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlay a) =>
    a
    -- ^ /@self@/: a GESTextOverlay
    -> m Double
    -- ^ __Returns:__ The horizontal position used by /@source@/.
textOverlayGetXpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlay a) =>
a -> m Double
textOverlayGetXpos a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
self' <- a -> IO (Ptr TextOverlay)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TextOverlay -> IO CDouble
ges_text_overlay_get_xpos Ptr TextOverlay
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TextOverlayGetXposMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlayGetXposMethodInfo a signature where
    overloadedMethod = textOverlayGetXpos

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


#endif

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

-- | Get the vertical position used by /@source@/.
textOverlayGetYpos ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlay a) =>
    a
    -- ^ /@self@/: a GESTextOverlay
    -> m Double
    -- ^ __Returns:__ The vertical position used by /@source@/.
textOverlayGetYpos :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlay a) =>
a -> m Double
textOverlayGetYpos a
self = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
self' <- a -> IO (Ptr TextOverlay)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CDouble
result <- Ptr TextOverlay -> IO CDouble
ges_text_overlay_get_ypos Ptr TextOverlay
self'
    let result' :: Double
result' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
result'

#if defined(ENABLE_OVERLOADING)
data TextOverlayGetYposMethodInfo
instance (signature ~ (m Double), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlayGetYposMethodInfo a signature where
    overloadedMethod = textOverlayGetYpos

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


#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TextOverlaySetColorMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlaySetColorMethodInfo a signature where
    overloadedMethod = textOverlaySetColor

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


#endif

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

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

-- | Sets the pango font description of the text this track element
-- will render.
textOverlaySetFontDesc ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlay a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlay.TextOverlay'
    -> Maybe (T.Text)
    -- ^ /@fontDesc@/: the pango font description
    -> m ()
textOverlaySetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlay a) =>
a -> Maybe Text -> m ()
textOverlaySetFontDesc a
self Maybe Text
fontDesc = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
self' <- a -> IO (Ptr TextOverlay)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeFontDesc <- case Maybe Text
fontDesc of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jFontDesc -> do
            CString
jFontDesc' <- Text -> IO CString
textToCString Text
jFontDesc
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jFontDesc'
    Ptr TextOverlay -> CString -> IO ()
ges_text_overlay_set_font_desc Ptr TextOverlay
self' CString
maybeFontDesc
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeFontDesc
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextOverlaySetFontDescMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlaySetFontDescMethodInfo a signature where
    overloadedMethod = textOverlaySetFontDesc

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


#endif

-- method TextOverlay::set_halignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlay" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTextOverlay* to set 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
--                       "The #GESTextHAlign defining the horizontal alignment\nof the text render by @self."
--                 , 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_set_halignment" ges_text_overlay_set_halignment :: 
    Ptr TextOverlay ->                      -- self : TInterface (Name {namespace = "GES", name = "TextOverlay"})
    CUInt ->                                -- halign : TInterface (Name {namespace = "GES", name = "TextHAlign"})
    IO ()

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

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

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


#endif

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

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

-- | Sets the text this track element will render.
textOverlaySetText ::
    (B.CallStack.HasCallStack, MonadIO m, IsTextOverlay a) =>
    a
    -- ^ /@self@/: the t'GI.GES.Objects.TextOverlay.TextOverlay'* to set text on
    -> Maybe (T.Text)
    -- ^ /@text@/: the text to render. an internal copy of this text will be
    -- made.
    -> m ()
textOverlaySetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlay a) =>
a -> Maybe Text -> m ()
textOverlaySetText a
self Maybe Text
text = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlay
self' <- a -> IO (Ptr TextOverlay)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CString
maybeText <- case Maybe Text
text of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jText -> do
            CString
jText' <- Text -> IO CString
textToCString Text
jText
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jText'
    Ptr TextOverlay -> CString -> IO ()
ges_text_overlay_set_text Ptr TextOverlay
self' CString
maybeText
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeText
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data TextOverlaySetTextMethodInfo
instance (signature ~ (Maybe (T.Text) -> m ()), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlaySetTextMethodInfo a signature where
    overloadedMethod = textOverlaySetText

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


#endif

-- method TextOverlay::set_valignment
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "TextOverlay" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GESTextOverlay* to set 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
--                       "The #GESTextVAlign defining the vertical alignment\nof the text render by @self."
--                 , 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_set_valignment" ges_text_overlay_set_valignment :: 
    Ptr TextOverlay ->                      -- self : TInterface (Name {namespace = "GES", name = "TextOverlay"})
    CUInt ->                                -- valign : TInterface (Name {namespace = "GES", name = "TextVAlign"})
    IO ()

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

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

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


#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TextOverlaySetXposMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlaySetXposMethodInfo a signature where
    overloadedMethod = textOverlaySetXpos

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


#endif

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

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

#if defined(ENABLE_OVERLOADING)
data TextOverlaySetYposMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsTextOverlay a) => O.OverloadedMethod TextOverlaySetYposMethodInfo a signature where
    overloadedMethod = textOverlaySetYpos

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


#endif