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

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

#if defined(ENABLE_OVERLOADING)
type family ResolveTextOverlayClipMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"color"

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

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

#if defined(ENABLE_OVERLOADING)
data 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.4/docs/GI-GES-Objects-TextOverlayClip.html#g:attr:color"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipFontDescPropertyInfo
instance AttrInfo TextOverlayClipFontDescPropertyInfo where
    type AttrAllowedOps TextOverlayClipFontDescPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TextOverlayClipFontDescPropertyInfo = IsTextOverlayClip
    type AttrSetTypeConstraint TextOverlayClipFontDescPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TextOverlayClipFontDescPropertyInfo = (~) T.Text
    type AttrTransferType TextOverlayClipFontDescPropertyInfo = T.Text
    type AttrGetType TextOverlayClipFontDescPropertyInfo = (Maybe T.Text)
    type AttrLabel TextOverlayClipFontDescPropertyInfo = "font-desc"
    type AttrOrigin TextOverlayClipFontDescPropertyInfo = TextOverlayClip
    attrGet = getTextOverlayClipFontDesc
    attrSet = setTextOverlayClipFontDesc
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextOverlayClipFontDesc
    attrClear = clearTextOverlayClipFontDesc
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TextOverlayClip.fontDesc"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/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 = IO TextHAlign -> m TextHAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TextHAlign -> m TextHAlign) -> IO TextHAlign -> m TextHAlign
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TextHAlign
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"halignment"

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

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

#if defined(ENABLE_OVERLOADING)
data 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.4/docs/GI-GES-Objects-TextOverlayClip.html#g:attr:halignment"
        })
#endif

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

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

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

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

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

#if defined(ENABLE_OVERLOADING)
data TextOverlayClipTextPropertyInfo
instance AttrInfo TextOverlayClipTextPropertyInfo where
    type AttrAllowedOps TextOverlayClipTextPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TextOverlayClipTextPropertyInfo = IsTextOverlayClip
    type AttrSetTypeConstraint TextOverlayClipTextPropertyInfo = (~) T.Text
    type AttrTransferTypeConstraint TextOverlayClipTextPropertyInfo = (~) T.Text
    type AttrTransferType TextOverlayClipTextPropertyInfo = T.Text
    type AttrGetType TextOverlayClipTextPropertyInfo = (Maybe T.Text)
    type AttrLabel TextOverlayClipTextPropertyInfo = "text"
    type AttrOrigin TextOverlayClipTextPropertyInfo = TextOverlayClip
    attrGet = getTextOverlayClipText
    attrSet = setTextOverlayClipText
    attrTransfer _ v = do
        return v
    attrConstruct = constructTextOverlayClipText
    attrClear = clearTextOverlayClipText
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.TextOverlayClip.text"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.4/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 = IO TextVAlign -> m TextVAlign
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO TextVAlign -> m TextVAlign) -> IO TextVAlign -> m TextVAlign
forall a b. (a -> b) -> a -> b
$ o -> String -> IO TextVAlign
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"valignment"

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

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

#if defined(ENABLE_OVERLOADING)
data 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.4/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 = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"xpos"

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

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

#if defined(ENABLE_OVERLOADING)
data 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.4/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 = IO Double -> m Double
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Double -> m Double) -> IO Double -> m Double
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Double
forall a. GObject a => a -> String -> IO Double
B.Properties.getObjectPropertyDouble o
obj String
"ypos"

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

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

#if defined(ENABLE_OVERLOADING)
data 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.4/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, DK.Type)])
#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, DK.Type)])

#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  = IO (Maybe TextOverlayClip) -> m (Maybe TextOverlayClip)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TextOverlayClip) -> m (Maybe TextOverlayClip))
-> IO (Maybe TextOverlayClip) -> m (Maybe TextOverlayClip)
forall a b. (a -> b) -> a -> b
$ do
    Ptr TextOverlayClip
result <- IO (Ptr TextOverlayClip)
ges_text_overlay_clip_new
    Maybe TextOverlayClip
maybeResult <- Ptr TextOverlayClip
-> (Ptr TextOverlayClip -> IO TextOverlayClip)
-> IO (Maybe TextOverlayClip)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TextOverlayClip
result ((Ptr TextOverlayClip -> IO TextOverlayClip)
 -> IO (Maybe TextOverlayClip))
-> (Ptr TextOverlayClip -> IO TextOverlayClip)
-> IO (Maybe TextOverlayClip)
forall a b. (a -> b) -> a -> b
$ \Ptr TextOverlayClip
result' -> do
        TextOverlayClip
result'' <- ((ManagedPtr TextOverlayClip -> TextOverlayClip)
-> Ptr TextOverlayClip -> IO TextOverlayClip
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TextOverlayClip -> TextOverlayClip
TextOverlayClip) Ptr TextOverlayClip
result'
        TextOverlayClip -> IO TextOverlayClip
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TextOverlayClip
result''
    Maybe TextOverlayClip -> IO (Maybe TextOverlayClip)
forall a. a -> IO a
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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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'
    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 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.4/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 (Maybe T.Text)
    -- ^ __Returns:__ The pango font description used by /@self@/.
textOverlayClipGetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m (Maybe Text)
textOverlayClipGetFontDesc 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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'
    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 TextOverlayClipGetFontDescMethodInfo
instance (signature ~ (m (Maybe 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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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' = (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 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.4/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 (Maybe T.Text)
    -- ^ __Returns:__ The text currently set on /@self@/.
textOverlayClipGetText :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> m (Maybe Text)
textOverlayClipGetText 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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'
    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 TextOverlayClipGetTextMethodInfo
instance (signature ~ (m (Maybe 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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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' = (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 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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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' = 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 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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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' = 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 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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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
    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 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.4/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 = 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_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'*
    -> Maybe (T.Text)
    -- ^ /@fontDesc@/: the pango font description
    -> m ()
textOverlayClipSetFontDesc :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsTextOverlayClip a) =>
a -> Maybe Text -> m ()
textOverlayClipSetFontDesc 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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 TextOverlayClip -> CString -> IO ()
ges_text_overlay_clip_set_font_desc Ptr TextOverlayClip
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 TextOverlayClipSetFontDescMethodInfo
instance (signature ~ (Maybe (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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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 TextOverlayClip -> CUInt -> IO ()
ges_text_overlay_clip_set_halign Ptr TextOverlayClip
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 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.4/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 = 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_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
    -> Maybe (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 -> Maybe Text -> m ()
textOverlayClipSetText 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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 TextOverlayClip -> CString -> IO ()
ges_text_overlay_clip_set_text Ptr TextOverlayClip
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 TextOverlayClipSetTextMethodInfo
instance (signature ~ (Maybe (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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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 TextOverlayClip -> CUInt -> IO ()
ges_text_overlay_clip_set_valign Ptr TextOverlayClip
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 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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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 TextOverlayClip -> CDouble -> IO ()
ges_text_overlay_clip_set_xpos Ptr TextOverlayClip
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 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.4/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 = 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 TextOverlayClip
self' <- a -> IO (Ptr TextOverlayClip)
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 TextOverlayClip -> CDouble -> IO ()
ges_text_overlay_clip_set_ypos Ptr TextOverlayClip
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 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.4/docs/GI-GES-Objects-TextOverlayClip.html#v:textOverlayClipSetYpos"
        })


#endif