{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./
-- 
-- /Since: 2.2.0/

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

module GI.HarfBuzz.Structs.OtVarAxisInfoT
    ( 

-- * Exported types
    OtVarAxisInfoT(..)                      ,
    newZeroOtVarAxisInfoT                   ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveOtVarAxisInfoTMethod             ,
#endif




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

    getOtVarAxisInfoTAxisIndex              ,
#if defined(ENABLE_OVERLOADING)
    otVarAxisInfoT_axisIndex                ,
#endif
    setOtVarAxisInfoTAxisIndex              ,


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

    getOtVarAxisInfoTDefaultValue           ,
#if defined(ENABLE_OVERLOADING)
    otVarAxisInfoT_defaultValue             ,
#endif
    setOtVarAxisInfoTDefaultValue           ,


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

    getOtVarAxisInfoTFlags                  ,
#if defined(ENABLE_OVERLOADING)
    otVarAxisInfoT_flags                    ,
#endif
    setOtVarAxisInfoTFlags                  ,


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

    getOtVarAxisInfoTMaxValue               ,
#if defined(ENABLE_OVERLOADING)
    otVarAxisInfoT_maxValue                 ,
#endif
    setOtVarAxisInfoTMaxValue               ,


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

    getOtVarAxisInfoTMinValue               ,
#if defined(ENABLE_OVERLOADING)
    otVarAxisInfoT_minValue                 ,
#endif
    setOtVarAxisInfoTMinValue               ,


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

    getOtVarAxisInfoTNameId                 ,
#if defined(ENABLE_OVERLOADING)
    otVarAxisInfoT_nameId                   ,
#endif
    setOtVarAxisInfoTNameId                 ,


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

    getOtVarAxisInfoTTag                    ,
#if defined(ENABLE_OVERLOADING)
    otVarAxisInfoT_tag                      ,
#endif
    setOtVarAxisInfoTTag                    ,




    ) 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.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 {-# SOURCE #-} qualified GI.HarfBuzz.Flags as HarfBuzz.Flags

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

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

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


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

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


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

#if defined(ENABLE_OVERLOADING)
data OtVarAxisInfoTAxisIndexFieldInfo
instance AttrInfo OtVarAxisInfoTAxisIndexFieldInfo where
    type AttrBaseTypeConstraint OtVarAxisInfoTAxisIndexFieldInfo = (~) OtVarAxisInfoT
    type AttrAllowedOps OtVarAxisInfoTAxisIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint OtVarAxisInfoTAxisIndexFieldInfo = (~) Word32
    type AttrTransferTypeConstraint OtVarAxisInfoTAxisIndexFieldInfo = (~)Word32
    type AttrTransferType OtVarAxisInfoTAxisIndexFieldInfo = Word32
    type AttrGetType OtVarAxisInfoTAxisIndexFieldInfo = Word32
    type AttrLabel OtVarAxisInfoTAxisIndexFieldInfo = "axis_index"
    type AttrOrigin OtVarAxisInfoTAxisIndexFieldInfo = OtVarAxisInfoT
    attrGet = getOtVarAxisInfoTAxisIndex
    attrSet = setOtVarAxisInfoTAxisIndex
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

otVarAxisInfoT_axisIndex :: AttrLabelProxy "axisIndex"
otVarAxisInfoT_axisIndex = AttrLabelProxy

#endif


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

#if defined(ENABLE_OVERLOADING)
data OtVarAxisInfoTTagFieldInfo
instance AttrInfo OtVarAxisInfoTTagFieldInfo where
    type AttrBaseTypeConstraint OtVarAxisInfoTTagFieldInfo = (~) OtVarAxisInfoT
    type AttrAllowedOps OtVarAxisInfoTTagFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint OtVarAxisInfoTTagFieldInfo = (~) Word32
    type AttrTransferTypeConstraint OtVarAxisInfoTTagFieldInfo = (~)Word32
    type AttrTransferType OtVarAxisInfoTTagFieldInfo = Word32
    type AttrGetType OtVarAxisInfoTTagFieldInfo = Word32
    type AttrLabel OtVarAxisInfoTTagFieldInfo = "tag"
    type AttrOrigin OtVarAxisInfoTTagFieldInfo = OtVarAxisInfoT
    attrGet = getOtVarAxisInfoTTag
    attrSet = setOtVarAxisInfoTTag
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

otVarAxisInfoT_tag :: AttrLabelProxy "tag"
otVarAxisInfoT_tag = AttrLabelProxy

#endif


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

#if defined(ENABLE_OVERLOADING)
data OtVarAxisInfoTNameIdFieldInfo
instance AttrInfo OtVarAxisInfoTNameIdFieldInfo where
    type AttrBaseTypeConstraint OtVarAxisInfoTNameIdFieldInfo = (~) OtVarAxisInfoT
    type AttrAllowedOps OtVarAxisInfoTNameIdFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint OtVarAxisInfoTNameIdFieldInfo = (~) Word32
    type AttrTransferTypeConstraint OtVarAxisInfoTNameIdFieldInfo = (~)Word32
    type AttrTransferType OtVarAxisInfoTNameIdFieldInfo = Word32
    type AttrGetType OtVarAxisInfoTNameIdFieldInfo = Word32
    type AttrLabel OtVarAxisInfoTNameIdFieldInfo = "name_id"
    type AttrOrigin OtVarAxisInfoTNameIdFieldInfo = OtVarAxisInfoT
    attrGet = getOtVarAxisInfoTNameId
    attrSet = setOtVarAxisInfoTNameId
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

otVarAxisInfoT_nameId :: AttrLabelProxy "nameId"
otVarAxisInfoT_nameId = AttrLabelProxy

#endif


-- | Get the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' otVarAxisInfoT #flags
-- @
getOtVarAxisInfoTFlags :: MonadIO m => OtVarAxisInfoT -> m [HarfBuzz.Flags.OtVarAxisFlagsT]
getOtVarAxisInfoTFlags :: OtVarAxisInfoT -> m [OtVarAxisFlagsT]
getOtVarAxisInfoTFlags OtVarAxisInfoT
s = IO [OtVarAxisFlagsT] -> m [OtVarAxisFlagsT]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [OtVarAxisFlagsT] -> m [OtVarAxisFlagsT])
-> IO [OtVarAxisFlagsT] -> m [OtVarAxisFlagsT]
forall a b. (a -> b) -> a -> b
$ OtVarAxisInfoT
-> (Ptr OtVarAxisInfoT -> IO [OtVarAxisFlagsT])
-> IO [OtVarAxisFlagsT]
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr OtVarAxisInfoT
s ((Ptr OtVarAxisInfoT -> IO [OtVarAxisFlagsT])
 -> IO [OtVarAxisFlagsT])
-> (Ptr OtVarAxisInfoT -> IO [OtVarAxisFlagsT])
-> IO [OtVarAxisFlagsT]
forall a b. (a -> b) -> a -> b
$ \Ptr OtVarAxisInfoT
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr OtVarAxisInfoT
ptr Ptr OtVarAxisInfoT -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO CUInt
    let val' :: [OtVarAxisFlagsT]
val' = CUInt -> [OtVarAxisFlagsT]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
val
    [OtVarAxisFlagsT] -> IO [OtVarAxisFlagsT]
forall (m :: * -> *) a. Monad m => a -> m a
return [OtVarAxisFlagsT]
val'

-- | Set the value of the “@flags@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' otVarAxisInfoT [ #flags 'Data.GI.Base.Attributes.:=' value ]
-- @
setOtVarAxisInfoTFlags :: MonadIO m => OtVarAxisInfoT -> [HarfBuzz.Flags.OtVarAxisFlagsT] -> m ()
setOtVarAxisInfoTFlags :: OtVarAxisInfoT -> [OtVarAxisFlagsT] -> m ()
setOtVarAxisInfoTFlags OtVarAxisInfoT
s [OtVarAxisFlagsT]
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ OtVarAxisInfoT -> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr OtVarAxisInfoT
s ((Ptr OtVarAxisInfoT -> IO ()) -> IO ())
-> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr OtVarAxisInfoT
ptr -> do
    let val' :: CUInt
val' = [OtVarAxisFlagsT] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [OtVarAxisFlagsT]
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr OtVarAxisInfoT
ptr Ptr OtVarAxisInfoT -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data OtVarAxisInfoTFlagsFieldInfo
instance AttrInfo OtVarAxisInfoTFlagsFieldInfo where
    type AttrBaseTypeConstraint OtVarAxisInfoTFlagsFieldInfo = (~) OtVarAxisInfoT
    type AttrAllowedOps OtVarAxisInfoTFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint OtVarAxisInfoTFlagsFieldInfo = (~) [HarfBuzz.Flags.OtVarAxisFlagsT]
    type AttrTransferTypeConstraint OtVarAxisInfoTFlagsFieldInfo = (~)[HarfBuzz.Flags.OtVarAxisFlagsT]
    type AttrTransferType OtVarAxisInfoTFlagsFieldInfo = [HarfBuzz.Flags.OtVarAxisFlagsT]
    type AttrGetType OtVarAxisInfoTFlagsFieldInfo = [HarfBuzz.Flags.OtVarAxisFlagsT]
    type AttrLabel OtVarAxisInfoTFlagsFieldInfo = "flags"
    type AttrOrigin OtVarAxisInfoTFlagsFieldInfo = OtVarAxisInfoT
    attrGet = getOtVarAxisInfoTFlags
    attrSet = setOtVarAxisInfoTFlags
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

otVarAxisInfoT_flags :: AttrLabelProxy "flags"
otVarAxisInfoT_flags = AttrLabelProxy

#endif


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

-- | Set the value of the “@min_value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' otVarAxisInfoT [ #minValue 'Data.GI.Base.Attributes.:=' value ]
-- @
setOtVarAxisInfoTMinValue :: MonadIO m => OtVarAxisInfoT -> Float -> m ()
setOtVarAxisInfoTMinValue :: OtVarAxisInfoT -> Float -> m ()
setOtVarAxisInfoTMinValue OtVarAxisInfoT
s Float
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ OtVarAxisInfoT -> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr OtVarAxisInfoT
s ((Ptr OtVarAxisInfoT -> IO ()) -> IO ())
-> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr OtVarAxisInfoT
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr OtVarAxisInfoT
ptr Ptr OtVarAxisInfoT -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data OtVarAxisInfoTMinValueFieldInfo
instance AttrInfo OtVarAxisInfoTMinValueFieldInfo where
    type AttrBaseTypeConstraint OtVarAxisInfoTMinValueFieldInfo = (~) OtVarAxisInfoT
    type AttrAllowedOps OtVarAxisInfoTMinValueFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint OtVarAxisInfoTMinValueFieldInfo = (~) Float
    type AttrTransferTypeConstraint OtVarAxisInfoTMinValueFieldInfo = (~)Float
    type AttrTransferType OtVarAxisInfoTMinValueFieldInfo = Float
    type AttrGetType OtVarAxisInfoTMinValueFieldInfo = Float
    type AttrLabel OtVarAxisInfoTMinValueFieldInfo = "min_value"
    type AttrOrigin OtVarAxisInfoTMinValueFieldInfo = OtVarAxisInfoT
    attrGet = getOtVarAxisInfoTMinValue
    attrSet = setOtVarAxisInfoTMinValue
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

otVarAxisInfoT_minValue :: AttrLabelProxy "minValue"
otVarAxisInfoT_minValue = AttrLabelProxy

#endif


-- | Get the value of the “@default_value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' otVarAxisInfoT #defaultValue
-- @
getOtVarAxisInfoTDefaultValue :: MonadIO m => OtVarAxisInfoT -> m Float
getOtVarAxisInfoTDefaultValue :: OtVarAxisInfoT -> m Float
getOtVarAxisInfoTDefaultValue OtVarAxisInfoT
s = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ OtVarAxisInfoT -> (Ptr OtVarAxisInfoT -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr OtVarAxisInfoT
s ((Ptr OtVarAxisInfoT -> IO Float) -> IO Float)
-> (Ptr OtVarAxisInfoT -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr OtVarAxisInfoT
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr OtVarAxisInfoT
ptr Ptr OtVarAxisInfoT -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@default_value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' otVarAxisInfoT [ #defaultValue 'Data.GI.Base.Attributes.:=' value ]
-- @
setOtVarAxisInfoTDefaultValue :: MonadIO m => OtVarAxisInfoT -> Float -> m ()
setOtVarAxisInfoTDefaultValue :: OtVarAxisInfoT -> Float -> m ()
setOtVarAxisInfoTDefaultValue OtVarAxisInfoT
s Float
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ OtVarAxisInfoT -> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr OtVarAxisInfoT
s ((Ptr OtVarAxisInfoT -> IO ()) -> IO ())
-> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr OtVarAxisInfoT
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr OtVarAxisInfoT
ptr Ptr OtVarAxisInfoT -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data OtVarAxisInfoTDefaultValueFieldInfo
instance AttrInfo OtVarAxisInfoTDefaultValueFieldInfo where
    type AttrBaseTypeConstraint OtVarAxisInfoTDefaultValueFieldInfo = (~) OtVarAxisInfoT
    type AttrAllowedOps OtVarAxisInfoTDefaultValueFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint OtVarAxisInfoTDefaultValueFieldInfo = (~) Float
    type AttrTransferTypeConstraint OtVarAxisInfoTDefaultValueFieldInfo = (~)Float
    type AttrTransferType OtVarAxisInfoTDefaultValueFieldInfo = Float
    type AttrGetType OtVarAxisInfoTDefaultValueFieldInfo = Float
    type AttrLabel OtVarAxisInfoTDefaultValueFieldInfo = "default_value"
    type AttrOrigin OtVarAxisInfoTDefaultValueFieldInfo = OtVarAxisInfoT
    attrGet = getOtVarAxisInfoTDefaultValue
    attrSet = setOtVarAxisInfoTDefaultValue
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

otVarAxisInfoT_defaultValue :: AttrLabelProxy "defaultValue"
otVarAxisInfoT_defaultValue = AttrLabelProxy

#endif


-- | Get the value of the “@max_value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' otVarAxisInfoT #maxValue
-- @
getOtVarAxisInfoTMaxValue :: MonadIO m => OtVarAxisInfoT -> m Float
getOtVarAxisInfoTMaxValue :: OtVarAxisInfoT -> m Float
getOtVarAxisInfoTMaxValue OtVarAxisInfoT
s = IO Float -> m Float
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Float -> m Float) -> IO Float -> m Float
forall a b. (a -> b) -> a -> b
$ OtVarAxisInfoT -> (Ptr OtVarAxisInfoT -> IO Float) -> IO Float
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr OtVarAxisInfoT
s ((Ptr OtVarAxisInfoT -> IO Float) -> IO Float)
-> (Ptr OtVarAxisInfoT -> IO Float) -> IO Float
forall a b. (a -> b) -> a -> b
$ \Ptr OtVarAxisInfoT
ptr -> do
    CFloat
val <- Ptr CFloat -> IO CFloat
forall a. Storable a => Ptr a -> IO a
peek (Ptr OtVarAxisInfoT
ptr Ptr OtVarAxisInfoT -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO CFloat
    let val' :: Float
val' = CFloat -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac CFloat
val
    Float -> IO Float
forall (m :: * -> *) a. Monad m => a -> m a
return Float
val'

-- | Set the value of the “@max_value@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' otVarAxisInfoT [ #maxValue 'Data.GI.Base.Attributes.:=' value ]
-- @
setOtVarAxisInfoTMaxValue :: MonadIO m => OtVarAxisInfoT -> Float -> m ()
setOtVarAxisInfoTMaxValue :: OtVarAxisInfoT -> Float -> m ()
setOtVarAxisInfoTMaxValue OtVarAxisInfoT
s Float
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ OtVarAxisInfoT -> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr OtVarAxisInfoT
s ((Ptr OtVarAxisInfoT -> IO ()) -> IO ())
-> (Ptr OtVarAxisInfoT -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr OtVarAxisInfoT
ptr -> do
    let val' :: CFloat
val' = Float -> CFloat
forall a b. (Real a, Fractional b) => a -> b
realToFrac Float
val
    Ptr CFloat -> CFloat -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr OtVarAxisInfoT
ptr Ptr OtVarAxisInfoT -> Int -> Ptr CFloat
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (CFloat
val' :: CFloat)

#if defined(ENABLE_OVERLOADING)
data OtVarAxisInfoTMaxValueFieldInfo
instance AttrInfo OtVarAxisInfoTMaxValueFieldInfo where
    type AttrBaseTypeConstraint OtVarAxisInfoTMaxValueFieldInfo = (~) OtVarAxisInfoT
    type AttrAllowedOps OtVarAxisInfoTMaxValueFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint OtVarAxisInfoTMaxValueFieldInfo = (~) Float
    type AttrTransferTypeConstraint OtVarAxisInfoTMaxValueFieldInfo = (~)Float
    type AttrTransferType OtVarAxisInfoTMaxValueFieldInfo = Float
    type AttrGetType OtVarAxisInfoTMaxValueFieldInfo = Float
    type AttrLabel OtVarAxisInfoTMaxValueFieldInfo = "max_value"
    type AttrOrigin OtVarAxisInfoTMaxValueFieldInfo = OtVarAxisInfoT
    attrGet = getOtVarAxisInfoTMaxValue
    attrSet = setOtVarAxisInfoTMaxValue
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v

otVarAxisInfoT_maxValue :: AttrLabelProxy "maxValue"
otVarAxisInfoT_maxValue = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList OtVarAxisInfoT
type instance O.AttributeList OtVarAxisInfoT = OtVarAxisInfoTAttributeList
type OtVarAxisInfoTAttributeList = ('[ '("axisIndex", OtVarAxisInfoTAxisIndexFieldInfo), '("tag", OtVarAxisInfoTTagFieldInfo), '("nameId", OtVarAxisInfoTNameIdFieldInfo), '("flags", OtVarAxisInfoTFlagsFieldInfo), '("minValue", OtVarAxisInfoTMinValueFieldInfo), '("defaultValue", OtVarAxisInfoTDefaultValueFieldInfo), '("maxValue", OtVarAxisInfoTMaxValueFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveOtVarAxisInfoTMethod (t :: Symbol) (o :: *) :: * where
    ResolveOtVarAxisInfoTMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveOtVarAxisInfoTMethod t OtVarAxisInfoT, O.MethodInfo info OtVarAxisInfoT p) => OL.IsLabel t (OtVarAxisInfoT -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif