{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Extra alignment parameters for the memory of video buffers. This
-- structure is usually used to configure the bufferpool if it supports the
-- 'GI.GstVideo.Constants.BUFFER_POOL_OPTION_VIDEO_ALIGNMENT'.

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

module GI.GstVideo.Structs.VideoAlignment
    ( 

-- * Exported types
    VideoAlignment(..)                      ,
    newZeroVideoAlignment                   ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [reset]("GI.GstVideo.Structs.VideoAlignment#g:method:reset").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveVideoAlignmentMethod             ,
#endif

-- ** reset #method:reset#

#if defined(ENABLE_OVERLOADING)
    VideoAlignmentResetMethodInfo           ,
#endif
    videoAlignmentReset                     ,




 -- * Properties


-- ** paddingBottom #attr:paddingBottom#
-- | extra pixels on the bottom

    getVideoAlignmentPaddingBottom          ,
    setVideoAlignmentPaddingBottom          ,
#if defined(ENABLE_OVERLOADING)
    videoAlignment_paddingBottom            ,
#endif


-- ** paddingLeft #attr:paddingLeft#
-- | extra pixels on the left side

    getVideoAlignmentPaddingLeft            ,
    setVideoAlignmentPaddingLeft            ,
#if defined(ENABLE_OVERLOADING)
    videoAlignment_paddingLeft              ,
#endif


-- ** paddingRight #attr:paddingRight#
-- | extra pixels on the right side

    getVideoAlignmentPaddingRight           ,
    setVideoAlignmentPaddingRight           ,
#if defined(ENABLE_OVERLOADING)
    videoAlignment_paddingRight             ,
#endif


-- ** paddingTop #attr:paddingTop#
-- | extra pixels on the top

    getVideoAlignmentPaddingTop             ,
    setVideoAlignmentPaddingTop             ,
#if defined(ENABLE_OVERLOADING)
    videoAlignment_paddingTop               ,
#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.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.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 VideoAlignment = VideoAlignment (SP.ManagedPtr VideoAlignment)
    deriving (VideoAlignment -> VideoAlignment -> Bool
(VideoAlignment -> VideoAlignment -> Bool)
-> (VideoAlignment -> VideoAlignment -> Bool) -> Eq VideoAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoAlignment -> VideoAlignment -> Bool
$c/= :: VideoAlignment -> VideoAlignment -> Bool
== :: VideoAlignment -> VideoAlignment -> Bool
$c== :: VideoAlignment -> VideoAlignment -> Bool
Eq)

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

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


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

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


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

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

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

videoAlignment_paddingTop :: AttrLabelProxy "paddingTop"
videoAlignment_paddingTop = AttrLabelProxy

#endif


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

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

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

videoAlignment_paddingBottom :: AttrLabelProxy "paddingBottom"
videoAlignment_paddingBottom = AttrLabelProxy

#endif


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

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

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

videoAlignment_paddingLeft :: AttrLabelProxy "paddingLeft"
videoAlignment_paddingLeft = AttrLabelProxy

#endif


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

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

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

videoAlignment_paddingRight :: AttrLabelProxy "paddingRight"
videoAlignment_paddingRight = AttrLabelProxy

#endif


-- XXX Skipped attribute for "VideoAlignment:stride_align"
-- Not implemented: Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TUInt)

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoAlignment
type instance O.AttributeList VideoAlignment = VideoAlignmentAttributeList
type VideoAlignmentAttributeList = ('[ '("paddingTop", VideoAlignmentPaddingTopFieldInfo), '("paddingBottom", VideoAlignmentPaddingBottomFieldInfo), '("paddingLeft", VideoAlignmentPaddingLeftFieldInfo), '("paddingRight", VideoAlignmentPaddingRightFieldInfo)] :: [(Symbol, *)])
#endif

-- method VideoAlignment::reset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "align"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoAlignment" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoAlignment"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_alignment_reset" gst_video_alignment_reset :: 
    Ptr VideoAlignment ->                   -- align : TInterface (Name {namespace = "GstVideo", name = "VideoAlignment"})
    IO ()

-- | Set /@align@/ to its default values with no padding and no alignment.
videoAlignmentReset ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoAlignment
    -- ^ /@align@/: a t'GI.GstVideo.Structs.VideoAlignment.VideoAlignment'
    -> m ()
videoAlignmentReset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoAlignment -> m ()
videoAlignmentReset VideoAlignment
align = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoAlignment
align' <- VideoAlignment -> IO (Ptr VideoAlignment)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoAlignment
align
    Ptr VideoAlignment -> IO ()
gst_video_alignment_reset Ptr VideoAlignment
align'
    VideoAlignment -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoAlignment
align
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoAlignmentResetMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VideoAlignmentResetMethodInfo VideoAlignment signature where
    overloadedMethod = videoAlignmentReset

instance O.OverloadedMethodInfo VideoAlignmentResetMethodInfo VideoAlignment where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoAlignment.videoAlignmentReset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.25/docs/GI-GstVideo-Structs-VideoAlignment.html#v:videoAlignmentReset"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoAlignmentMethod (t :: Symbol) (o :: *) :: * where
    ResolveVideoAlignmentMethod "reset" o = VideoAlignmentResetMethodInfo
    ResolveVideoAlignmentMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif