{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

The 'GI.Pango.Structs.LayoutLine.LayoutLine' structure represents one of the lines resulting
from laying out a paragraph via 'GI.Pango.Objects.Layout.Layout'. 'GI.Pango.Structs.LayoutLine.LayoutLine'
structures are obtained by calling 'GI.Pango.Objects.Layout.layoutGetLine' and
are only valid until the text, attributes, or settings of the
parent 'GI.Pango.Objects.Layout.Layout' are modified.

Routines for rendering PangoLayout objects are provided in
code specific to each rendering system.
-}

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

module GI.Pango.Structs.LayoutLine
    (

-- * Exported types
    LayoutLine(..)                          ,
    newZeroLayoutLine                       ,
    noLayoutLine                            ,


 -- * Methods
-- ** getExtents #method:getExtents#

#if ENABLE_OVERLOADING
    LayoutLineGetExtentsMethodInfo          ,
#endif
    layoutLineGetExtents                    ,


-- ** getPixelExtents #method:getPixelExtents#

#if ENABLE_OVERLOADING
    LayoutLineGetPixelExtentsMethodInfo     ,
#endif
    layoutLineGetPixelExtents               ,


-- ** getXRanges #method:getXRanges#

#if ENABLE_OVERLOADING
    LayoutLineGetXRangesMethodInfo          ,
#endif
    layoutLineGetXRanges                    ,


-- ** indexToX #method:indexToX#

#if ENABLE_OVERLOADING
    LayoutLineIndexToXMethodInfo            ,
#endif
    layoutLineIndexToX                      ,


-- ** ref #method:ref#

#if ENABLE_OVERLOADING
    LayoutLineRefMethodInfo                 ,
#endif
    layoutLineRef                           ,


-- ** unref #method:unref#

#if ENABLE_OVERLOADING
    LayoutLineUnrefMethodInfo               ,
#endif
    layoutLineUnref                         ,


-- ** xToIndex #method:xToIndex#

#if ENABLE_OVERLOADING
    LayoutLineXToIndexMethodInfo            ,
#endif
    layoutLineXToIndex                      ,




 -- * Properties
-- ** isParagraphStart #attr:isParagraphStart#
{- | @/TRUE/@ if this is the first line of the paragraph
-}
    getLayoutLineIsParagraphStart           ,
#if ENABLE_OVERLOADING
    layoutLine_isParagraphStart             ,
#endif
    setLayoutLineIsParagraphStart           ,


-- ** layout #attr:layout#
{- | the layout this line belongs to, might be 'Nothing'
-}
    clearLayoutLineLayout                   ,
    getLayoutLineLayout                     ,
#if ENABLE_OVERLOADING
    layoutLine_layout                       ,
#endif
    setLayoutLineLayout                     ,


-- ** length #attr:length#
{- | length of line in bytes
-}
    getLayoutLineLength                     ,
#if ENABLE_OVERLOADING
    layoutLine_length                       ,
#endif
    setLayoutLineLength                     ,


-- ** resolvedDir #attr:resolvedDir#
{- | @/Resolved/@ PangoDirection of line
-}
    getLayoutLineResolvedDir                ,
#if ENABLE_OVERLOADING
    layoutLine_resolvedDir                  ,
#endif
    setLayoutLineResolvedDir                ,


-- ** runs #attr:runs#
{- | list of runs in the
       line, from left to right
-}
    clearLayoutLineRuns                     ,
    getLayoutLineRuns                       ,
#if ENABLE_OVERLOADING
    layoutLine_runs                         ,
#endif
    setLayoutLineRuns                       ,


-- ** startIndex #attr:startIndex#
{- | start of line as byte index into layout->text
-}
    getLayoutLineStartIndex                 ,
#if 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.ManagedPtr as B.ManagedPtr
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.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.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

-- | Memory-managed wrapper type.
newtype LayoutLine = LayoutLine (ManagedPtr LayoutLine)
foreign import ccall "pango_layout_line_get_type" c_pango_layout_line_get_type ::
    IO GType

instance BoxedObject LayoutLine where
    boxedType _ = c_pango_layout_line_get_type

-- | Construct a `LayoutLine` struct initialized to zero.
newZeroLayoutLine :: MonadIO m => m LayoutLine
newZeroLayoutLine = liftIO $ callocBoxedBytes 32 >>= wrapBoxed LayoutLine

instance tag ~ 'AttrSet => Constructible LayoutLine tag where
    new _ attrs = do
        o <- newZeroLayoutLine
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `LayoutLine`.
noLayoutLine :: Maybe LayoutLine
noLayoutLine = Nothing

{- |
Get the value of the “@layout@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' layoutLine #layout
@
-}
getLayoutLineLayout :: MonadIO m => LayoutLine -> m (Maybe Pango.Layout.Layout)
getLayoutLineLayout s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Pango.Layout.Layout)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Pango.Layout.Layout) val'
        return val''
    return result

{- |
Set the value of the “@layout@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' layoutLine [ #layout 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLayoutLineLayout :: MonadIO m => LayoutLine -> Ptr Pango.Layout.Layout -> m ()
setLayoutLineLayout s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Ptr Pango.Layout.Layout)

{- |
Set the value of the “@layout@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #layout
@
-}
clearLayoutLineLayout :: MonadIO m => LayoutLine -> m ()
clearLayoutLineLayout s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: Ptr Pango.Layout.Layout)

#if ENABLE_OVERLOADING
data LayoutLineLayoutFieldInfo
instance AttrInfo LayoutLineLayoutFieldInfo where
    type AttrAllowedOps LayoutLineLayoutFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint LayoutLineLayoutFieldInfo = (~) (Ptr Pango.Layout.Layout)
    type AttrBaseTypeConstraint LayoutLineLayoutFieldInfo = (~) LayoutLine
    type AttrGetType LayoutLineLayoutFieldInfo = Maybe Pango.Layout.Layout
    type AttrLabel LayoutLineLayoutFieldInfo = "layout"
    type AttrOrigin LayoutLineLayoutFieldInfo = LayoutLine
    attrGet _ = getLayoutLineLayout
    attrSet _ = setLayoutLineLayout
    attrConstruct = undefined
    attrClear _ = clearLayoutLineLayout

layoutLine_layout :: AttrLabelProxy "layout"
layoutLine_layout = AttrLabelProxy

#endif


{- |
Get the value of the “@start_index@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' layoutLine #startIndex
@
-}
getLayoutLineStartIndex :: MonadIO m => LayoutLine -> m Int32
getLayoutLineStartIndex s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Int32
    return val

{- |
Set the value of the “@start_index@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' layoutLine [ #startIndex 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLayoutLineStartIndex :: MonadIO m => LayoutLine -> Int32 -> m ()
setLayoutLineStartIndex s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Int32)

#if ENABLE_OVERLOADING
data LayoutLineStartIndexFieldInfo
instance AttrInfo LayoutLineStartIndexFieldInfo where
    type AttrAllowedOps LayoutLineStartIndexFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LayoutLineStartIndexFieldInfo = (~) Int32
    type AttrBaseTypeConstraint LayoutLineStartIndexFieldInfo = (~) LayoutLine
    type AttrGetType LayoutLineStartIndexFieldInfo = Int32
    type AttrLabel LayoutLineStartIndexFieldInfo = "start_index"
    type AttrOrigin LayoutLineStartIndexFieldInfo = LayoutLine
    attrGet _ = getLayoutLineStartIndex
    attrSet _ = setLayoutLineStartIndex
    attrConstruct = undefined
    attrClear _ = undefined

layoutLine_startIndex :: AttrLabelProxy "startIndex"
layoutLine_startIndex = AttrLabelProxy

#endif


{- |
Get the value of the “@length@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' layoutLine #length
@
-}
getLayoutLineLength :: MonadIO m => LayoutLine -> m Int32
getLayoutLineLength s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 12) :: IO Int32
    return val

{- |
Set the value of the “@length@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' layoutLine [ #length 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLayoutLineLength :: MonadIO m => LayoutLine -> Int32 -> m ()
setLayoutLineLength s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 12) (val :: Int32)

#if ENABLE_OVERLOADING
data LayoutLineLengthFieldInfo
instance AttrInfo LayoutLineLengthFieldInfo where
    type AttrAllowedOps LayoutLineLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LayoutLineLengthFieldInfo = (~) Int32
    type AttrBaseTypeConstraint LayoutLineLengthFieldInfo = (~) LayoutLine
    type AttrGetType LayoutLineLengthFieldInfo = Int32
    type AttrLabel LayoutLineLengthFieldInfo = "length"
    type AttrOrigin LayoutLineLengthFieldInfo = LayoutLine
    attrGet _ = getLayoutLineLength
    attrSet _ = setLayoutLineLength
    attrConstruct = undefined
    attrClear _ = undefined

layoutLine_length :: AttrLabelProxy "length"
layoutLine_length = AttrLabelProxy

#endif


{- |
Get the value of the “@runs@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' layoutLine #runs
@
-}
getLayoutLineRuns :: MonadIO m => LayoutLine -> m [Pango.GlyphItem.GlyphItem]
getLayoutLineRuns s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO (Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
    val' <- unpackGSList val
    val'' <- mapM (newBoxed Pango.GlyphItem.GlyphItem) val'
    return val''

{- |
Set the value of the “@runs@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' layoutLine [ #runs 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLayoutLineRuns :: MonadIO m => LayoutLine -> Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)) -> m ()
setLayoutLineRuns s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (val :: Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))

{- |
Set the value of the “@runs@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #runs
@
-}
clearLayoutLineRuns :: MonadIO m => LayoutLine -> m ()
clearLayoutLineRuns s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 16) (FP.nullPtr :: Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))

#if ENABLE_OVERLOADING
data LayoutLineRunsFieldInfo
instance AttrInfo LayoutLineRunsFieldInfo where
    type AttrAllowedOps LayoutLineRunsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint LayoutLineRunsFieldInfo = (~) (Ptr (GSList (Ptr Pango.GlyphItem.GlyphItem)))
    type AttrBaseTypeConstraint LayoutLineRunsFieldInfo = (~) LayoutLine
    type AttrGetType LayoutLineRunsFieldInfo = [Pango.GlyphItem.GlyphItem]
    type AttrLabel LayoutLineRunsFieldInfo = "runs"
    type AttrOrigin LayoutLineRunsFieldInfo = LayoutLine
    attrGet _ = getLayoutLineRuns
    attrSet _ = setLayoutLineRuns
    attrConstruct = undefined
    attrClear _ = clearLayoutLineRuns

layoutLine_runs :: AttrLabelProxy "runs"
layoutLine_runs = AttrLabelProxy

#endif


{- |
Get the value of the “@is_paragraph_start@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' layoutLine #isParagraphStart
@
-}
getLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> m Word32
getLayoutLineIsParagraphStart s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word32
    return val

{- |
Set the value of the “@is_paragraph_start@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' layoutLine [ #isParagraphStart 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLayoutLineIsParagraphStart :: MonadIO m => LayoutLine -> Word32 -> m ()
setLayoutLineIsParagraphStart s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word32)

#if ENABLE_OVERLOADING
data LayoutLineIsParagraphStartFieldInfo
instance AttrInfo LayoutLineIsParagraphStartFieldInfo where
    type AttrAllowedOps LayoutLineIsParagraphStartFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LayoutLineIsParagraphStartFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LayoutLineIsParagraphStartFieldInfo = (~) LayoutLine
    type AttrGetType LayoutLineIsParagraphStartFieldInfo = Word32
    type AttrLabel LayoutLineIsParagraphStartFieldInfo = "is_paragraph_start"
    type AttrOrigin LayoutLineIsParagraphStartFieldInfo = LayoutLine
    attrGet _ = getLayoutLineIsParagraphStart
    attrSet _ = setLayoutLineIsParagraphStart
    attrConstruct = undefined
    attrClear _ = undefined

layoutLine_isParagraphStart :: AttrLabelProxy "isParagraphStart"
layoutLine_isParagraphStart = AttrLabelProxy

#endif


{- |
Get the value of the “@resolved_dir@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' layoutLine #resolvedDir
@
-}
getLayoutLineResolvedDir :: MonadIO m => LayoutLine -> m Word32
getLayoutLineResolvedDir s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 28) :: IO Word32
    return val

{- |
Set the value of the “@resolved_dir@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' layoutLine [ #resolvedDir 'Data.GI.Base.Attributes.:=' value ]
@
-}
setLayoutLineResolvedDir :: MonadIO m => LayoutLine -> Word32 -> m ()
setLayoutLineResolvedDir s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 28) (val :: Word32)

#if ENABLE_OVERLOADING
data LayoutLineResolvedDirFieldInfo
instance AttrInfo LayoutLineResolvedDirFieldInfo where
    type AttrAllowedOps LayoutLineResolvedDirFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint LayoutLineResolvedDirFieldInfo = (~) Word32
    type AttrBaseTypeConstraint LayoutLineResolvedDirFieldInfo = (~) LayoutLine
    type AttrGetType LayoutLineResolvedDirFieldInfo = Word32
    type AttrLabel LayoutLineResolvedDirFieldInfo = "resolved_dir"
    type AttrOrigin LayoutLineResolvedDirFieldInfo = LayoutLine
    attrGet _ = getLayoutLineResolvedDir
    attrSet _ = setLayoutLineResolvedDir
    attrConstruct = undefined
    attrClear _ = undefined

layoutLine_resolvedDir :: AttrLabelProxy "resolvedDir"
layoutLine_resolvedDir = AttrLabelProxy

#endif



#if 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, *)])
#endif

-- method LayoutLine::get_extents
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ink_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the extents of\n           the glyph string as drawn, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "logical_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the logical\n               extents of the glyph string, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_layout_line_get_extents" pango_layout_line_get_extents ::
    Ptr LayoutLine ->                       -- line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
    Ptr Pango.Rectangle.Rectangle ->        -- ink_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
    Ptr Pango.Rectangle.Rectangle ->        -- logical_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
    IO ()

{- |
Computes the logical and ink extents of a layout line. See
'GI.Pango.Objects.Font.fontGetGlyphExtents' for details about the interpretation
of the rectangles.
-}
layoutLineGetExtents ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayoutLine
    {- ^ /@line@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine' -}
    -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
layoutLineGetExtents line = liftIO $ do
    line' <- unsafeManagedPtrGetPtr line
    inkRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
    logicalRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
    pango_layout_line_get_extents line' inkRect logicalRect
    inkRect' <- (wrapPtr Pango.Rectangle.Rectangle) inkRect
    logicalRect' <- (wrapPtr Pango.Rectangle.Rectangle) logicalRect
    touchManagedPtr line
    return (inkRect', logicalRect')

#if ENABLE_OVERLOADING
data LayoutLineGetExtentsMethodInfo
instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.MethodInfo LayoutLineGetExtentsMethodInfo LayoutLine signature where
    overloadedMethod _ = layoutLineGetExtents

#endif

-- method LayoutLine::get_pixel_extents
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "layout_line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ink_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the extents of\n                  the glyph string as drawn, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "logical_rect", argType = TInterface (Name {namespace = "Pango", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "rectangle used to store the logical\n                      extents of the glyph string, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_layout_line_get_pixel_extents" pango_layout_line_get_pixel_extents ::
    Ptr LayoutLine ->                       -- layout_line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
    Ptr Pango.Rectangle.Rectangle ->        -- ink_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
    Ptr Pango.Rectangle.Rectangle ->        -- logical_rect : TInterface (Name {namespace = "Pango", name = "Rectangle"})
    IO ()

{- |
Computes the logical and ink extents of /@layoutLine@/ in device units.
This function just calls 'GI.Pango.Structs.LayoutLine.layoutLineGetExtents' followed by
two 'GI.Pango.Functions.extentsToPixels' calls, rounding /@inkRect@/ and /@logicalRect@/
such that the rounded rectangles fully contain the unrounded one (that is,
passes them as first argument to 'GI.Pango.Functions.extentsToPixels').
-}
layoutLineGetPixelExtents ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayoutLine
    {- ^ /@layoutLine@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine' -}
    -> m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))
