{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Pango.Structs.LayoutLine
(
LayoutLine(..) ,
newZeroLayoutLine ,
#if defined(ENABLE_OVERLOADING)
ResolveLayoutLineMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
LayoutLineGetExtentsMethodInfo ,
#endif
layoutLineGetExtents ,
#if defined(ENABLE_OVERLOADING)
LayoutLineGetHeightMethodInfo ,
#endif
layoutLineGetHeight ,
#if defined(ENABLE_OVERLOADING)
LayoutLineGetLengthMethodInfo ,
#endif
layoutLineGetLength ,
#if defined(ENABLE_OVERLOADING)
LayoutLineGetPixelExtentsMethodInfo ,
#endif
layoutLineGetPixelExtents ,
#if defined(ENABLE_OVERLOADING)
LayoutLineGetResolvedDirectionMethodInfo,
#endif
layoutLineGetResolvedDirection ,
#if defined(ENABLE_OVERLOADING)
LayoutLineGetStartIndexMethodInfo ,
#endif
layoutLineGetStartIndex ,
#if defined(ENABLE_OVERLOADING)
LayoutLineGetXRangesMethodInfo ,
#endif
layoutLineGetXRanges ,
#if defined(ENABLE_OVERLOADING)
LayoutLineIndexToXMethodInfo ,
#endif
layoutLineIndexToX ,
#if defined(ENABLE_OVERLOADING)
LayoutLineIsParagraphStartMethodInfo ,
#endif
layoutLineIsParagraphStart ,
#if defined(ENABLE_OVERLOADING)
LayoutLineRefMethodInfo ,
#endif
layoutLineRef ,
#if defined(ENABLE_OVERLOADING)
LayoutLineUnrefMethodInfo ,
#endif
layoutLineUnref ,
#if defined(ENABLE_OVERLOADING)
LayoutLineXToIndexMethodInfo ,
#endif
layoutLineXToIndex ,
getLayoutLineIsParagraphStart ,
#if defined(ENABLE_OVERLOADING)
layoutLine_isParagraphStart ,
#endif
setLayoutLineIsParagraphStart ,
clearLayoutLineLayout ,
getLayoutLineLayout ,
#if defined(ENABLE_OVERLOADING)
layoutLine_layout ,
#endif
setLayoutLineLayout ,
getLayoutLineLength ,
#if defined(ENABLE_OVERLOADING)
layoutLine_length ,
#endif
setLayoutLineLength ,
getLayoutLineResolvedDir ,
#if defined(ENABLE_OVERLOADING)
layoutLine_resolvedDir ,
#endif
setLayoutLineResolvedDir ,
clearLayoutLineRuns ,
getLayoutLineRuns ,
#if defined(ENABLE_OVERLOADING)
layoutLine_runs ,
#endif
setLayoutLineRuns ,
getLayoutLineStartIndex ,
#if defined(ENABLE_OVERLOADING)
layoutLine_startIndex ,
#endif
setLayoutLineStartIndex ,
) 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.Enums as Pango.Enums
import {-# SOURCE #-} qualified GI.Pango.Objects.Layout as Pango.Layout
import {-# SOURCE #-} qualified GI.Pango.Structs.GlyphItem as Pango.GlyphItem
import {-# SOURCE #-} qualified GI.Pango.Structs.Rectangle as Pango.Rectangle
newtype LayoutLine = LayoutLine (SP.ManagedPtr LayoutLine)
deriving (LayoutLine -> LayoutLine -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LayoutLine -> LayoutLine -> Bool
$c/= :: LayoutLine -> LayoutLine -> Bool
== :: LayoutLine -> LayoutLine -> Bool
$c== :: LayoutLine -> LayoutLine -> Bool
Eq)
instance SP.ManagedPtrNewtype LayoutLine where
toManagedPtr :: LayoutLine -> ManagedPtr LayoutLine
toManagedPtr (LayoutLine ManagedPtr LayoutLine
p) = ManagedPtr LayoutLine
p
foreign import ccall "pango_layout_line_get_type" c_pango_layout_line_get_type ::
IO GType
type instance O.ParentTypes LayoutLine = '[]
instance O.HasParentTypes LayoutLine
instance B.Types.TypedObject LayoutLine where
glibType :: IO GType
glibType = IO GType
c_pango_layout_line_get_type
instance B.Types.GBoxed LayoutLine
instance B.GValue.IsGValue (Maybe LayoutLine) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_pango_layout_line_get_type
gvalueSet_ :: Ptr GValue -> Maybe LayoutLine -> IO ()
gvalueSet_ Ptr GValue
gv Maybe LayoutLine
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr LayoutLine)
gvalueSet_ Ptr GValue
gv (P.Just LayoutLine
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr LayoutLine
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe LayoutLine)
gvalueGet_ Ptr GValue
gv = do
Ptr LayoutLine
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr LayoutLine)
if Ptr LayoutLine
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr LayoutLine -> LayoutLine
LayoutLine Ptr LayoutLine
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
newZeroLayoutLine :: MonadIO m => m LayoutLine
newZeroLayoutLine :: forall (m :: * -> *). MonadIO m => m LayoutLine
newZeroLayoutLine = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
24 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr LayoutLine -> LayoutLine
LayoutLine
instance tag ~ 'AttrSet => Constructible LayoutLine tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr LayoutLine -> LayoutLine)
-> [AttrOp LayoutLine tag] -> m LayoutLine
new ManagedPtr LayoutLine -> LayoutLine
_ [AttrOp LayoutLine tag]
attrs = do
LayoutLine
o <- forall (m :: * -> *). MonadIO m => m LayoutLine
newZeroLayoutLine
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set LayoutLine
o [AttrOp LayoutLine tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return LayoutLine
o
getLayoutLineLayout :: MonadIO m => LayoutLine -> m (Maybe Pango.Layout.Layout)
getLayoutLineLayout :: forall (m :: * -> *). MonadIO m => LayoutLine -> m (Maybe Layout)
getLayoutLineLayout LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
Ptr Layout
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO (Ptr Pango.Layout.Layout)
Maybe Layout
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr Layout
val forall a b. (a -> b) -> a -> b
$ \Ptr Layout
val' -> do
Layout
val'' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Layout -> Layout
Pango.Layout.Layout) Ptr Layout
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Layout
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Layout
result
setLayoutLineLayout :: MonadIO m => LayoutLine -> Ptr Pango.Layout.Layout -> m ()
setLayoutLineLayout :: forall (m :: * -> *). MonadIO m => LayoutLine -> Ptr Layout -> m ()
setLayoutLineLayout LayoutLine
s Ptr Layout
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Ptr Layout
val :: Ptr Pango.Layout.Layout)
clearLayoutLineLayout :: MonadIO m => LayoutLine -> m ()
clearLayoutLineLayout :: forall (m :: * -> *). MonadIO m => LayoutLine -> m ()
clearLayoutLineLayout LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (forall a. Ptr a
FP.nullPtr :: Ptr Pango.Layout.Layout)
#if defined(ENABLE_OVERLOADING)
data LayoutLineLayoutFieldInfo
instance AttrInfo LayoutLineLayoutFieldInfo where
type AttrBaseTypeConstraint LayoutLineLayoutFieldInfo = (~) LayoutLine
type AttrAllowedOps LayoutLineLayoutFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint LayoutLineLayoutFieldInfo = (~) (Ptr Pango.Layout.Layout)
type AttrTransferTypeConstraint LayoutLineLayoutFieldInfo = (~)(Ptr Pango.Layout.Layout)
type AttrTransferType LayoutLineLayoutFieldInfo = (Ptr Pango.Layout.Layout)
type AttrGetType LayoutLineLayoutFieldInfo = Maybe Pango.Layout.Layout
type AttrLabel LayoutLineLayoutFieldInfo = "layout"
type AttrOrigin LayoutLineLayoutFieldInfo = LayoutLine
attrGet = getLayoutLineLayout
attrSet = setLayoutLineLayout
attrConstruct = undefined
attrClear = clearLayoutLineLayout
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layout"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#g:attr:layout"
})
layoutLine_layout :: AttrLabelProxy "layout"
layoutLine_layout = AttrLabelProxy
#endif
getLayoutLineStartIndex :: MonadIO m => LayoutLine -> m Int32
getLayoutLineStartIndex :: forall (m :: * -> *). MonadIO m => LayoutLine -> m Int32
getLayoutLineStartIndex LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setLayoutLineStartIndex :: MonadIO m => LayoutLine -> Int32 -> m ()
setLayoutLineStartIndex :: forall (m :: * -> *). MonadIO m => LayoutLine -> Int32 -> m ()
setLayoutLineStartIndex LayoutLine
s Int32
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data LayoutLineStartIndexFieldInfo
instance AttrInfo LayoutLineStartIndexFieldInfo where
type AttrBaseTypeConstraint LayoutLineStartIndexFieldInfo = (~) LayoutLine
type AttrAllowedOps LayoutLineStartIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint LayoutLineStartIndexFieldInfo = (~) Int32
type AttrTransferTypeConstraint LayoutLineStartIndexFieldInfo = (~)Int32
type AttrTransferType LayoutLineStartIndexFieldInfo = Int32
type AttrGetType LayoutLineStartIndexFieldInfo = Int32
type AttrLabel LayoutLineStartIndexFieldInfo = "start_index"
type AttrOrigin LayoutLineStartIndexFieldInfo = LayoutLine
attrGet = getLayoutLineStartIndex
attrSet = setLayoutLineStartIndex
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.startIndex"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#g:attr:startIndex"
})
layoutLine_startIndex :: AttrLabelProxy "startIndex"
layoutLine_startIndex = AttrLabelProxy
#endif
getLayoutLineLength :: MonadIO m => LayoutLine -> m Int32
getLayoutLineLength :: forall (m :: * -> *). MonadIO m => LayoutLine -> m Int32
getLayoutLineLength LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setLayoutLineLength :: MonadIO m => LayoutLine -> Int32 -> m ()
setLayoutLineLength :: forall (m :: * -> *). MonadIO m => LayoutLine -> Int32 -> m ()
setLayoutLineLength LayoutLine
s Int32
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data LayoutLineLengthFieldInfo
instance AttrInfo LayoutLineLengthFieldInfo where
type AttrBaseTypeConstraint LayoutLineLengthFieldInfo = (~) LayoutLine
type AttrAllowedOps LayoutLineLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint LayoutLineLengthFieldInfo = (~) Int32
type AttrTransferTypeConstraint LayoutLineLengthFieldInfo = (~)Int32
type AttrTransferType LayoutLineLengthFieldInfo = Int32
type AttrGetType LayoutLineLengthFieldInfo = Int32
type AttrLabel LayoutLineLengthFieldInfo = "length"
type AttrOrigin LayoutLineLengthFieldInfo = LayoutLine
attrGet = getLayoutLineLength
attrSet = setLayoutLineLength
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.length"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#g:attr:length"
})
layoutLine_length :: AttrLabelProxy "length"
layoutLine_length = AttrLabelProxy
#endif
getLayoutLineRuns :: MonadIO m => LayoutLine -> m [Pango.GlyphItem.GlyphItem]
getLayoutLineRuns :: forall (m :: * -> *). MonadIO m => LayoutLine -> m [GlyphItem]
getLayoutLineRuns LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
Ptr (GSList (Ptr GlyphItem))
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
[Ptr GlyphItem]
val' <- forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr GlyphItem))
val
[GlyphItem]
val'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr GlyphItem -> GlyphItem
Pango.GlyphItem.GlyphItem) [Ptr GlyphItem]
val'
forall (m :: * -> *) a. Monad m => a -> m a
return [GlyphItem]
val''
setLayoutLineRuns :: MonadIO m => LayoutLine -> Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)) -> m ()
setLayoutLineRuns :: forall (m :: * -> *).
MonadIO m =>
LayoutLine -> Ptr (GSList (Ptr GlyphItem)) -> m ()
setLayoutLineRuns LayoutLine
s Ptr (GSList (Ptr GlyphItem))
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Ptr (GSList (Ptr GlyphItem))
val :: Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
clearLayoutLineRuns :: MonadIO m => LayoutLine -> m ()
clearLayoutLineRuns :: forall (m :: * -> *). MonadIO m => LayoutLine -> m ()
clearLayoutLineRuns LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. Ptr a
FP.nullPtr :: Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
#if defined(ENABLE_OVERLOADING)
data LayoutLineRunsFieldInfo
instance AttrInfo LayoutLineRunsFieldInfo where
type AttrBaseTypeConstraint LayoutLineRunsFieldInfo = (~) LayoutLine
type AttrAllowedOps LayoutLineRunsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint LayoutLineRunsFieldInfo = (~) (Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
type AttrTransferTypeConstraint LayoutLineRunsFieldInfo = (~)(Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
type AttrTransferType LayoutLineRunsFieldInfo = (Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
type AttrGetType LayoutLineRunsFieldInfo = [Pango.GlyphItem.GlyphItem]
type AttrLabel LayoutLineRunsFieldInfo = "runs"
type AttrOrigin LayoutLineRunsFieldInfo = LayoutLine
attrGet = getLayoutLineRuns
attrSet = setLayoutLineRuns
attrConstruct = undefined
attrClear = clearLayoutLineRuns
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.runs"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#g:attr:runs"
})
layoutLine_runs :: AttrLabelProxy "runs"
layoutLine_runs = AttrLabelProxy
#endif
getLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> m Word32
getLayoutLineIsParagraphStart :: forall (m :: * -> *). MonadIO m => LayoutLine -> m Word32
getLayoutLineIsParagraphStart LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> Word32 -> m ()
setLayoutLineIsParagraphStart :: forall (m :: * -> *). MonadIO m => LayoutLine -> Word32 -> m ()
setLayoutLineIsParagraphStart LayoutLine
s Word32
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data LayoutLineIsParagraphStartFieldInfo
instance AttrInfo LayoutLineIsParagraphStartFieldInfo where
type AttrBaseTypeConstraint LayoutLineIsParagraphStartFieldInfo = (~) LayoutLine
type AttrAllowedOps LayoutLineIsParagraphStartFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint LayoutLineIsParagraphStartFieldInfo = (~) Word32
type AttrTransferTypeConstraint LayoutLineIsParagraphStartFieldInfo = (~)Word32
type AttrTransferType LayoutLineIsParagraphStartFieldInfo = Word32
type AttrGetType LayoutLineIsParagraphStartFieldInfo = Word32
type AttrLabel LayoutLineIsParagraphStartFieldInfo = "is_paragraph_start"
type AttrOrigin LayoutLineIsParagraphStartFieldInfo = LayoutLine
attrGet = getLayoutLineIsParagraphStart
attrSet = setLayoutLineIsParagraphStart
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.isParagraphStart"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#g:attr:isParagraphStart"
})
layoutLine_isParagraphStart :: AttrLabelProxy "isParagraphStart"
layoutLine_isParagraphStart = AttrLabelProxy
#endif
getLayoutLineResolvedDir :: MonadIO m => LayoutLine -> m Word32
getLayoutLineResolvedDir :: forall (m :: * -> *). MonadIO m => LayoutLine -> m Word32
getLayoutLineResolvedDir LayoutLine
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
Word32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val
setLayoutLineResolvedDir :: MonadIO m => LayoutLine -> Word32 -> m ()
setLayoutLineResolvedDir :: forall (m :: * -> *). MonadIO m => LayoutLine -> Word32 -> m ()
setLayoutLineResolvedDir LayoutLine
s Word32
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 LayoutLine
s forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr LayoutLine
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Word32
val :: Word32)
#if defined(ENABLE_OVERLOADING)
data LayoutLineResolvedDirFieldInfo
instance AttrInfo LayoutLineResolvedDirFieldInfo where
type AttrBaseTypeConstraint LayoutLineResolvedDirFieldInfo = (~) LayoutLine
type AttrAllowedOps LayoutLineResolvedDirFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint LayoutLineResolvedDirFieldInfo = (~) Word32
type AttrTransferTypeConstraint LayoutLineResolvedDirFieldInfo = (~)Word32
type AttrTransferType LayoutLineResolvedDirFieldInfo = Word32
type AttrGetType LayoutLineResolvedDirFieldInfo = Word32
type AttrLabel LayoutLineResolvedDirFieldInfo = "resolved_dir"
type AttrOrigin LayoutLineResolvedDirFieldInfo = LayoutLine
attrGet = getLayoutLineResolvedDir
attrSet = setLayoutLineResolvedDir
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.resolvedDir"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#g:attr:resolvedDir"
})
layoutLine_resolvedDir :: AttrLabelProxy "resolvedDir"
layoutLine_resolvedDir = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList LayoutLine
type instance O.AttributeList LayoutLine = LayoutLineAttributeList
type LayoutLineAttributeList = ('[ '("layout", LayoutLineLayoutFieldInfo), '("startIndex", LayoutLineStartIndexFieldInfo), '("length", LayoutLineLengthFieldInfo), '("runs", LayoutLineRunsFieldInfo), '("isParagraphStart", LayoutLineIsParagraphStartFieldInfo), '("resolvedDir", LayoutLineResolvedDirFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "pango_layout_line_get_extents" pango_layout_line_get_extents ::
Ptr LayoutLine ->
Ptr Pango.Rectangle.Rectangle ->
Ptr Pango.Rectangle.Rectangle ->
IO ()
layoutLineGetExtents ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
layoutLineGetExtents :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m (Rectangle, Rectangle)
layoutLineGetExtents LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Ptr Rectangle
inkRect <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
16 :: IO (Ptr Pango.Rectangle.Rectangle)
Ptr Rectangle
logicalRect <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
16 :: IO (Ptr Pango.Rectangle.Rectangle)
Ptr LayoutLine -> Ptr Rectangle -> Ptr Rectangle -> IO ()
pango_layout_line_get_extents Ptr LayoutLine
line' Ptr Rectangle
inkRect Ptr Rectangle
logicalRect
Rectangle
inkRect' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Rectangle -> Rectangle
Pango.Rectangle.Rectangle) Ptr Rectangle
inkRect
Rectangle
logicalRect' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Rectangle -> Rectangle
Pango.Rectangle.Rectangle) Ptr Rectangle
logicalRect
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall (m :: * -> *) a. Monad m => a -> m a
return (Rectangle
inkRect', Rectangle
logicalRect')
#if defined(ENABLE_OVERLOADING)
data LayoutLineGetExtentsMethodInfo
instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.OverloadedMethod LayoutLineGetExtentsMethodInfo LayoutLine signature where
overloadedMethod = layoutLineGetExtents
instance O.OverloadedMethodInfo LayoutLineGetExtentsMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineGetExtents",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineGetExtents"
})
#endif
foreign import ccall "pango_layout_line_get_height" pango_layout_line_get_height ::
Ptr LayoutLine ->
Ptr Int32 ->
IO ()
layoutLineGetHeight ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m (Int32)
layoutLineGetHeight :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m Int32
layoutLineGetHeight LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Ptr Int32
height <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr LayoutLine -> Ptr Int32 -> IO ()
pango_layout_line_get_height Ptr LayoutLine
line' Ptr Int32
height
Int32
height' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
height
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall a. Ptr a -> IO ()
freeMem Ptr Int32
height
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
height'
#if defined(ENABLE_OVERLOADING)
data LayoutLineGetHeightMethodInfo
instance (signature ~ (m (Int32)), MonadIO m) => O.OverloadedMethod LayoutLineGetHeightMethodInfo LayoutLine signature where
overloadedMethod = layoutLineGetHeight
instance O.OverloadedMethodInfo LayoutLineGetHeightMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineGetHeight",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineGetHeight"
})
#endif
foreign import ccall "pango_layout_line_get_length" pango_layout_line_get_length ::
Ptr LayoutLine ->
IO Int32
layoutLineGetLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m Int32
layoutLineGetLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m Int32
layoutLineGetLength LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Int32
result <- Ptr LayoutLine -> IO Int32
pango_layout_line_get_length Ptr LayoutLine
line'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data LayoutLineGetLengthMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod LayoutLineGetLengthMethodInfo LayoutLine signature where
overloadedMethod = layoutLineGetLength
instance O.OverloadedMethodInfo LayoutLineGetLengthMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineGetLength",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineGetLength"
})
#endif
foreign import ccall "pango_layout_line_get_pixel_extents" pango_layout_line_get_pixel_extents ::
Ptr LayoutLine ->
Ptr Pango.Rectangle.Rectangle ->
Ptr Pango.Rectangle.Rectangle ->
IO ()
layoutLineGetPixelExtents ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
layoutLineGetPixelExtents :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m (Rectangle, Rectangle)
layoutLineGetPixelExtents LayoutLine
layoutLine = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
layoutLine' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
layoutLine
Ptr Rectangle
inkRect <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
16 :: IO (Ptr Pango.Rectangle.Rectangle)
Ptr Rectangle
logicalRect <- forall a. Int -> IO (Ptr a)
SP.callocBytes Int
16 :: IO (Ptr Pango.Rectangle.Rectangle)
Ptr LayoutLine -> Ptr Rectangle -> Ptr Rectangle -> IO ()
pango_layout_line_get_pixel_extents Ptr LayoutLine
layoutLine' Ptr Rectangle
inkRect Ptr Rectangle
logicalRect
Rectangle
inkRect' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Rectangle -> Rectangle
Pango.Rectangle.Rectangle) Ptr Rectangle
inkRect
Rectangle
logicalRect' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Rectangle -> Rectangle
Pango.Rectangle.Rectangle) Ptr Rectangle
logicalRect
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
layoutLine
forall (m :: * -> *) a. Monad m => a -> m a
return (Rectangle
inkRect', Rectangle
logicalRect')
#if defined(ENABLE_OVERLOADING)
data LayoutLineGetPixelExtentsMethodInfo
instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.OverloadedMethod LayoutLineGetPixelExtentsMethodInfo LayoutLine signature where
overloadedMethod = layoutLineGetPixelExtents
instance O.OverloadedMethodInfo LayoutLineGetPixelExtentsMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineGetPixelExtents",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineGetPixelExtents"
})
#endif
foreign import ccall "pango_layout_line_get_resolved_direction" pango_layout_line_get_resolved_direction ::
Ptr LayoutLine ->
IO CUInt
layoutLineGetResolvedDirection ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m Pango.Enums.Direction
layoutLineGetResolvedDirection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m Direction
layoutLineGetResolvedDirection LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
CUInt
result <- Ptr LayoutLine -> IO CUInt
pango_layout_line_get_resolved_direction Ptr LayoutLine
line'
let result' :: Direction
result' = (forall a. Enum a => Int -> a
toEnum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall (m :: * -> *) a. Monad m => a -> m a
return Direction
result'
#if defined(ENABLE_OVERLOADING)
data LayoutLineGetResolvedDirectionMethodInfo
instance (signature ~ (m Pango.Enums.Direction), MonadIO m) => O.OverloadedMethod LayoutLineGetResolvedDirectionMethodInfo LayoutLine signature where
overloadedMethod = layoutLineGetResolvedDirection
instance O.OverloadedMethodInfo LayoutLineGetResolvedDirectionMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineGetResolvedDirection",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineGetResolvedDirection"
})
#endif
foreign import ccall "pango_layout_line_get_start_index" pango_layout_line_get_start_index ::
Ptr LayoutLine ->
IO Int32
layoutLineGetStartIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m Int32
layoutLineGetStartIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m Int32
layoutLineGetStartIndex LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Int32
result <- Ptr LayoutLine -> IO Int32
pango_layout_line_get_start_index Ptr LayoutLine
line'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data LayoutLineGetStartIndexMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod LayoutLineGetStartIndexMethodInfo LayoutLine signature where
overloadedMethod = layoutLineGetStartIndex
instance O.OverloadedMethodInfo LayoutLineGetStartIndexMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineGetStartIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineGetStartIndex"
})
#endif
foreign import ccall "pango_layout_line_get_x_ranges" pango_layout_line_get_x_ranges ::
Ptr LayoutLine ->
Int32 ->
Int32 ->
Ptr (Ptr Int32) ->
Ptr Int32 ->
IO ()
layoutLineGetXRanges ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> Int32
-> Int32
-> m ([Int32])
layoutLineGetXRanges :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> Int32 -> Int32 -> m [Int32]
layoutLineGetXRanges LayoutLine
line Int32
startIndex Int32
endIndex = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Ptr (Ptr Int32)
ranges <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Int32))
Ptr Int32
nRanges <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr LayoutLine
-> Int32 -> Int32 -> Ptr (Ptr Int32) -> Ptr Int32 -> IO ()
pango_layout_line_get_x_ranges Ptr LayoutLine
line' Int32
startIndex Int32
endIndex Ptr (Ptr Int32)
ranges Ptr Int32
nRanges
Int32
nRanges' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
nRanges
Ptr Int32
ranges' <- forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Int32)
ranges
[Int32]
ranges'' <- (forall a b. (Integral a, Storable b) => a -> Ptr b -> IO [b]
unpackStorableArrayWithLength Int32
nRanges') Ptr Int32
ranges'
forall a. Ptr a -> IO ()
freeMem Ptr Int32
ranges'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Int32)
ranges
forall a. Ptr a -> IO ()
freeMem Ptr Int32
nRanges
forall (m :: * -> *) a. Monad m => a -> m a
return [Int32]
ranges''
#if defined(ENABLE_OVERLOADING)
data LayoutLineGetXRangesMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ([Int32])), MonadIO m) => O.OverloadedMethod LayoutLineGetXRangesMethodInfo LayoutLine signature where
overloadedMethod = layoutLineGetXRanges
instance O.OverloadedMethodInfo LayoutLineGetXRangesMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineGetXRanges",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineGetXRanges"
})
#endif
foreign import ccall "pango_layout_line_index_to_x" pango_layout_line_index_to_x ::
Ptr LayoutLine ->
Int32 ->
CInt ->
Ptr Int32 ->
IO ()
layoutLineIndexToX ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> Int32
-> Bool
-> m (Int32)
layoutLineIndexToX :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> Int32 -> Bool -> m Int32
layoutLineIndexToX LayoutLine
line Int32
index_ Bool
trailing = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
let trailing' :: CInt
trailing' = (forall a b. (Integral a, Num b) => a -> b
P.fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
P.fromEnum) Bool
trailing
Ptr Int32
xPos <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr LayoutLine -> Int32 -> CInt -> Ptr Int32 -> IO ()
pango_layout_line_index_to_x Ptr LayoutLine
line' Int32
index_ CInt
trailing' Ptr Int32
xPos
Int32
xPos' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
xPos
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall a. Ptr a -> IO ()
freeMem Ptr Int32
xPos
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
xPos'
#if defined(ENABLE_OVERLOADING)
data LayoutLineIndexToXMethodInfo
instance (signature ~ (Int32 -> Bool -> m (Int32)), MonadIO m) => O.OverloadedMethod LayoutLineIndexToXMethodInfo LayoutLine signature where
overloadedMethod = layoutLineIndexToX
instance O.OverloadedMethodInfo LayoutLineIndexToXMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineIndexToX",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineIndexToX"
})
#endif
foreign import ccall "pango_layout_line_is_paragraph_start" pango_layout_line_is_paragraph_start ::
Ptr LayoutLine ->
IO CInt
layoutLineIsParagraphStart ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m Bool
layoutLineIsParagraphStart :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m Bool
layoutLineIsParagraphStart LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
CInt
result <- Ptr LayoutLine -> IO CInt
pango_layout_line_is_paragraph_start Ptr LayoutLine
line'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data LayoutLineIsParagraphStartMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod LayoutLineIsParagraphStartMethodInfo LayoutLine signature where
overloadedMethod = layoutLineIsParagraphStart
instance O.OverloadedMethodInfo LayoutLineIsParagraphStartMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineIsParagraphStart",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineIsParagraphStart"
})
#endif
foreign import ccall "pango_layout_line_ref" pango_layout_line_ref ::
Ptr LayoutLine ->
IO (Ptr LayoutLine)
layoutLineRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m (Maybe LayoutLine)
layoutLineRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m (Maybe LayoutLine)
layoutLineRef LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Ptr LayoutLine
result <- Ptr LayoutLine -> IO (Ptr LayoutLine)
pango_layout_line_ref Ptr LayoutLine
line'
Maybe LayoutLine
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr LayoutLine
result forall a b. (a -> b) -> a -> b
$ \Ptr LayoutLine
result' -> do
LayoutLine
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr LayoutLine -> LayoutLine
LayoutLine) Ptr LayoutLine
result'
forall (m :: * -> *) a. Monad m => a -> m a
return LayoutLine
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe LayoutLine
maybeResult
#if defined(ENABLE_OVERLOADING)
data LayoutLineRefMethodInfo
instance (signature ~ (m (Maybe LayoutLine)), MonadIO m) => O.OverloadedMethod LayoutLineRefMethodInfo LayoutLine signature where
overloadedMethod = layoutLineRef
instance O.OverloadedMethodInfo LayoutLineRefMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineRef"
})
#endif
foreign import ccall "pango_layout_line_unref" pango_layout_line_unref ::
Ptr LayoutLine ->
IO ()
layoutLineUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> m ()
layoutLineUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> m ()
layoutLineUnref LayoutLine
line = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Ptr LayoutLine -> IO ()
pango_layout_line_unref Ptr LayoutLine
line'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data LayoutLineUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod LayoutLineUnrefMethodInfo LayoutLine signature where
overloadedMethod = layoutLineUnref
instance O.OverloadedMethodInfo LayoutLineUnrefMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineUnref"
})
#endif
foreign import ccall "pango_layout_line_x_to_index" pango_layout_line_x_to_index ::
Ptr LayoutLine ->
Int32 ->
Ptr Int32 ->
Ptr Int32 ->
IO CInt
layoutLineXToIndex ::
(B.CallStack.HasCallStack, MonadIO m) =>
LayoutLine
-> Int32
-> m ((Bool, Int32, Int32))
layoutLineXToIndex :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
LayoutLine -> Int32 -> m (Bool, Int32, Int32)
layoutLineXToIndex LayoutLine
line Int32
xPos = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr LayoutLine
line' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr LayoutLine
line
Ptr Int32
index_ <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
Ptr Int32
trailing <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr LayoutLine -> Int32 -> Ptr Int32 -> Ptr Int32 -> IO CInt
pango_layout_line_x_to_index Ptr LayoutLine
line' Int32
xPos Ptr Int32
index_ Ptr Int32
trailing
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int32
index_' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
index_
Int32
trailing' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
trailing
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr LayoutLine
line
forall a. Ptr a -> IO ()
freeMem Ptr Int32
index_
forall a. Ptr a -> IO ()
freeMem Ptr Int32
trailing
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int32
index_', Int32
trailing')
#if defined(ENABLE_OVERLOADING)
data LayoutLineXToIndexMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Int32, Int32))), MonadIO m) => O.OverloadedMethod LayoutLineXToIndexMethodInfo LayoutLine signature where
overloadedMethod = layoutLineXToIndex
instance O.OverloadedMethodInfo LayoutLineXToIndexMethodInfo LayoutLine where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Pango.Structs.LayoutLine.layoutLineXToIndex",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-pango-1.0.27/docs/GI-Pango-Structs-LayoutLine.html#v:layoutLineXToIndex"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveLayoutLineMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveLayoutLineMethod "indexToX" o = LayoutLineIndexToXMethodInfo
ResolveLayoutLineMethod "isParagraphStart" o = LayoutLineIsParagraphStartMethodInfo
ResolveLayoutLineMethod "ref" o = LayoutLineRefMethodInfo
ResolveLayoutLineMethod "unref" o = LayoutLineUnrefMethodInfo
ResolveLayoutLineMethod "xToIndex" o = LayoutLineXToIndexMethodInfo
ResolveLayoutLineMethod "getExtents" o = LayoutLineGetExtentsMethodInfo
ResolveLayoutLineMethod "getHeight" o = LayoutLineGetHeightMethodInfo
ResolveLayoutLineMethod "getLength" o = LayoutLineGetLengthMethodInfo
ResolveLayoutLineMethod "getPixelExtents" o = LayoutLineGetPixelExtentsMethodInfo
ResolveLayoutLineMethod "getResolvedDirection" o = LayoutLineGetResolvedDirectionMethodInfo
ResolveLayoutLineMethod "getStartIndex" o = LayoutLineGetStartIndexMethodInfo
ResolveLayoutLineMethod "getXRanges" o = LayoutLineGetXRangesMethodInfo
ResolveLayoutLineMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveLayoutLineMethod t LayoutLine, O.OverloadedMethod info LayoutLine p) => OL.IsLabel t (LayoutLine -> 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 ~ ResolveLayoutLineMethod t LayoutLine, O.OverloadedMethod info LayoutLine p, R.HasField t LayoutLine p) => R.HasField t LayoutLine p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveLayoutLineMethod t LayoutLine, O.OverloadedMethodInfo info LayoutLine) => OL.IsLabel t (O.MethodProxy info LayoutLine) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif