{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The structure that holds various text properties of an t'GI.HarfBuzz.Structs.BufferT.BufferT'. Can be
-- set and retrieved using 'GI.HarfBuzz.Functions.bufferSetSegmentProperties' and
-- 'GI.HarfBuzz.Functions.bufferGetSegmentProperties', respectively.

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

module GI.HarfBuzz.Structs.SegmentPropertiesT
    ( 

-- * Exported types
    SegmentPropertiesT(..)                  ,
    newZeroSegmentPropertiesT               ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveSegmentPropertiesTMethod         ,
#endif



 -- * Properties


-- ** direction #attr:direction#
-- | the t'GI.HarfBuzz.Enums.DirectionT' of the buffer, see 'GI.HarfBuzz.Functions.bufferSetDirection'.

    getSegmentPropertiesTDirection          ,
#if defined(ENABLE_OVERLOADING)
    segmentPropertiesT_direction            ,
#endif
    setSegmentPropertiesTDirection          ,


-- ** language #attr:language#
-- | the t'GI.HarfBuzz.Structs.LanguageT.LanguageT' of the buffer, see 'GI.HarfBuzz.Functions.bufferSetLanguage'.

    getSegmentPropertiesTLanguage           ,
#if defined(ENABLE_OVERLOADING)
    segmentPropertiesT_language             ,
#endif


-- ** script #attr:script#
-- | the t'GI.HarfBuzz.Enums.ScriptT' of the buffer, see 'GI.HarfBuzz.Functions.bufferSetScript'.

    getSegmentPropertiesTScript             ,
#if defined(ENABLE_OVERLOADING)
    segmentPropertiesT_script               ,
#endif
    setSegmentPropertiesTScript             ,




    ) 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

import {-# SOURCE #-} qualified GI.HarfBuzz.Enums as HarfBuzz.Enums
import {-# SOURCE #-} qualified GI.HarfBuzz.Structs.LanguageT as HarfBuzz.LanguageT

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

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

foreign import ccall "hb_gobject_segment_properties_get_type" c_hb_gobject_segment_properties_get_type :: 
    IO GType

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

instance B.Types.TypedObject SegmentPropertiesT where
    glibType :: IO GType
glibType = IO GType
c_hb_gobject_segment_properties_get_type

instance B.Types.GBoxed SegmentPropertiesT

-- | Convert 'SegmentPropertiesT' 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 SegmentPropertiesT) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_hb_gobject_segment_properties_get_type
    gvalueSet_ :: Ptr GValue -> Maybe SegmentPropertiesT -> IO ()
gvalueSet_ Ptr GValue
gv Maybe SegmentPropertiesT
P.Nothing = Ptr GValue -> Ptr SegmentPropertiesT -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr SegmentPropertiesT
forall a. Ptr a
FP.nullPtr :: FP.Ptr SegmentPropertiesT)
    gvalueSet_ Ptr GValue
gv (P.Just SegmentPropertiesT
obj) = SegmentPropertiesT -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SegmentPropertiesT
obj (Ptr GValue -> Ptr SegmentPropertiesT -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe SegmentPropertiesT)
gvalueGet_ Ptr GValue
gv = do
        Ptr SegmentPropertiesT
ptr <- Ptr GValue -> IO (Ptr SegmentPropertiesT)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr SegmentPropertiesT)
        if Ptr SegmentPropertiesT
ptr Ptr SegmentPropertiesT -> Ptr SegmentPropertiesT -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr SegmentPropertiesT
forall a. Ptr a
FP.nullPtr
        then SegmentPropertiesT -> Maybe SegmentPropertiesT
forall a. a -> Maybe a
P.Just (SegmentPropertiesT -> Maybe SegmentPropertiesT)
-> IO SegmentPropertiesT -> IO (Maybe SegmentPropertiesT)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr SegmentPropertiesT -> SegmentPropertiesT)
-> Ptr SegmentPropertiesT -> IO SegmentPropertiesT
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr SegmentPropertiesT -> SegmentPropertiesT
SegmentPropertiesT Ptr SegmentPropertiesT
ptr
        else Maybe SegmentPropertiesT -> IO (Maybe SegmentPropertiesT)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SegmentPropertiesT
