{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Description of a tile. This structure allow to describe arbitrary tile
-- dimensions and sizes.
-- 
-- /Since: 1.22/

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

module GI.GstVideo.Structs.VideoTileInfo
    ( 

-- * Exported types
    VideoTileInfo(..)                       ,
    newZeroVideoTileInfo                    ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveVideoTileInfoMethod              ,
#endif



 -- * Properties


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

    getVideoTileInfoHeight                  ,
    setVideoTileInfoHeight                  ,
#if defined(ENABLE_OVERLOADING)
    videoTileInfo_height                    ,
#endif


-- ** size #attr:size#
-- | The size in bytes of a tile. This value must be divisible by
-- t'GI.GstVideo.Structs.VideoTileInfo.VideoTileInfo'.@/stride/@.
-- 
-- /Since: 1.22/

    getVideoTileInfoSize                    ,
    setVideoTileInfoSize                    ,
#if defined(ENABLE_OVERLOADING)
    videoTileInfo_size                      ,
#endif


-- ** stride #attr:stride#
-- | The stride (in bytes) of a tile line. Regardless if the tile have sub-tiles
-- this stride multiplied by the height should be equal to
-- t'GI.GstVideo.Structs.VideoTileInfo.VideoTileInfo'.@/size/@. This value is used to translate into linear stride
-- when older APIs are being used to expose this format.
-- 
-- /Since: 1.22/

    getVideoTileInfoStride                  ,
    setVideoTileInfoStride                  ,
#if defined(ENABLE_OVERLOADING)
    videoTileInfo_stride                    ,
#endif


-- ** width #attr:width#
-- | The width in pixels of a tile. This value can be zero if the number of
-- pixels per line is not an integer value.
-- 
-- /Since: 1.22/

    getVideoTileInfoWidth                   ,
    setVideoTileInfoWidth                   ,
#if defined(ENABLE_OVERLOADING)
    videoTileInfo_width                     ,
#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


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

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

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


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

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


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

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

videoTileInfo_width :: AttrLabelProxy "width"
videoTileInfo_width = 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' videoTileInfo #height
-- @
getVideoTileInfoHeight :: MonadIO m => VideoTileInfo -> m Word32
getVideoTileInfoHeight :: forall (m :: * -> *). MonadIO m => VideoTileInfo -> m Word32
getVideoTileInfoHeight VideoTileInfo
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
$ VideoTileInfo -> (Ptr VideoTileInfo -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTileInfo
s ((Ptr VideoTileInfo -> IO Word32) -> IO Word32)
-> (Ptr VideoTileInfo -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTileInfo
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoTileInfo
ptr Ptr VideoTileInfo -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: 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 “@height@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoTileInfo [ #height 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoTileInfoHeight :: MonadIO m => VideoTileInfo -> Word32 -> m ()
setVideoTileInfoHeight :: forall (m :: * -> *). MonadIO m => VideoTileInfo -> Word32 -> m ()
setVideoTileInfoHeight VideoTileInfo
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
$ VideoTileInfo -> (Ptr VideoTileInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTileInfo
s ((Ptr VideoTileInfo -> IO ()) -> IO ())
-> (Ptr VideoTileInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTileInfo
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoTileInfo
ptr Ptr VideoTileInfo -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Word32
val :: Word32)

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

videoTileInfo_height :: AttrLabelProxy "height"
videoTileInfo_height = AttrLabelProxy

#endif


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

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

videoTileInfo_stride :: AttrLabelProxy "stride"
videoTileInfo_stride = AttrLabelProxy

#endif


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

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

videoTileInfo_size :: AttrLabelProxy "size"
videoTileInfo_size = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoTileInfo
type instance O.AttributeList VideoTileInfo = VideoTileInfoAttributeList
type VideoTileInfoAttributeList = ('[ '("width", VideoTileInfoWidthFieldInfo), '("height", VideoTileInfoHeightFieldInfo), '("stride", VideoTileInfoStrideFieldInfo), '("size", VideoTileInfoSizeFieldInfo)] :: [(Symbol, DK.Type)])
#endif

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

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

#endif

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

#endif