{-# 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 (MIN_VERSION_haskell_gi_overloading(1,0,0) && !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.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 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.7/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.7/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.7/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.7/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, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveGlyphPositionTMethod (t :: Symbol) (o :: *) :: * 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