layoutLineGetPixelExtents layoutLine = liftIO $ do
    layoutLine' <- unsafeManagedPtrGetPtr layoutLine
    inkRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
    logicalRect <- callocBytes 16 :: IO (Ptr Pango.Rectangle.Rectangle)
    pango_layout_line_get_pixel_extents layoutLine' inkRect logicalRect
    inkRect' <- (wrapPtr Pango.Rectangle.Rectangle) inkRect
    logicalRect' <- (wrapPtr Pango.Rectangle.Rectangle) logicalRect
    touchManagedPtr layoutLine
    return (inkRect', logicalRect')

#if ENABLE_OVERLOADING
data LayoutLineGetPixelExtentsMethodInfo
instance (signature ~ (m ((Pango.Rectangle.Rectangle, Pango.Rectangle.Rectangle))), MonadIO m) => O.MethodInfo LayoutLineGetPixelExtentsMethodInfo LayoutLine signature where
    overloadedMethod _ = layoutLineGetPixelExtents

#endif

-- method LayoutLine::get_x_ranges
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Start byte index of the logical range. If this value\n              is less than the start index for the line, then\n              the first range will extend all the way to the leading\n              edge of the layout. Otherwise it will start at the\n              leading edge of the first character.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Ending byte index of the logical range. If this value\n              is greater than the end index for the line, then\n              the last range will extend all the way to the trailing\n              edge of the layout. Otherwise, it will end at the\n              trailing edge of the last character.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ranges", argType = TCArray False (-1) 4 (TBasicType TInt), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n              location to store a pointer to an array of ranges.\n              The array will be of length <literal>2*n_ranges</literal>,\n              with each range starting at <literal>(*ranges)[2*n]</literal>\n              and of width <literal>(*ranges)[2*n + 1] - (*ranges)[2*n]</literal>.\n              This array must be freed with g_free(). The coordinates are relative\n              to the layout and are in Pango units.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "n_ranges", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of ranges stored in @ranges.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : [Arg {argCName = "n_ranges", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of ranges stored in @ranges.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_layout_line_get_x_ranges" pango_layout_line_get_x_ranges ::
    Ptr LayoutLine ->                       -- line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
    Int32 ->                                -- start_index : TBasicType TInt
    Int32 ->                                -- end_index : TBasicType TInt
    Ptr (Ptr Int32) ->                      -- ranges : TCArray False (-1) 4 (TBasicType TInt)
    Ptr Int32 ->                            -- n_ranges : TBasicType TInt
    IO ()

