{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Metadata type that holds information about the positioning, size,
-- transparency and composition operator of a video frame in the timeline
-- composition.
-- 
-- /Since: 1.24/

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

module GI.GES.Structs.FrameCompositionMeta
    ( 

-- * Exported types
    FrameCompositionMeta(..)                ,
    newZeroFrameCompositionMeta             ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveFrameCompositionMetaMethod       ,
#endif



 -- * Properties


-- ** alpha #attr:alpha#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_alpha              ,
#endif
    getFrameCompositionMetaAlpha            ,
    setFrameCompositionMetaAlpha            ,


-- ** height #attr:height#
-- | The desired height of the video. -1 means that no scaling should be
-- applied.

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_height             ,
#endif
    getFrameCompositionMetaHeight           ,
    setFrameCompositionMetaHeight           ,


-- ** meta #attr:meta#
-- | the parent t'GI.Gst.Structs.Meta.Meta'.

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_meta               ,
#endif
    getFrameCompositionMetaMeta             ,


-- ** operator #attr:operator#
-- | The blending operator for the source.

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_operator           ,
#endif
    getFrameCompositionMetaOperator         ,
    setFrameCompositionMetaOperator         ,


-- ** posx #attr:posx#
-- | The desired x position.

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_posx               ,
#endif
    getFrameCompositionMetaPosx             ,
    setFrameCompositionMetaPosx             ,


-- ** posy #attr:posy#
-- | The desired y position.

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_posy               ,
#endif
    getFrameCompositionMetaPosy             ,
    setFrameCompositionMetaPosy             ,


-- ** width #attr:width#
-- | The desired width of the video. -1 means that no scaling should beapplied
-- applied.

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_width              ,
#endif
    getFrameCompositionMetaWidth            ,
    setFrameCompositionMetaWidth            ,


-- ** zorder #attr:zorder#
-- | The desired z order.

#if defined(ENABLE_OVERLOADING)
    frameCompositionMeta_zorder             ,
#endif
    getFrameCompositionMetaZorder           ,
    setFrameCompositionMetaZorder           ,




    ) 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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.Gst.Structs.Meta as Gst.Meta

#else
import qualified GI.Gst.Structs.Meta as Gst.Meta

#endif

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

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

instance BoxedPtr FrameCompositionMeta where
    boxedPtrCopy :: FrameCompositionMeta -> IO FrameCompositionMeta
boxedPtrCopy = \FrameCompositionMeta
p -> FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO FrameCompositionMeta)
-> IO FrameCompositionMeta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr FrameCompositionMeta
p (Int -> Ptr FrameCompositionMeta -> IO (Ptr FrameCompositionMeta)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr FrameCompositionMeta -> IO (Ptr FrameCompositionMeta))
-> (Ptr FrameCompositionMeta -> IO FrameCompositionMeta)
-> Ptr FrameCompositionMeta
-> IO FrameCompositionMeta
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr FrameCompositionMeta -> FrameCompositionMeta)
-> Ptr FrameCompositionMeta -> IO FrameCompositionMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr FrameCompositionMeta -> FrameCompositionMeta
FrameCompositionMeta)
    boxedPtrFree :: FrameCompositionMeta -> IO ()
boxedPtrFree = \FrameCompositionMeta
x -> FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr FrameCompositionMeta
x Ptr FrameCompositionMeta -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr FrameCompositionMeta where
    boxedPtrCalloc :: IO (Ptr FrameCompositionMeta)
boxedPtrCalloc = Int -> IO (Ptr FrameCompositionMeta)
forall a. Int -> IO (Ptr a)
callocBytes Int
64


-- | Construct a `FrameCompositionMeta` struct initialized to zero.
newZeroFrameCompositionMeta :: MonadIO m => m FrameCompositionMeta
newZeroFrameCompositionMeta :: forall (m :: * -> *). MonadIO m => m FrameCompositionMeta
newZeroFrameCompositionMeta = IO FrameCompositionMeta -> m FrameCompositionMeta
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO FrameCompositionMeta -> m FrameCompositionMeta)
-> IO FrameCompositionMeta -> m FrameCompositionMeta
forall a b. (a -> b) -> a -> b
$ IO (Ptr FrameCompositionMeta)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr FrameCompositionMeta)
-> (Ptr FrameCompositionMeta -> IO FrameCompositionMeta)
-> IO FrameCompositionMeta
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr FrameCompositionMeta -> FrameCompositionMeta)
-> Ptr FrameCompositionMeta -> IO FrameCompositionMeta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr FrameCompositionMeta -> FrameCompositionMeta
FrameCompositionMeta

instance tag ~ 'AttrSet => Constructible FrameCompositionMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr FrameCompositionMeta -> FrameCompositionMeta)
-> [AttrOp FrameCompositionMeta tag] -> m FrameCompositionMeta
new ManagedPtr FrameCompositionMeta -> FrameCompositionMeta
_ [AttrOp FrameCompositionMeta tag]
attrs = do
        FrameCompositionMeta
o <- m FrameCompositionMeta
forall (m :: * -> *). MonadIO m => m FrameCompositionMeta
newZeroFrameCompositionMeta
        FrameCompositionMeta
-> [AttrOp FrameCompositionMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set FrameCompositionMeta
o [AttrOp FrameCompositionMeta tag]
[AttrOp FrameCompositionMeta 'AttrSet]
attrs
        FrameCompositionMeta -> m FrameCompositionMeta
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return FrameCompositionMeta
o


-- | Get the value of the “@meta@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #meta
-- @
getFrameCompositionMetaMeta :: MonadIO m => FrameCompositionMeta -> m Gst.Meta.Meta
getFrameCompositionMetaMeta :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Meta
getFrameCompositionMetaMeta FrameCompositionMeta
s = IO Meta -> m Meta
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Meta -> m Meta) -> IO Meta -> m Meta
forall a b. (a -> b) -> a -> b
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Meta) -> IO Meta)
-> (Ptr FrameCompositionMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr Meta
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Gst.Meta.Meta)
    Meta
val' <- ((ManagedPtr Meta -> Meta) -> Ptr Meta -> IO Meta
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Meta -> Meta
Gst.Meta.Meta) Ptr Meta
val
    Meta -> IO Meta
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Meta
val'

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaMetaFieldInfo
instance AttrInfo FrameCompositionMetaMetaFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaMetaFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint FrameCompositionMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType FrameCompositionMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType FrameCompositionMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel FrameCompositionMetaMetaFieldInfo = "meta"
    type AttrOrigin FrameCompositionMetaMetaFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.meta"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:meta"
        })

frameCompositionMeta_meta :: AttrLabelProxy "meta"
frameCompositionMeta_meta = AttrLabelProxy

#endif


-- | Get the value of the “@alpha@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #alpha
-- @
getFrameCompositionMetaAlpha :: MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaAlpha :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaAlpha FrameCompositionMeta
s = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Double) -> IO Double)
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@alpha@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' frameCompositionMeta [ #alpha 'Data.GI.Base.Attributes.:=' value ]
-- @
setFrameCompositionMetaAlpha :: MonadIO m => FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaAlpha :: forall (m :: * -> *).
MonadIO m =>
FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaAlpha FrameCompositionMeta
s Double
val = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO ()) -> IO ())
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaAlphaFieldInfo
instance AttrInfo FrameCompositionMetaAlphaFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaAlphaFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaAlphaFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaAlphaFieldInfo = (~) Double
    type AttrTransferTypeConstraint FrameCompositionMetaAlphaFieldInfo = (~)Double
    type AttrTransferType FrameCompositionMetaAlphaFieldInfo = Double
    type AttrGetType FrameCompositionMetaAlphaFieldInfo = Double
    type AttrLabel FrameCompositionMetaAlphaFieldInfo = "alpha"
    type AttrOrigin FrameCompositionMetaAlphaFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaAlpha
    attrSet = setFrameCompositionMetaAlpha
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.alpha"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:alpha"
        })

frameCompositionMeta_alpha :: AttrLabelProxy "alpha"
frameCompositionMeta_alpha = AttrLabelProxy

#endif


-- | Get the value of the “@posx@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #posx
-- @
getFrameCompositionMetaPosx :: MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaPosx :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaPosx FrameCompositionMeta
s = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Double) -> IO Double)
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@posx@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' frameCompositionMeta [ #posx 'Data.GI.Base.Attributes.:=' value ]
-- @
setFrameCompositionMetaPosx :: MonadIO m => FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaPosx :: forall (m :: * -> *).
MonadIO m =>
FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaPosx FrameCompositionMeta
s Double
val = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO ()) -> IO ())
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaPosxFieldInfo
instance AttrInfo FrameCompositionMetaPosxFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaPosxFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaPosxFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaPosxFieldInfo = (~) Double
    type AttrTransferTypeConstraint FrameCompositionMetaPosxFieldInfo = (~)Double
    type AttrTransferType FrameCompositionMetaPosxFieldInfo = Double
    type AttrGetType FrameCompositionMetaPosxFieldInfo = Double
    type AttrLabel FrameCompositionMetaPosxFieldInfo = "posx"
    type AttrOrigin FrameCompositionMetaPosxFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaPosx
    attrSet = setFrameCompositionMetaPosx
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.posx"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:posx"
        })

frameCompositionMeta_posx :: AttrLabelProxy "posx"
frameCompositionMeta_posx = AttrLabelProxy

#endif


-- | Get the value of the “@posy@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #posy
-- @
getFrameCompositionMetaPosy :: MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaPosy :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaPosy FrameCompositionMeta
s = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Double) -> IO Double)
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@posy@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' frameCompositionMeta [ #posy 'Data.GI.Base.Attributes.:=' value ]
-- @
setFrameCompositionMetaPosy :: MonadIO m => FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaPosy :: forall (m :: * -> *).
MonadIO m =>
FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaPosy FrameCompositionMeta
s Double
val = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO ()) -> IO ())
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaPosyFieldInfo
instance AttrInfo FrameCompositionMetaPosyFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaPosyFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaPosyFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaPosyFieldInfo = (~) Double
    type AttrTransferTypeConstraint FrameCompositionMetaPosyFieldInfo = (~)Double
    type AttrTransferType FrameCompositionMetaPosyFieldInfo = Double
    type AttrGetType FrameCompositionMetaPosyFieldInfo = Double
    type AttrLabel FrameCompositionMetaPosyFieldInfo = "posy"
    type AttrOrigin FrameCompositionMetaPosyFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaPosy
    attrSet = setFrameCompositionMetaPosy
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.posy"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:posy"
        })

frameCompositionMeta_posy :: AttrLabelProxy "posy"
frameCompositionMeta_posy = AttrLabelProxy

#endif


-- | Get the value of the “@height@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #height
-- @
getFrameCompositionMetaHeight :: MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaHeight :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaHeight FrameCompositionMeta
s = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Double) -> IO Double)
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@height@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' frameCompositionMeta [ #height 'Data.GI.Base.Attributes.:=' value ]
-- @
setFrameCompositionMetaHeight :: MonadIO m => FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaHeight :: forall (m :: * -> *).
MonadIO m =>
FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaHeight FrameCompositionMeta
s Double
val = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO ()) -> IO ())
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
40) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaHeightFieldInfo
instance AttrInfo FrameCompositionMetaHeightFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaHeightFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaHeightFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaHeightFieldInfo = (~) Double
    type AttrTransferTypeConstraint FrameCompositionMetaHeightFieldInfo = (~)Double
    type AttrTransferType FrameCompositionMetaHeightFieldInfo = Double
    type AttrGetType FrameCompositionMetaHeightFieldInfo = Double
    type AttrLabel FrameCompositionMetaHeightFieldInfo = "height"
    type AttrOrigin FrameCompositionMetaHeightFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaHeight
    attrSet = setFrameCompositionMetaHeight
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.height"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:height"
        })

frameCompositionMeta_height :: AttrLabelProxy "height"
frameCompositionMeta_height = AttrLabelProxy

#endif


-- | Get the value of the “@width@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #width
-- @
getFrameCompositionMetaWidth :: MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaWidth :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Double
getFrameCompositionMetaWidth FrameCompositionMeta
s = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Double) -> IO Double)
-> (Ptr FrameCompositionMeta -> IO Double) -> IO Double
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    CDouble
val <- Ptr CDouble -> IO CDouble
forall a. Storable a => Ptr a -> IO a
peek (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) :: IO CDouble
    let val' :: Double
val' = CDouble -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac CDouble
val
    Double -> IO Double
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Double
val'

-- | Set the value of the “@width@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' frameCompositionMeta [ #width 'Data.GI.Base.Attributes.:=' value ]
-- @
setFrameCompositionMetaWidth :: MonadIO m => FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaWidth :: forall (m :: * -> *).
MonadIO m =>
FrameCompositionMeta -> Double -> m ()
setFrameCompositionMetaWidth FrameCompositionMeta
s Double
val = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO ()) -> IO ())
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    let val' :: CDouble
val' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
val
    Ptr CDouble -> CDouble -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr CDouble
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
48) (CDouble
val' :: CDouble)

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaWidthFieldInfo
instance AttrInfo FrameCompositionMetaWidthFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaWidthFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaWidthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaWidthFieldInfo = (~) Double
    type AttrTransferTypeConstraint FrameCompositionMetaWidthFieldInfo = (~)Double
    type AttrTransferType FrameCompositionMetaWidthFieldInfo = Double
    type AttrGetType FrameCompositionMetaWidthFieldInfo = Double
    type AttrLabel FrameCompositionMetaWidthFieldInfo = "width"
    type AttrOrigin FrameCompositionMetaWidthFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaWidth
    attrSet = setFrameCompositionMetaWidth
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.width"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:width"
        })

frameCompositionMeta_width :: AttrLabelProxy "width"
frameCompositionMeta_width = AttrLabelProxy

#endif


