{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Bar data should be included in video user data
-- whenever the rectangular picture area containing useful information
-- does not extend to the full height or width of the coded frame
-- and AFD alone is insufficient to describe the extent of the image.
-- 
-- Note: either vertical or horizontal bars are specified, but not both.
-- 
-- For more details, see:
-- 
-- https:\/\/www.atsc.org\/wp-content\/uploads\/2015\/03\/a_53-Part-4-2009.pdf
-- 
-- and SMPTE ST2016-1
-- 
-- /Since: 1.18/

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

module GI.GstVideo.Structs.VideoBarMeta
    ( 

-- * Exported types
    VideoBarMeta(..)                        ,
    newZeroVideoBarMeta                     ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveVideoBarMetaMethod               ,
#endif

-- ** getInfo #method:getInfo#

    videoBarMetaGetInfo                     ,




 -- * Properties


-- ** barData1 #attr:barData1#
-- | If /@isLetterbox@/ is true, then the value specifies the
--      last line of a horizontal letterbox bar area at top of reconstructed frame.
--      Otherwise, it specifies the last horizontal luminance sample of a vertical pillarbox
--      bar area at the left side of the reconstructed frame

    getVideoBarMetaBarData1                 ,
    setVideoBarMetaBarData1                 ,
#if defined(ENABLE_OVERLOADING)
    videoBarMeta_barData1                   ,
#endif


-- ** barData2 #attr:barData2#
-- | If /@isLetterbox@/ is true, then the value specifies the
--      first line of a horizontal letterbox bar area at bottom of reconstructed frame.
--      Otherwise, it specifies the first horizontal
--      luminance sample of a vertical pillarbox bar area at the right side of the reconstructed frame.

    getVideoBarMetaBarData2                 ,
    setVideoBarMetaBarData2                 ,
#if defined(ENABLE_OVERLOADING)
    videoBarMeta_barData2                   ,
#endif


-- ** field #attr:field#
-- | 0 for progressive or field 1 and 1 for field 2

    getVideoBarMetaField                    ,
    setVideoBarMetaField                    ,
#if defined(ENABLE_OVERLOADING)
    videoBarMeta_field                      ,
#endif


-- ** isLetterbox #attr:isLetterbox#
-- | if true then bar data specifies letterbox, otherwise pillarbox

    getVideoBarMetaIsLetterbox              ,
    setVideoBarMetaIsLetterbox              ,
#if defined(ENABLE_OVERLOADING)
    videoBarMeta_isLetterbox                ,
#endif


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

    getVideoBarMetaMeta                     ,
#if defined(ENABLE_OVERLOADING)
    videoBarMeta_meta                       ,
#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 qualified GI.Gst.Structs.Meta as Gst.Meta
import qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo

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

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

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


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

instance tag ~ 'AttrSet => Constructible VideoBarMeta tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr VideoBarMeta -> VideoBarMeta)
-> [AttrOp VideoBarMeta tag] -> m VideoBarMeta
new ManagedPtr VideoBarMeta -> VideoBarMeta
_ [AttrOp VideoBarMeta tag]
attrs = do
        VideoBarMeta
o <- m VideoBarMeta
forall (m :: * -> *). MonadIO m => m VideoBarMeta
newZeroVideoBarMeta
        VideoBarMeta -> [AttrOp VideoBarMeta 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set VideoBarMeta
o [AttrOp VideoBarMeta tag]
[AttrOp VideoBarMeta 'AttrSet]
attrs
        VideoBarMeta -> m VideoBarMeta
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoBarMeta
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' videoBarMeta #meta
-- @
getVideoBarMetaMeta :: MonadIO m => VideoBarMeta -> m Gst.Meta.Meta
getVideoBarMetaMeta :: forall (m :: * -> *). MonadIO m => VideoBarMeta -> m Meta
getVideoBarMetaMeta VideoBarMeta
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
$ VideoBarMeta -> (Ptr VideoBarMeta -> IO Meta) -> IO Meta
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoBarMeta
s ((Ptr VideoBarMeta -> IO Meta) -> IO Meta)
-> (Ptr VideoBarMeta -> IO Meta) -> IO Meta
forall a b. (a -> b) -> a -> b
$ \Ptr VideoBarMeta
ptr -> do
    let val :: Ptr Meta
val = Ptr VideoBarMeta
ptr Ptr VideoBarMeta -> 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 VideoBarMetaMetaFieldInfo
instance AttrInfo VideoBarMetaMetaFieldInfo where
    type AttrBaseTypeConstraint VideoBarMetaMetaFieldInfo = (~) VideoBarMeta
    type AttrAllowedOps VideoBarMetaMetaFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint VideoBarMetaMetaFieldInfo = (~) (Ptr Gst.Meta.Meta)
    type AttrTransferTypeConstraint VideoBarMetaMetaFieldInfo = (~)(Ptr Gst.Meta.Meta)
    type AttrTransferType VideoBarMetaMetaFieldInfo = (Ptr Gst.Meta.Meta)
    type AttrGetType VideoBarMetaMetaFieldInfo = Gst.Meta.Meta
    type AttrLabel VideoBarMetaMetaFieldInfo = "meta"
    type AttrOrigin VideoBarMetaMetaFieldInfo = VideoBarMeta
    attrGet = getVideoBarMetaMeta
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoBarMeta.meta"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.28/docs/GI-GstVideo-Structs-VideoBarMeta.html#g:attr:meta"
        })

videoBarMeta_meta :: AttrLabelProxy "meta"
videoBarMeta_meta = AttrLabelProxy

#endif


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

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

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

videoBarMeta_field :: AttrLabelProxy "field"
videoBarMeta_field = AttrLabelProxy

#endif


-- | Get the value of the “@is_letterbox@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoBarMeta #isLetterbox
-- @
getVideoBarMetaIsLetterbox :: MonadIO m => VideoBarMeta -> m Bool
getVideoBarMetaIsLetterbox :: forall (m :: * -> *). MonadIO m => VideoBarMeta -> m Bool
getVideoBarMetaIsLetterbox VideoBarMeta
s = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ VideoBarMeta -> (Ptr VideoBarMeta -> IO Bool) -> IO Bool
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoBarMeta
s ((Ptr VideoBarMeta -> IO Bool) -> IO Bool)
-> (Ptr VideoBarMeta -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr VideoBarMeta
ptr -> do
    CInt
val <- Ptr CInt -> IO CInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoBarMeta
ptr Ptr VideoBarMeta -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO CInt
    let val' :: Bool
val' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
val
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
val'

-- | Set the value of the “@is_letterbox@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoBarMeta [ #isLetterbox 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoBarMetaIsLetterbox :: MonadIO m => VideoBarMeta -> Bool -> m ()
setVideoBarMetaIsLetterbox :: forall (m :: * -> *). MonadIO m => VideoBarMeta -> Bool -> m ()
setVideoBarMetaIsLetterbox VideoBarMeta
s Bool
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
$ VideoBarMeta -> (Ptr VideoBarMeta -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoBarMeta
s ((Ptr VideoBarMeta -> IO ()) -> IO ())
-> (Ptr VideoBarMeta -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoBarMeta
ptr -> do
    let val' :: CInt
val' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
val
    Ptr CInt -> CInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoBarMeta
ptr Ptr VideoBarMeta -> Int -> Ptr CInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (CInt
val' :: CInt)

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

videoBarMeta_isLetterbox :: AttrLabelProxy "isLetterbox"
videoBarMeta_isLetterbox = AttrLabelProxy

#endif


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

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

videoBarMeta_barData1 :: AttrLabelProxy "barData1"
videoBarMeta_barData1 = AttrLabelProxy

#endif


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

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

videoBarMeta_barData2 :: AttrLabelProxy "barData2"
videoBarMeta_barData2 = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoBarMeta
type instance O.AttributeList VideoBarMeta = VideoBarMetaAttributeList
type VideoBarMetaAttributeList = ('[ '("meta", VideoBarMetaMetaFieldInfo), '("field", VideoBarMetaFieldFieldInfo), '("isLetterbox", VideoBarMetaIsLetterboxFieldInfo), '("barData1", VideoBarMetaBarData1FieldInfo), '("barData2", VideoBarMetaBarData2FieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method VideoBarMeta::get_info
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "MetaInfo" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_bar_meta_get_info" gst_video_bar_meta_get_info :: 
    IO (Ptr Gst.MetaInfo.MetaInfo)

-- | /No description available in the introspection data./
videoBarMetaGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Gst.MetaInfo.MetaInfo
videoBarMetaGetInfo :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MetaInfo
videoBarMetaGetInfo  = IO MetaInfo -> m MetaInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MetaInfo -> m MetaInfo) -> IO MetaInfo -> m MetaInfo
forall a b. (a -> b) -> a -> b
$ do
    Ptr MetaInfo
result <- IO (Ptr MetaInfo)
gst_video_bar_meta_get_info
    Text -> Ptr MetaInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoBarMetaGetInfo" Ptr MetaInfo
result
    MetaInfo
result' <- ((ManagedPtr MetaInfo -> MetaInfo) -> Ptr MetaInfo -> IO MetaInfo
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr MetaInfo -> MetaInfo
Gst.MetaInfo.MetaInfo) Ptr MetaInfo
result
    MetaInfo -> IO MetaInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MetaInfo
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

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

#endif

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

#endif