{- |
Gets a list of visual ranges corresponding to a given logical range.
This list is not necessarily minimal - there may be consecutive
ranges which are adjacent. The ranges will be sorted from left to
right. The ranges are with respect to the left edge of the entire
layout, not with respect to the line.
-}
layoutLineGetXRanges ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayoutLine
    {- ^ /@line@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine' -}
    -> Int32
    {- ^ /@startIndex@/: Start byte index of the logical range. If this value
              is less than the start index for the line, then
              the first range will extend all the way to the leading
              edge of the layout. Otherwise it will start at the
              leading edge of the first character. -}
    -> Int32
    {- ^ /@endIndex@/: Ending byte index of the logical range. If this value
              is greater than the end index for the line, then
              the last range will extend all the way to the trailing
              edge of the layout. Otherwise, it will end at the
              trailing edge of the last character. -}
    -> m ([Int32])
layoutLineGetXRanges line startIndex endIndex = liftIO $ do
    line' <- unsafeManagedPtrGetPtr line
    ranges <- allocMem :: IO (Ptr (Ptr Int32))
    nRanges <- allocMem :: IO (Ptr Int32)
    pango_layout_line_get_x_ranges line' startIndex endIndex ranges nRanges
    nRanges' <- peek nRanges
    ranges' <- peek ranges
    ranges'' <- (unpackStorableArrayWithLength nRanges') ranges'
    freeMem ranges'
    touchManagedPtr line
    freeMem ranges
    freeMem nRanges
    return ranges''

#if ENABLE_OVERLOADING
data LayoutLineGetXRangesMethodInfo
instance (signature ~ (Int32 -> Int32 -> m ([Int32])), MonadIO m) => O.MethodInfo LayoutLineGetXRangesMethodInfo LayoutLine signature where
    overloadedMethod _ = layoutLineGetXRanges

#endif

-- method LayoutLine::index_to_x
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "byte offset of a grapheme within the layout", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "trailing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an integer indicating the edge of the grapheme to retrieve\n           the position of. If > 0, the trailing edge of the grapheme,\n           if 0, the leading of the grapheme.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_pos", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the x_offset (in Pango unit)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_layout_line_index_to_x" pango_layout_line_index_to_x ::
    Ptr LayoutLine ->                       -- line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
    Int32 ->                                -- index_ : TBasicType TInt
    CInt ->                                 -- trailing : TBasicType TBoolean
    Ptr Int32 ->                            -- x_pos : TBasicType TInt
    IO ()

{- |
Converts an index within a line to a X position.
-}
layoutLineIndexToX ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayoutLine
    {- ^ /@line@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine' -}
    -> Int32
    {- ^ /@index_@/: byte offset of a grapheme within the layout -}
    -> Bool
    {- ^ /@trailing@/: an integer indicating the edge of the grapheme to retrieve
           the position of. If > 0, the trailing edge of the grapheme,
           if 0, the leading of the grapheme. -}
    -> m (Int32)
layoutLineIndexToX line index_ trailing = liftIO $ do
    line' <- unsafeManagedPtrGetPtr line
    let trailing' = (fromIntegral . fromEnum) trailing
    xPos <- allocMem :: IO (Ptr Int32)
    pango_layout_line_index_to_x line' index_ trailing' xPos
    xPos' <- peek xPos
    touchManagedPtr line
    freeMem xPos
    return xPos'

#if ENABLE_OVERLOADING
data LayoutLineIndexToXMethodInfo
instance (signature ~ (Int32 -> Bool -> m (Int32)), MonadIO m) => O.MethodInfo LayoutLineIndexToXMethodInfo LayoutLine signature where
    overloadedMethod _ = layoutLineIndexToX

#endif

-- method LayoutLine::ref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine, may be %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Pango", name = "LayoutLine"}))
-- throws : False
-- Skip return : False

foreign import ccall "pango_layout_line_ref" pango_layout_line_ref ::
    Ptr LayoutLine ->                       -- line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
    IO (Ptr LayoutLine)

{- |
Increase the reference count of a 'GI.Pango.Structs.LayoutLine.LayoutLine' by one.

/Since: 1.10/
-}
layoutLineRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayoutLine
    {- ^ /@line@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine', may be 'Nothing' -}
    -> m LayoutLine
    {- ^ __Returns:__ the line passed in. -}
layoutLineRef line = liftIO $ do
    line' <- unsafeManagedPtrGetPtr line
    result <- pango_layout_line_ref line'
    checkUnexpectedReturnNULL "layoutLineRef" result
    result' <- (wrapBoxed LayoutLine) result
    touchManagedPtr line
    return result'

#if ENABLE_OVERLOADING
data LayoutLineRefMethodInfo
instance (signature ~ (m LayoutLine), MonadIO m) => O.MethodInfo LayoutLineRefMethodInfo LayoutLine signature where
    overloadedMethod _ = layoutLineRef

#endif

-- method LayoutLine::unref
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_layout_line_unref" pango_layout_line_unref ::
    Ptr LayoutLine ->                       -- line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
    IO ()

{- |
Decrease the reference count of a 'GI.Pango.Structs.LayoutLine.LayoutLine' by one.
If the result is zero, the line and all associated memory
will be freed.
-}
layoutLineUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayoutLine
    {- ^ /@line@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine' -}
    -> m ()
layoutLineUnref line = liftIO $ do
    line' <- unsafeManagedPtrGetPtr line
    pango_layout_line_unref line'
    touchManagedPtr line
    return ()

#if ENABLE_OVERLOADING
data LayoutLineUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo LayoutLineUnrefMethodInfo LayoutLine signature where
    overloadedMethod _ = layoutLineUnref

#endif

-- method LayoutLine::x_to_index
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "line", argType = TInterface (Name {namespace = "Pango", name = "LayoutLine"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoLayoutLine", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x_pos", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X offset (in Pango units)\n            from the left edge of the line.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index_", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store calculated byte index for\n                  the grapheme in which the user clicked.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "trailing", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store an integer indicating where\n                  in the grapheme the user clicked. It will either\n                  be zero, or the number of characters in the\n                  grapheme. 0 represents the leading edge of the grapheme.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "pango_layout_line_x_to_index" pango_layout_line_x_to_index ::
    Ptr LayoutLine ->                       -- line : TInterface (Name {namespace = "Pango", name = "LayoutLine"})
    Int32 ->                                -- x_pos : TBasicType TInt
    Ptr Int32 ->                            -- index_ : TBasicType TInt
    Ptr Int32 ->                            -- trailing : TBasicType TInt
    IO CInt

{- |
Converts from x offset to the byte index of the corresponding
character within the text of the layout. If /@xPos@/ is outside the line,
/@index_@/ and /@trailing@/ will point to the very first or very last position
in the line. This determination is based on the resolved direction
of the paragraph; for example, if the resolved direction is
right-to-left, then an X position to the right of the line (after it)
results in 0 being stored in /@index_@/ and /@trailing@/. An X position to the
left of the line results in /@index_@/ pointing to the (logical) last
grapheme in the line and /@trailing@/ being set to the number of characters
in that grapheme. The reverse is true for a left-to-right line.
-}
layoutLineXToIndex ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    LayoutLine
    {- ^ /@line@/: a 'GI.Pango.Structs.LayoutLine.LayoutLine' -}
    -> Int32
    {- ^ /@xPos@/: the X offset (in Pango units)
            from the left edge of the line. -}
    -> m ((Bool, Int32, Int32))
    {- ^ __Returns:__ 'False' if /@xPos@/ was outside the line, 'True' if inside -}
layoutLineXToIndex line xPos = liftIO $ do
    line' <- unsafeManagedPtrGetPtr line
    index_ <- allocMem :: IO (Ptr Int32)
    trailing <- allocMem :: IO (Ptr Int32)
    result <- pango_layout_line_x_to_index line' xPos index_ trailing
    let result' = (/= 0) result
    index_' <- peek index_
    trailing' <- peek trailing
    touchManagedPtr line
    freeMem index_
    freeMem trailing
    return (result', index_', trailing')

#if ENABLE_OVERLOADING
data LayoutLineXToIndexMethodInfo
instance (signature ~ (Int32 -> m ((Bool, Int32, Int32))), MonadIO m) => O.MethodInfo LayoutLineXToIndexMethodInfo LayoutLine signature where
    overloadedMethod _ = layoutLineXToIndex

#endif

#if ENABLE_OVERLOADING
type family ResolveLayoutLineMethod (t :: Symbol) (o :: *) :: * where
    ResolveLayoutLineMethod "indexToX" o = LayoutLineIndexToXMethodInfo
    ResolveLayoutLineMethod "ref" o = LayoutLineRefMethodInfo
    ResolveLayoutLineMethod "unref" o = LayoutLineUnrefMethodInfo
    ResolveLayoutLineMethod "xToIndex" o = LayoutLineXToIndexMethodInfo
    ResolveLayoutLineMethod "getExtents" o = LayoutLineGetExtentsMethodInfo
    ResolveLayoutLineMethod "getPixelExtents" o = LayoutLineGetPixelExtentsMethodInfo
    ResolveLayoutLineMethod "getXRanges" o = LayoutLineGetXRangesMethodInfo
    ResolveLayoutLineMethod l o = O.MethodResolutionFailed l o

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

#endif