forall a. Maybe a
P.Nothing
        
    

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

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


-- | Get the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' segmentPropertiesT #direction
-- @
getSegmentPropertiesTDirection :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.Enums.DirectionT
getSegmentPropertiesTDirection :: forall (m :: * -> *).
MonadIO m =>
SegmentPropertiesT -> m DirectionT
getSegmentPropertiesTDirection SegmentPropertiesT
s = IO DirectionT -> m DirectionT
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DirectionT -> m DirectionT) -> IO DirectionT -> m DirectionT
forall a b. (a -> b) -> a -> b
$ SegmentPropertiesT
-> (Ptr SegmentPropertiesT -> IO DirectionT) -> IO DirectionT
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SegmentPropertiesT
s ((Ptr SegmentPropertiesT -> IO DirectionT) -> IO DirectionT)
-> (Ptr SegmentPropertiesT -> IO DirectionT) -> IO DirectionT
forall a b. (a -> b) -> a -> b
$ \Ptr SegmentPropertiesT
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr SegmentPropertiesT
ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CUInt
    let val' :: DirectionT
val' = (Int -> DirectionT
forall a. Enum a => Int -> a
toEnum (Int -> DirectionT) -> (CUInt -> Int) -> CUInt -> DirectionT
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    DirectionT -> IO DirectionT
forall (m :: * -> *) a. Monad m => a -> m a
return DirectionT
val'

-- | Set the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' segmentPropertiesT [ #direction 'Data.GI.Base.Attributes.:=' value ]
-- @
setSegmentPropertiesTDirection :: MonadIO m => SegmentPropertiesT -> HarfBuzz.Enums.DirectionT -> m ()
setSegmentPropertiesTDirection :: forall (m :: * -> *).
MonadIO m =>
SegmentPropertiesT -> DirectionT -> m ()
setSegmentPropertiesTDirection SegmentPropertiesT
s DirectionT
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SegmentPropertiesT -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SegmentPropertiesT
s ((Ptr SegmentPropertiesT -> IO ()) -> IO ())
-> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SegmentPropertiesT
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (DirectionT -> Int) -> DirectionT -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DirectionT -> Int
forall a. Enum a => a -> Int
fromEnum) DirectionT
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SegmentPropertiesT
ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CUInt
val' :: CUInt)

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

segmentPropertiesT_direction :: AttrLabelProxy "direction"
segmentPropertiesT_direction = AttrLabelProxy

#endif


-- | Get the value of the “@script@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' segmentPropertiesT #script
-- @
getSegmentPropertiesTScript :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.Enums.ScriptT
getSegmentPropertiesTScript :: forall (m :: * -> *). MonadIO m => SegmentPropertiesT -> m ScriptT
getSegmentPropertiesTScript SegmentPropertiesT
s = IO ScriptT -> m ScriptT
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScriptT -> m ScriptT) -> IO ScriptT -> m ScriptT
forall a b. (a -> b) -> a -> b
$ SegmentPropertiesT
-> (Ptr SegmentPropertiesT -> IO ScriptT) -> IO ScriptT
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SegmentPropertiesT
s ((Ptr SegmentPropertiesT -> IO ScriptT) -> IO ScriptT)
-> (Ptr SegmentPropertiesT -> IO ScriptT) -> IO ScriptT
forall a b. (a -> b) -> a -> b
$ \Ptr SegmentPropertiesT
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr SegmentPropertiesT
ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CUInt
    let val' :: ScriptT
val' = (Int -> ScriptT
forall a. Enum a => Int -> a
toEnum (Int -> ScriptT) -> (CUInt -> Int) -> CUInt -> ScriptT
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    ScriptT -> IO ScriptT
forall (m :: * -> *) a. Monad m => a -> m a
return ScriptT
val'

-- | Set the value of the “@script@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' segmentPropertiesT [ #script 'Data.GI.Base.Attributes.:=' value ]
-- @
setSegmentPropertiesTScript :: MonadIO m => SegmentPropertiesT -> HarfBuzz.Enums.ScriptT -> m ()
setSegmentPropertiesTScript :: forall (m :: * -> *).
MonadIO m =>
SegmentPropertiesT -> ScriptT -> m ()
setSegmentPropertiesTScript SegmentPropertiesT
s ScriptT
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ SegmentPropertiesT -> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SegmentPropertiesT
s ((Ptr SegmentPropertiesT -> IO ()) -> IO ())
-> (Ptr SegmentPropertiesT -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr SegmentPropertiesT
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (ScriptT -> Int) -> ScriptT -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ScriptT -> Int
forall a. Enum a => a -> Int
fromEnum) ScriptT
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr SegmentPropertiesT
ptr Ptr SegmentPropertiesT -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CUInt
val' :: CUInt)

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

segmentPropertiesT_script :: AttrLabelProxy "script"
segmentPropertiesT_script = AttrLabelProxy

#endif


-- | Get the value of the “@language@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' segmentPropertiesT #language
-- @
getSegmentPropertiesTLanguage :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.LanguageT.LanguageT
getSegmentPropertiesTLanguage :: forall (m :: * -> *).
MonadIO m =>
SegmentPropertiesT -> m LanguageT
getSegmentPropertiesTLanguage SegmentPropertiesT
s = IO LanguageT -> m LanguageT
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO LanguageT -> m LanguageT) -> IO LanguageT -> m LanguageT
forall a b. (a -> b) -> a -> b
$ SegmentPropertiesT
-> (Ptr SegmentPropertiesT -> IO LanguageT) -> IO LanguageT
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr SegmentPropertiesT
s ((Ptr SegmentPropertiesT -> IO LanguageT) -> IO LanguageT)
-> (Ptr SegmentPropertiesT -> IO LanguageT) -> IO LanguageT
forall a b. (a -> b) -> a -> b
$ \Ptr SegmentPropertiesT
ptr -> do
    let val :: Ptr LanguageT
val = Ptr SegmentPropertiesT
ptr Ptr SegmentPropertiesT -> Int -> Ptr LanguageT
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8 :: (Ptr HarfBuzz.LanguageT.LanguageT)
    LanguageT
val' <- ((ManagedPtr LanguageT -> LanguageT)
-> Ptr LanguageT -> IO LanguageT
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr LanguageT -> LanguageT
HarfBuzz.LanguageT.LanguageT) Ptr LanguageT
val
    LanguageT -> IO LanguageT
forall (m :: * -> *) a. Monad m => a -> m a
return LanguageT
val'

#if defined(ENABLE_OVERLOADING)
data SegmentPropertiesTLanguageFieldInfo
instance AttrInfo SegmentPropertiesTLanguageFieldInfo where
    type AttrBaseTypeConstraint SegmentPropertiesTLanguageFieldInfo = (~) SegmentPropertiesT
    type AttrAllowedOps SegmentPropertiesTLanguageFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint SegmentPropertiesTLanguageFieldInfo = (~) (Ptr HarfBuzz.LanguageT.LanguageT)
    type AttrTransferTypeConstraint SegmentPropertiesTLanguageFieldInfo = (~)(Ptr HarfBuzz.LanguageT.LanguageT)
    type AttrTransferType SegmentPropertiesTLanguageFieldInfo = (Ptr HarfBuzz.LanguageT.LanguageT)
    type AttrGetType SegmentPropertiesTLanguageFieldInfo = HarfBuzz.LanguageT.LanguageT
    type AttrLabel SegmentPropertiesTLanguageFieldInfo = "language"
    type AttrOrigin SegmentPropertiesTLanguageFieldInfo = SegmentPropertiesT
    attrGet = getSegmentPropertiesTLanguage
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.HarfBuzz.Structs.SegmentPropertiesT.language"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-harfbuzz-0.0.5/docs/GI-HarfBuzz-Structs-SegmentPropertiesT.html#g:attr:language"
        })

segmentPropertiesT_language :: AttrLabelProxy "language"
segmentPropertiesT_language = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList SegmentPropertiesT
type instance O.AttributeList SegmentPropertiesT = SegmentPropertiesTAttributeList
type SegmentPropertiesTAttributeList = ('[ '("direction", SegmentPropertiesTDirectionFieldInfo), '("script", SegmentPropertiesTScriptFieldInfo), '("language", SegmentPropertiesTLanguageFieldInfo)] :: [(Symbol, *)])
#endif

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

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

#endif

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

#endif