    {-# LANGUAGE TypeApplications #-}

    -- | Copyright  : Will Thompson and Iñaki García Etxebarria
    -- License    : LGPL-2.1
    -- Maintainer : Iñaki García Etxebarria
    --
    -- The t'GI.HarfBuzz.Structs.GlyphPositionT.GlyphPositionT' is the structure that holds the positions of the
    -- glyph in both horizontal and vertical directions. All positions in
    -- t'GI.HarfBuzz.Structs.GlyphPositionT.GlyphPositionT' are relative to the current point.

    #if !defined(__HADDOCK_VERSION__)
    #define ENABLE_OVERLOADING
    #endif

    module GI.HarfBuzz.Structs.GlyphPositionT
        (

    -- * Exported types
        GlyphPositionT(..)                      ,
        newZeroGlyphPositionT                   ,

     -- * Methods

    #if defined(ENABLE_OVERLOADING)
        ResolveGlyphPositionTMethod             ,
    #endif

     -- * Properties

    -- ** xAdvance #attr:xAdvance#
    -- | how much the line advances after drawing this glyph when setting
    --             text in horizontal direction.

        getGlyphPositionTXAdvance               ,
    #if defined(ENABLE_OVERLOADING)
        glyphPositionT_xAdvance                 ,
    #endif
        setGlyphPositionTXAdvance               ,

    -- ** xOffset #attr:xOffset#
    -- | how much the glyph moves on the X-axis before drawing it, this
    --            should not affect how much the line advances.

        getGlyphPositionTXOffset                ,
    #if defined(ENABLE_OVERLOADING)
        glyphPositionT_xOffset                  ,
    #endif
        setGlyphPositionTXOffset                ,

    -- ** yAdvance #attr:yAdvance#
    -- | how much the line advances after drawing this glyph when setting
    --             text in vertical direction.

        getGlyphPositionTYAdvance               ,
    #if defined(ENABLE_OVERLOADING)
        glyphPositionT_yAdvance                 ,
    #endif
        setGlyphPositionTYAdvance               ,

    -- ** yOffset #attr:yOffset#
    -- | how much the glyph moves on the Y-axis before drawing it, this
    --            should not affect how much the line advances.

        getGlyphPositionTYOffset                ,
    #if defined(ENABLE_OVERLOADING)
        glyphPositionT_yOffset                  ,
    #endif
        setGlyphPositionTYOffset                ,

        ) 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)

    #else

    #endif

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

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

    foreign import ccall "hb_gobject_glyph_position_get_type" c_hb_gobject_glyph_position_get_type ::
        IO GType

    type instance O.ParentTypes GlyphPositionT = '[]
    instance O.HasParentTypes GlyphPositionT

    instance B.Types.TypedObject GlyphPositionT where
        glibType :: IO GType
    glibType = IO GType
    c_hb_gobject_glyph_position_get_type

    instance B.Types.GBoxed GlyphPositionT

    -- | Convert 'GlyphPositionT' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
    instance B.GValue.IsGValue (Maybe GlyphPositionT) where
        gvalueGType_ :: IO GType
    gvalueGType_ = IO GType
    c_hb_gobject_glyph_position_get_type
        gvalueSet_ :: Ptr GValue -> Maybe GlyphPositionT -> IO ()
    gvalueSet_ Ptr GValue
    gv Maybe GlyphPositionT
    P.Nothing = Ptr GValue -> Ptr GlyphPositionT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv (Ptr GlyphPositionT
    forall a. Ptr a
    FP.nullPtr :: FP.Ptr GlyphPositionT)
        gvalueSet_ Ptr GValue
    gv (P.Just GlyphPositionT
    obj) = GlyphPositionT -> (Ptr GlyphPositionT -> IO ()) -> IO ()
    forall a c.
    (HasCallStack, ManagedPtrNewtype a) =>
    a -> (Ptr a -> IO c) -> IO c
    B.ManagedPtr.withManagedPtr GlyphPositionT
    obj (Ptr GValue -> Ptr GlyphPositionT -> IO ()
    forall a. Ptr GValue -> Ptr a -> IO ()
    B.GValue.set_boxed Ptr GValue
    gv)
        gvalueGet_ :: Ptr GValue -> IO (Maybe GlyphPositionT)
    gvalueGet_ Ptr GValue
    gv = do
            Ptr GlyphPositionT
    ptr <- Ptr GValue -> IO (Ptr GlyphPositionT)
    forall b. Ptr GValue -> IO (Ptr b)
    B.GValue.get_boxed Ptr GValue
    gv :: IO (Ptr GlyphPositionT)
            if Ptr GlyphPositionT
    ptr Ptr GlyphPositionT -> Ptr GlyphPositionT -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Ptr GlyphPositionT
    forall a. Ptr a
    FP.nullPtr
            then GlyphPositionT -> Maybe GlyphPositionT
    forall a. a -> Maybe a
    P.Just (GlyphPositionT -> Maybe GlyphPositionT)
    -> IO GlyphPositionT -> IO (Maybe GlyphPositionT)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (ManagedPtr GlyphPositionT -> GlyphPositionT)
    -> Ptr GlyphPositionT -> IO GlyphPositionT
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    B.ManagedPtr.newBoxed ManagedPtr GlyphPositionT -> GlyphPositionT
    GlyphPositionT Ptr GlyphPositionT
    ptr
            else Maybe GlyphPositionT -> IO (Maybe GlyphPositionT)
    forall a. a -> IO a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe GlyphPositionT
    forall a. Maybe a
    P.Nothing

    -- | Construct a `GlyphPositionT` struct initialized to zero.
    newZeroGlyphPositionT :: MonadIO m => m GlyphPositionT
    newZeroGlyphPositionT :: forall (m :: * -> *). MonadIO m => m GlyphPositionT
    newZeroGlyphPositionT = IO GlyphPositionT -> m GlyphPositionT
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO (IO GlyphPositionT -> m GlyphPositionT)
    -> IO GlyphPositionT -> m GlyphPositionT
    forall a b. (a -> b) -> a -> b
    $ Int -> IO (Ptr GlyphPositionT)
    forall a. GBoxed a => Int -> IO (Ptr a)
    callocBoxedBytes Int
    20 IO (Ptr GlyphPositionT)
    -> (Ptr GlyphPositionT -> IO GlyphPositionT) -> IO GlyphPositionT
    forall a b. IO a -> (a -> IO b) -> IO b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= (ManagedPtr GlyphPositionT -> GlyphPositionT)
    -> Ptr GlyphPositionT -> IO GlyphPositionT
    forall a.
    (HasCallStack, GBoxed a) =>
    (ManagedPtr a -> a) -> Ptr a -> IO a
    wrapBoxed ManagedPtr GlyphPositionT -> GlyphPositionT
    GlyphPositionT

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

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

    #if defined(ENABLE_OVERLOADING)
    data GlyphPositionTXAdvanceFieldInfo
    instance AttrInfo GlyphPositionTXAdvanceFieldInfo where
        type AttrBaseTypeConstraint GlyphPositionTXAdvanceFieldInfo = (~) GlyphPositionT
        type AttrAllowedOps GlyphPositionTXAdvanceFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphPositionTXAdvanceFieldInfo = (~) Int32
        type AttrTransferTypeConstraint GlyphPositionTXAdvanceFieldInfo = (~)Int32
        type AttrTransferType GlyphPositionTXAdvanceFieldInfo = Int32
        type AttrGetType GlyphPositionTXAdvanceFieldInfo = Int32
        type AttrLabel GlyphPositionTXAdvanceFieldInfo = "x_advance"
        type AttrOrigin GlyphPositionTXAdvanceFieldInfo = GlyphPositionT
        attrGet = getGlyphPositionTXAdvance
        attrSet = setGlyphPositionTXAdvance
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.HarfBuzz.Structs.GlyphPositionT.xAdvance"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.10/docs/GI-HarfBuzz-Structs-GlyphPositionT.html#g:attr:xAdvance"
            })

    glyphPositionT_xAdvance :: AttrLabelProxy "xAdvance"
    glyphPositionT_xAdvance = AttrLabelProxy

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    data GlyphPositionTYAdvanceFieldInfo
    instance AttrInfo GlyphPositionTYAdvanceFieldInfo where
        type AttrBaseTypeConstraint GlyphPositionTYAdvanceFieldInfo = (~) GlyphPositionT
        type AttrAllowedOps GlyphPositionTYAdvanceFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphPositionTYAdvanceFieldInfo = (~) Int32
        type AttrTransferTypeConstraint GlyphPositionTYAdvanceFieldInfo = (~)Int32
        type AttrTransferType GlyphPositionTYAdvanceFieldInfo = Int32
        type AttrGetType GlyphPositionTYAdvanceFieldInfo = Int32
        type AttrLabel GlyphPositionTYAdvanceFieldInfo = "y_advance"
        type AttrOrigin GlyphPositionTYAdvanceFieldInfo = GlyphPositionT
        attrGet = getGlyphPositionTYAdvance
        attrSet = setGlyphPositionTYAdvance
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.HarfBuzz.Structs.GlyphPositionT.yAdvance"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.10/docs/GI-HarfBuzz-Structs-GlyphPositionT.html#g:attr:yAdvance"
            })

    glyphPositionT_yAdvance :: AttrLabelProxy "yAdvance"
    glyphPositionT_yAdvance = AttrLabelProxy

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    data GlyphPositionTXOffsetFieldInfo
    instance AttrInfo GlyphPositionTXOffsetFieldInfo where
        type AttrBaseTypeConstraint GlyphPositionTXOffsetFieldInfo = (~) GlyphPositionT
        type AttrAllowedOps GlyphPositionTXOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphPositionTXOffsetFieldInfo = (~) Int32
        type AttrTransferTypeConstraint GlyphPositionTXOffsetFieldInfo = (~)Int32
        type AttrTransferType GlyphPositionTXOffsetFieldInfo = Int32
        type AttrGetType GlyphPositionTXOffsetFieldInfo = Int32
        type AttrLabel GlyphPositionTXOffsetFieldInfo = "x_offset"
        type AttrOrigin GlyphPositionTXOffsetFieldInfo = GlyphPositionT
        attrGet = getGlyphPositionTXOffset
        attrSet = setGlyphPositionTXOffset
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.HarfBuzz.Structs.GlyphPositionT.xOffset"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.10/docs/GI-HarfBuzz-Structs-GlyphPositionT.html#g:attr:xOffset"
            })

    glyphPositionT_xOffset :: AttrLabelProxy "xOffset"
    glyphPositionT_xOffset = AttrLabelProxy

    #endif

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

    #if defined(ENABLE_OVERLOADING)
    data GlyphPositionTYOffsetFieldInfo
    instance AttrInfo GlyphPositionTYOffsetFieldInfo where
        type AttrBaseTypeConstraint GlyphPositionTYOffsetFieldInfo = (~) GlyphPositionT
        type AttrAllowedOps GlyphPositionTYOffsetFieldInfo = '[ 'AttrSet, 'AttrGet]
        type AttrSetTypeConstraint GlyphPositionTYOffsetFieldInfo = (~) Int32
        type AttrTransferTypeConstraint GlyphPositionTYOffsetFieldInfo = (~)Int32
        type AttrTransferType GlyphPositionTYOffsetFieldInfo = Int32
        type AttrGetType GlyphPositionTYOffsetFieldInfo = Int32
        type AttrLabel GlyphPositionTYOffsetFieldInfo = "y_offset"
        type AttrOrigin GlyphPositionTYOffsetFieldInfo = GlyphPositionT
        attrGet = getGlyphPositionTYOffset
        attrSet = setGlyphPositionTYOffset
        attrConstruct = undefined
        attrClear = undefined
        attrTransfer _ v = do
            return v
        dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
            O.resolvedSymbolName = "GI.HarfBuzz.Structs.GlyphPositionT.yOffset"
            , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.10/docs/GI-HarfBuzz-Structs-GlyphPositionT.html#g:attr:yOffset"
            })

    glyphPositionT_yOffset :: AttrLabelProxy "yOffset"
    glyphPositionT_yOffset = AttrLabelProxy

    #endif

    #if defined(ENABLE_OVERLOADING)
    instance O.HasAttributeList GlyphPositionT
    type instance O.AttributeList GlyphPositionT = GlyphPositionTAttributeList
    type GlyphPositionTAttributeList = ('[ '("xAdvance", GlyphPositionTXAdvanceFieldInfo), '("yAdvance", GlyphPositionTYAdvanceFieldInfo), '("xOffset", GlyphPositionTXOffsetFieldInfo), '("yOffset", GlyphPositionTYOffsetFieldInfo)] :: [(Symbol, DK.Type)])
    #endif

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

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

    #endif

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

    #endif