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

    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 \
           (!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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    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) => O.IsLabelProxy t (LayoutLine -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveLayoutLineMethod t LayoutLine, O.MethodInfo info LayoutLine p) => O.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

    #endif