{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.HarfBuzz.Structs.SegmentPropertiesT
(
SegmentPropertiesT(..) ,
newZeroSegmentPropertiesT ,
#if defined(ENABLE_OVERLOADING)
ResolveSegmentPropertiesTMethod ,
#endif
getSegmentPropertiesTDirection ,
#if defined(ENABLE_OVERLOADING)
segmentPropertiesT_direction ,
#endif
setSegmentPropertiesTDirection ,
getSegmentPropertiesTLanguage ,
#if defined(ENABLE_OVERLOADING)
segmentPropertiesT_language ,
#endif
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.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.Enums as HarfBuzz.Enums
import {-# SOURCE #-} qualified GI.HarfBuzz.Structs.LanguageT as HarfBuzz.LanguageT
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
instance B.GValue.IsGValue SegmentPropertiesT where
toGValue :: SegmentPropertiesT -> IO GValue
toGValue SegmentPropertiesT
o = do
GType
gtype <- IO GType
c_hb_gobject_segment_properties_get_type
SegmentPropertiesT
-> (Ptr SegmentPropertiesT -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SegmentPropertiesT
o (GType
-> (GValue -> Ptr SegmentPropertiesT -> IO ())
-> Ptr SegmentPropertiesT
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr SegmentPropertiesT -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO SegmentPropertiesT
fromGValue GValue
gv = do
Ptr SegmentPropertiesT
ptr <- GValue -> IO (Ptr SegmentPropertiesT)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr SegmentPropertiesT)
(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
newZeroSegmentPropertiesT :: MonadIO m => m SegmentPropertiesT
newZeroSegmentPropertiesT :: 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 :: (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
getSegmentPropertiesTDirection :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.Enums.DirectionT
getSegmentPropertiesTDirection :: 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'
setSegmentPropertiesTDirection :: MonadIO m => SegmentPropertiesT -> HarfBuzz.Enums.DirectionT -> m ()
setSegmentPropertiesTDirection :: 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
segmentPropertiesT_direction :: AttrLabelProxy "direction"
segmentPropertiesT_direction = AttrLabelProxy
#endif
getSegmentPropertiesTScript :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.Enums.ScriptT
getSegmentPropertiesTScript :: 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'
setSegmentPropertiesTScript :: MonadIO m => SegmentPropertiesT -> HarfBuzz.Enums.ScriptT -> m ()
setSegmentPropertiesTScript :: 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
segmentPropertiesT_script :: AttrLabelProxy "script"
segmentPropertiesT_script = AttrLabelProxy
#endif
getSegmentPropertiesTLanguage :: MonadIO m => SegmentPropertiesT -> m HarfBuzz.LanguageT.LanguageT
getSegmentPropertiesTLanguage :: 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
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.MethodInfo 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
#endif