-- | Get the value of the “@zorder@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #zorder
-- @
getFrameCompositionMetaZorder :: MonadIO m => FrameCompositionMeta -> m Word32
getFrameCompositionMetaZorder :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Word32
getFrameCompositionMetaZorder FrameCompositionMeta
s = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Word32) -> IO Word32)
-> (Ptr FrameCompositionMeta -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@zorder@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' frameCompositionMeta [ #zorder 'Data.GI.Base.Attributes.:=' value ]
-- @
setFrameCompositionMetaZorder :: MonadIO m => FrameCompositionMeta -> Word32 -> m ()
setFrameCompositionMetaZorder :: forall (m :: * -> *).
MonadIO m =>
FrameCompositionMeta -> Word32 -> m ()
setFrameCompositionMetaZorder FrameCompositionMeta
s Word32
val = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO ()) -> IO ())
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
56) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaZorderFieldInfo
instance AttrInfo FrameCompositionMetaZorderFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaZorderFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaZorderFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaZorderFieldInfo = (~) Word32
    type AttrTransferTypeConstraint FrameCompositionMetaZorderFieldInfo = (~)Word32
    type AttrTransferType FrameCompositionMetaZorderFieldInfo = Word32
    type AttrGetType FrameCompositionMetaZorderFieldInfo = Word32
    type AttrLabel FrameCompositionMetaZorderFieldInfo = "zorder"
    type AttrOrigin FrameCompositionMetaZorderFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaZorder
    attrSet = setFrameCompositionMetaZorder
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.zorder"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:zorder"
        })

frameCompositionMeta_zorder :: AttrLabelProxy "zorder"
frameCompositionMeta_zorder = AttrLabelProxy

#endif


-- | Get the value of the “@operator@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' frameCompositionMeta #operator
-- @
getFrameCompositionMetaOperator :: MonadIO m => FrameCompositionMeta -> m Int32
getFrameCompositionMetaOperator :: forall (m :: * -> *). MonadIO m => FrameCompositionMeta -> m Int32
getFrameCompositionMetaOperator FrameCompositionMeta
s = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO Int32) -> IO Int32)
-> (Ptr FrameCompositionMeta -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60) :: IO Int32
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val

-- | Set the value of the “@operator@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' frameCompositionMeta [ #operator 'Data.GI.Base.Attributes.:=' value ]
-- @
setFrameCompositionMetaOperator :: MonadIO m => FrameCompositionMeta -> Int32 -> m ()
setFrameCompositionMetaOperator :: forall (m :: * -> *).
MonadIO m =>
FrameCompositionMeta -> Int32 -> m ()
setFrameCompositionMetaOperator FrameCompositionMeta
s Int32
val = 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
$ FrameCompositionMeta
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr FrameCompositionMeta
s ((Ptr FrameCompositionMeta -> IO ()) -> IO ())
-> (Ptr FrameCompositionMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr FrameCompositionMeta
ptr -> do
    Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr FrameCompositionMeta
ptr Ptr FrameCompositionMeta -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
60) (Int32
val :: Int32)

#if defined(ENABLE_OVERLOADING)
data FrameCompositionMetaOperatorFieldInfo
instance AttrInfo FrameCompositionMetaOperatorFieldInfo where
    type AttrBaseTypeConstraint FrameCompositionMetaOperatorFieldInfo = (~) FrameCompositionMeta
    type AttrAllowedOps FrameCompositionMetaOperatorFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint FrameCompositionMetaOperatorFieldInfo = (~) Int32
    type AttrTransferTypeConstraint FrameCompositionMetaOperatorFieldInfo = (~)Int32
    type AttrTransferType FrameCompositionMetaOperatorFieldInfo = Int32
    type AttrGetType FrameCompositionMetaOperatorFieldInfo = Int32
    type AttrLabel FrameCompositionMetaOperatorFieldInfo = "operator"
    type AttrOrigin FrameCompositionMetaOperatorFieldInfo = FrameCompositionMeta
    attrGet = getFrameCompositionMetaOperator
    attrSet = setFrameCompositionMetaOperator
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Structs.FrameCompositionMeta.operator"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.5/docs/GI-GES-Structs-FrameCompositionMeta.html#g:attr:operator"
        })

frameCompositionMeta_operator :: AttrLabelProxy "operator"
frameCompositionMeta_operator = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList FrameCompositionMeta
type instance O.AttributeList FrameCompositionMeta = FrameCompositionMetaAttributeList
type FrameCompositionMetaAttributeList = ('[ '("meta", FrameCompositionMetaMetaFieldInfo), '("alpha", FrameCompositionMetaAlphaFieldInfo), '("posx", FrameCompositionMetaPosxFieldInfo), '("posy", FrameCompositionMetaPosyFieldInfo), '("height", FrameCompositionMetaHeightFieldInfo), '("width", FrameCompositionMetaWidthFieldInfo), '("zorder", FrameCompositionMetaZorderFieldInfo), '("operator", FrameCompositionMetaOperatorFieldInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveFrameCompositionMetaMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveFrameCompositionMetaMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif