{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Pango.Structs.Analysis
(
Analysis(..) ,
newZeroAnalysis ,
#if defined(ENABLE_OVERLOADING)
ResolveAnalysisMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
analysis_extraAttrs ,
#endif
clearAnalysisExtraAttrs ,
getAnalysisExtraAttrs ,
setAnalysisExtraAttrs ,
#if defined(ENABLE_OVERLOADING)
analysis_flags ,
#endif
getAnalysisFlags ,
setAnalysisFlags ,
#if defined(ENABLE_OVERLOADING)
analysis_font ,
#endif
clearAnalysisFont ,
getAnalysisFont ,
setAnalysisFont ,
#if defined(ENABLE_OVERLOADING)
analysis_gravity ,
#endif
getAnalysisGravity ,
setAnalysisGravity ,
#if defined(ENABLE_OVERLOADING)
analysis_langEngine ,
#endif
clearAnalysisLangEngine ,
getAnalysisLangEngine ,
setAnalysisLangEngine ,
#if defined(ENABLE_OVERLOADING)
analysis_language ,
#endif
clearAnalysisLanguage ,
getAnalysisLanguage ,
setAnalysisLanguage ,
#if defined(ENABLE_OVERLOADING)
analysis_level ,
#endif
getAnalysisLevel ,
setAnalysisLevel ,
#if defined(ENABLE_OVERLOADING)
analysis_script ,
#endif
getAnalysisScript ,
setAnalysisScript ,
#if defined(ENABLE_OVERLOADING)
analysis_shapeEngine ,
#endif
clearAnalysisShapeEngine ,
getAnalysisShapeEngine ,
setAnalysisShapeEngine ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Pango.Objects.Font as Pango.Font
import {-# SOURCE #-} qualified GI.Pango.Structs.Language as Pango.Language
newtype Analysis = Analysis (SP.ManagedPtr Analysis)
deriving (Analysis -> Analysis -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Analysis -> Analysis -> Bool
$c/= :: Analysis -> Analysis -> Bool
== :: Analysis -> Analysis -> Bool
$c== :: Analysis -> Analysis -> Bool
Eq)
instance SP.ManagedPtrNewtype Analysis where
toManagedPtr :: Analysis -> ManagedPtr Analysis
toManagedPtr (Analysis ManagedPtr Analysis
p) = ManagedPtr Analysis
p
instance BoxedPtr Analysis where
boxedPtrCopy :: Analysis -> IO Analysis
boxedPtrCopy = \Analysis
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Analysis
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
24 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr Analysis -> Analysis
Analysis)
boxedPtrFree :: Analysis -> IO ()
boxedPtrFree = \Analysis
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr Analysis
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr Analysis where
boxedPtrCalloc :: IO (Ptr Analysis)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
24
newZeroAnalysis :: MonadIO m => m Analysis
newZeroAnalysis :: forall (m :: * -> *). MonadIO m => m Analysis
newZeroAnalysis = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Analysis -> Analysis
Analysis
instance tag ~ 'AttrSet => Constructible Analysis tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr Analysis -> Analysis)
-> [AttrOp Analysis tag] -> m Analysis
new ManagedPtr Analysis -> Analysis
_ [AttrOp Analysis tag]
attrs = do
Analysis
o <- forall (m :: * -> *). MonadIO m => m Analysis
newZeroAnalysis
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set Analysis
o [AttrOp Analysis tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return Analysis
o
getAnalysisShapeEngine :: MonadIO m => Analysis -> m (Ptr ())
getAnalysisShapeEngine :: forall (m :: * -> *). MonadIO m => Analysis -> m (Ptr ())
getAnalysisShapeEngine Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setAnalysisShapeEngine :: MonadIO m => Analysis -> Ptr () -> m ()
setAnalysisShapeEngine :: forall (m :: * -> *). MonadIO m => Analysis -> Ptr () -> m ()
setAnalysisShapeEngine Analysis
s Ptr ()
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr ()
val :: Ptr ())
clearAnalysisShapeEngine :: MonadIO m => Analysis -> m ()
clearAnalysisShapeEngine :: forall (m :: * -> *). MonadIO m => Analysis -> m ()
clearAnalysisShapeEngine Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data AnalysisShapeEngineFieldInfo
instance AttrInfo AnalysisShapeEngineFieldInfo where
type AttrBaseTypeConstraint AnalysisShapeEngineFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisShapeEngineFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AnalysisShapeEngineFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint AnalysisShapeEngineFieldInfo = (~)(Ptr ())
type AttrTransferType AnalysisShapeEngineFieldInfo = (Ptr ())
type AttrGetType AnalysisShapeEngineFieldInfo = Ptr ()
type AttrLabel AnalysisShapeEngineFieldInfo = "shape_engine"
type AttrOrigin AnalysisShapeEngineFieldInfo = Analysis
attrGet = getAnalysisShapeEngine
attrSet = setAnalysisShapeEngine
attrConstruct = undefined
attrClear = clearAnalysisShapeEngine
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.shapeEngine"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:shapeEngine"
})
analysis_shapeEngine :: AttrLabelProxy "shapeEngine"
analysis_shapeEngine = AttrLabelProxy
#endif
getAnalysisLangEngine :: MonadIO m => Analysis -> m (Ptr ())
getAnalysisLangEngine :: forall (m :: * -> *). MonadIO m => Analysis -> m (Ptr ())
getAnalysisLangEngine Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setAnalysisLangEngine :: MonadIO m => Analysis -> Ptr () -> m ()
setAnalysisLangEngine :: forall (m :: * -> *). MonadIO m => Analysis -> Ptr () -> m ()
setAnalysisLangEngine Analysis
s Ptr ()
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Ptr ()
val :: Ptr ())
clearAnalysisLangEngine :: MonadIO m => Analysis -> m ()
clearAnalysisLangEngine :: forall (m :: * -> *). MonadIO m => Analysis -> m ()
clearAnalysisLangEngine Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data AnalysisLangEngineFieldInfo
instance AttrInfo AnalysisLangEngineFieldInfo where
type AttrBaseTypeConstraint AnalysisLangEngineFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisLangEngineFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AnalysisLangEngineFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint AnalysisLangEngineFieldInfo = (~)(Ptr ())
type AttrTransferType AnalysisLangEngineFieldInfo = (Ptr ())
type AttrGetType AnalysisLangEngineFieldInfo = Ptr ()
type AttrLabel AnalysisLangEngineFieldInfo = "lang_engine"
type AttrOrigin AnalysisLangEngineFieldInfo = Analysis
attrGet = getAnalysisLangEngine
attrSet = setAnalysisLangEngine
attrConstruct = undefined
attrClear = clearAnalysisLangEngine
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.langEngine"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:langEngine"
})
analysis_langEngine :: AttrLabelProxy "langEngine"
analysis_langEngine = AttrLabelProxy
#endif
getAnalysisFont :: MonadIO m => Analysis -> m (Maybe Pango.Font.Font)
getAnalysisFont :: forall (m :: * -> *). MonadIO m => Analysis -> m (Maybe Font)
getAnalysisFont Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Ptr Font
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr Pango.Font.Font)
Maybe Font
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Font
val forall a b. (a -> b) -> a -> b
$ \Ptr Font
val' -> do
Font
val'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Font -> Font
Pango.Font.Font) Ptr Font
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Font
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Font
result
setAnalysisFont :: MonadIO m => Analysis -> Ptr Pango.Font.Font -> m ()
setAnalysisFont :: forall (m :: * -> *). MonadIO m => Analysis -> Ptr Font -> m ()
setAnalysisFont Analysis
s Ptr Font
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr Font
val :: Ptr Pango.Font.Font)
clearAnalysisFont :: MonadIO m => Analysis -> m ()
clearAnalysisFont :: forall (m :: * -> *). MonadIO m => Analysis -> m ()
clearAnalysisFont Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: Ptr Pango.Font.Font)
#if defined(ENABLE_OVERLOADING)
data AnalysisFontFieldInfo
instance AttrInfo AnalysisFontFieldInfo where
type AttrBaseTypeConstraint AnalysisFontFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisFontFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AnalysisFontFieldInfo = (~) (Ptr Pango.Font.Font)
type AttrTransferTypeConstraint AnalysisFontFieldInfo = (~)(Ptr Pango.Font.Font)
type AttrTransferType AnalysisFontFieldInfo = (Ptr Pango.Font.Font)
type AttrGetType AnalysisFontFieldInfo = Maybe Pango.Font.Font
type AttrLabel AnalysisFontFieldInfo = "font"
type AttrOrigin AnalysisFontFieldInfo = Analysis
attrGet = getAnalysisFont
attrSet = setAnalysisFont
attrConstruct = undefined
attrClear = clearAnalysisFont
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.font"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:font"
})
analysis_font :: AttrLabelProxy "font"
analysis_font = AttrLabelProxy
#endif
getAnalysisLevel :: MonadIO m => Analysis -> m Word8
getAnalysisLevel :: forall (m :: * -> *). MonadIO m => Analysis -> m Word8
getAnalysisLevel Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Word8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
val
setAnalysisLevel :: MonadIO m => Analysis -> Word8 -> m ()
setAnalysisLevel :: forall (m :: * -> *). MonadIO m => Analysis -> Word8 -> m ()
setAnalysisLevel Analysis
s Word8
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word8
val :: Word8)
#if defined(ENABLE_OVERLOADING)
data AnalysisLevelFieldInfo
instance AttrInfo AnalysisLevelFieldInfo where
type AttrBaseTypeConstraint AnalysisLevelFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisLevelFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AnalysisLevelFieldInfo = (~) Word8
type AttrTransferTypeConstraint AnalysisLevelFieldInfo = (~)Word8
type AttrTransferType AnalysisLevelFieldInfo = Word8
type AttrGetType AnalysisLevelFieldInfo = Word8
type AttrLabel AnalysisLevelFieldInfo = "level"
type AttrOrigin AnalysisLevelFieldInfo = Analysis
attrGet = getAnalysisLevel
attrSet = setAnalysisLevel
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.level"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:level"
})
analysis_level :: AttrLabelProxy "level"
analysis_level = AttrLabelProxy
#endif
getAnalysisGravity :: MonadIO m => Analysis -> m Word8
getAnalysisGravity :: forall (m :: * -> *). MonadIO m => Analysis -> m Word8
getAnalysisGravity Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Word8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
13) :: IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
val
setAnalysisGravity :: MonadIO m => Analysis -> Word8 -> m ()
setAnalysisGravity :: forall (m :: * -> *). MonadIO m => Analysis -> Word8 -> m ()
setAnalysisGravity Analysis
s Word8
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
13) (Word8
val :: Word8)
#if defined(ENABLE_OVERLOADING)
data AnalysisGravityFieldInfo
instance AttrInfo AnalysisGravityFieldInfo where
type AttrBaseTypeConstraint AnalysisGravityFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisGravityFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AnalysisGravityFieldInfo = (~) Word8
type AttrTransferTypeConstraint AnalysisGravityFieldInfo = (~)Word8
type AttrTransferType AnalysisGravityFieldInfo = Word8
type AttrGetType AnalysisGravityFieldInfo = Word8
type AttrLabel AnalysisGravityFieldInfo = "gravity"
type AttrOrigin AnalysisGravityFieldInfo = Analysis
attrGet = getAnalysisGravity
attrSet = setAnalysisGravity
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.gravity"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:gravity"
})
analysis_gravity :: AttrLabelProxy "gravity"
analysis_gravity = AttrLabelProxy
#endif
getAnalysisFlags :: MonadIO m => Analysis -> m Word8
getAnalysisFlags :: forall (m :: * -> *). MonadIO m => Analysis -> m Word8
getAnalysisFlags Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Word8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
14) :: IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
val
setAnalysisFlags :: MonadIO m => Analysis -> Word8 -> m ()
setAnalysisFlags :: forall (m :: * -> *). MonadIO m => Analysis -> Word8 -> m ()
setAnalysisFlags Analysis
s Word8
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
14) (Word8
val :: Word8)
#if defined(ENABLE_OVERLOADING)
data AnalysisFlagsFieldInfo
instance AttrInfo AnalysisFlagsFieldInfo where
type AttrBaseTypeConstraint AnalysisFlagsFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisFlagsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AnalysisFlagsFieldInfo = (~) Word8
type AttrTransferTypeConstraint AnalysisFlagsFieldInfo = (~)Word8
type AttrTransferType AnalysisFlagsFieldInfo = Word8
type AttrGetType AnalysisFlagsFieldInfo = Word8
type AttrLabel AnalysisFlagsFieldInfo = "flags"
type AttrOrigin AnalysisFlagsFieldInfo = Analysis
attrGet = getAnalysisFlags
attrSet = setAnalysisFlags
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.flags"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:flags"
})
analysis_flags :: AttrLabelProxy "flags"
analysis_flags = AttrLabelProxy
#endif
getAnalysisScript :: MonadIO m => Analysis -> m Word8
getAnalysisScript :: forall (m :: * -> *). MonadIO m => Analysis -> m Word8
getAnalysisScript Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Word8
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
15) :: IO Word8
forall (m :: * -> *) a. Monad m => a -> m a
return Word8
val
setAnalysisScript :: MonadIO m => Analysis -> Word8 -> m ()
setAnalysisScript :: forall (m :: * -> *). MonadIO m => Analysis -> Word8 -> m ()
setAnalysisScript Analysis
s Word8
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
15) (Word8
val :: Word8)
#if defined(ENABLE_OVERLOADING)
data AnalysisScriptFieldInfo
instance AttrInfo AnalysisScriptFieldInfo where
type AttrBaseTypeConstraint AnalysisScriptFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisScriptFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint AnalysisScriptFieldInfo = (~) Word8
type AttrTransferTypeConstraint AnalysisScriptFieldInfo = (~)Word8
type AttrTransferType AnalysisScriptFieldInfo = Word8
type AttrGetType AnalysisScriptFieldInfo = Word8
type AttrLabel AnalysisScriptFieldInfo = "script"
type AttrOrigin AnalysisScriptFieldInfo = Analysis
attrGet = getAnalysisScript
attrSet = setAnalysisScript
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.script"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:script"
})
analysis_script :: AttrLabelProxy "script"
analysis_script = AttrLabelProxy
#endif
getAnalysisLanguage :: MonadIO m => Analysis -> m (Maybe Pango.Language.Language)
getAnalysisLanguage :: forall (m :: * -> *). MonadIO m => Analysis -> m (Maybe Language)
getAnalysisLanguage Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Ptr Language
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr Pango.Language.Language)
Maybe Language
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Language
val forall a b. (a -> b) -> a -> b
$ \Ptr Language
val' -> do
Language
val'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Language -> Language
Pango.Language.Language) Ptr Language
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Language
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Language
result
setAnalysisLanguage :: MonadIO m => Analysis -> Ptr Pango.Language.Language -> m ()
setAnalysisLanguage :: forall (m :: * -> *). MonadIO m => Analysis -> Ptr Language -> m ()
setAnalysisLanguage Analysis
s Ptr Language
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr Language
val :: Ptr Pango.Language.Language)
clearAnalysisLanguage :: MonadIO m => Analysis -> m ()
clearAnalysisLanguage :: forall (m :: * -> *). MonadIO m => Analysis -> m ()
clearAnalysisLanguage Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: Ptr Pango.Language.Language)
#if defined(ENABLE_OVERLOADING)
data AnalysisLanguageFieldInfo
instance AttrInfo AnalysisLanguageFieldInfo where
type AttrBaseTypeConstraint AnalysisLanguageFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisLanguageFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AnalysisLanguageFieldInfo = (~) (Ptr Pango.Language.Language)
type AttrTransferTypeConstraint AnalysisLanguageFieldInfo = (~)(Ptr Pango.Language.Language)
type AttrTransferType AnalysisLanguageFieldInfo = (Ptr Pango.Language.Language)
type AttrGetType AnalysisLanguageFieldInfo = Maybe Pango.Language.Language
type AttrLabel AnalysisLanguageFieldInfo = "language"
type AttrOrigin AnalysisLanguageFieldInfo = Analysis
attrGet = getAnalysisLanguage
attrSet = setAnalysisLanguage
attrConstruct = undefined
attrClear = clearAnalysisLanguage
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.language"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:language"
})
analysis_language :: AttrLabelProxy "language"
analysis_language = AttrLabelProxy
#endif
getAnalysisExtraAttrs :: MonadIO m => Analysis -> m ([Ptr ()])
Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
Ptr (GSList (Ptr ()))
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO (Ptr (GSList (Ptr ())))
[Ptr ()]
val' <- forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr ()))
val
forall (m :: * -> *) a. Monad m => a -> m a
return [Ptr ()]
val'
setAnalysisExtraAttrs :: MonadIO m => Analysis -> Ptr (GSList (Ptr ())) -> m ()
Analysis
s Ptr (GSList (Ptr ()))
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Ptr (GSList (Ptr ()))
val :: Ptr (GSList (Ptr ())))
clearAnalysisExtraAttrs :: MonadIO m => Analysis -> m ()
Analysis
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr Analysis
s forall a b. (a -> b) -> a -> b
$ \Ptr Analysis
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr Analysis
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (forall a. Ptr a
FP.nullPtr :: Ptr (GSList (Ptr ())))
#if defined(ENABLE_OVERLOADING)
data AnalysisExtraAttrsFieldInfo
instance AttrInfo AnalysisExtraAttrsFieldInfo where
type AttrBaseTypeConstraint AnalysisExtraAttrsFieldInfo = (~) Analysis
type AttrAllowedOps AnalysisExtraAttrsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint AnalysisExtraAttrsFieldInfo = (~) (Ptr (GSList (Ptr ())))
type AttrTransferTypeConstraint AnalysisExtraAttrsFieldInfo = (~)(Ptr (GSList (Ptr ())))
type AttrTransferType AnalysisExtraAttrsFieldInfo = (Ptr (GSList (Ptr ())))
type AttrGetType AnalysisExtraAttrsFieldInfo = [Ptr ()]
type AttrLabel AnalysisExtraAttrsFieldInfo = "extra_attrs"
type AttrOrigin AnalysisExtraAttrsFieldInfo = Analysis
attrGet = getAnalysisExtraAttrs
attrSet = setAnalysisExtraAttrs
attrConstruct = undefined
attrClear = clearAnalysisExtraAttrs
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.Analysis.extraAttrs"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-Analysis.html#g:attr:extraAttrs"
})
analysis_extraAttrs :: AttrLabelProxy "extraAttrs"
analysis_extraAttrs = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Analysis
type instance O.AttributeList Analysis = AnalysisAttributeList
type AnalysisAttributeList = ('[ '("shapeEngine", AnalysisShapeEngineFieldInfo), '("langEngine", AnalysisLangEngineFieldInfo), '("font", AnalysisFontFieldInfo), '("level", AnalysisLevelFieldInfo), '("gravity", AnalysisGravityFieldInfo), '("flags", AnalysisFlagsFieldInfo), '("script", AnalysisScriptFieldInfo), '("language", AnalysisLanguageFieldInfo), '("extraAttrs", AnalysisExtraAttrsFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveAnalysisMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveAnalysisMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveAnalysisMethod t Analysis, O.OverloadedMethod info Analysis p) => OL.IsLabel t (Analysis -> 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 ~ ResolveAnalysisMethod t Analysis, O.OverloadedMethod info Analysis p, R.HasField t Analysis p) => R.HasField t Analysis p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveAnalysisMethod t Analysis, O.OverloadedMethodInfo info Analysis) => OL.IsLabel t (O.MethodProxy info Analysis) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif